1 // <auto-generated> 2 // Generated by the protocol buffer compiler. DO NOT EDIT! 3 // source: src/proto/grpc/testing/control.proto 4 // </auto-generated> 5 #pragma warning disable 1591, 0612, 3021 6 #region Designer generated code 7 8 using pb = global::Google.Protobuf; 9 using pbc = global::Google.Protobuf.Collections; 10 using pbr = global::Google.Protobuf.Reflection; 11 using scg = global::System.Collections.Generic; 12 namespace Grpc.Testing { 13 14 /// <summary>Holder for reflection information generated from src/proto/grpc/testing/control.proto</summary> 15 public static partial class ControlReflection { 16 17 #region Descriptor 18 /// <summary>File descriptor for src/proto/grpc/testing/control.proto</summary> 19 public static pbr::FileDescriptor Descriptor { 20 get { return descriptor; } 21 } 22 private static pbr::FileDescriptor descriptor; 23 ControlReflection()24 static ControlReflection() { 25 byte[] descriptorData = global::System.Convert.FromBase64String( 26 string.Concat( 27 "CiRzcmMvcHJvdG8vZ3JwYy90ZXN0aW5nL2NvbnRyb2wucHJvdG8SDGdycGMu", 28 "dGVzdGluZxolc3JjL3Byb3RvL2dycGMvdGVzdGluZy9wYXlsb2Fkcy5wcm90", 29 "bxoic3JjL3Byb3RvL2dycGMvdGVzdGluZy9zdGF0cy5wcm90byIlCg1Qb2lz", 30 "c29uUGFyYW1zEhQKDG9mZmVyZWRfbG9hZBgBIAEoASISChBDbG9zZWRMb29w", 31 "UGFyYW1zInsKCkxvYWRQYXJhbXMSNQoLY2xvc2VkX2xvb3AYASABKAsyHi5n", 32 "cnBjLnRlc3RpbmcuQ2xvc2VkTG9vcFBhcmFtc0gAEi4KB3BvaXNzb24YAiAB", 33 "KAsyGy5ncnBjLnRlc3RpbmcuUG9pc3NvblBhcmFtc0gAQgYKBGxvYWQiVgoO", 34 "U2VjdXJpdHlQYXJhbXMSEwoLdXNlX3Rlc3RfY2EYASABKAgSHAoUc2VydmVy", 35 "X2hvc3Rfb3ZlcnJpZGUYAiABKAkSEQoJY3JlZF90eXBlGAMgASgJIk0KCkNo", 36 "YW5uZWxBcmcSDAoEbmFtZRgBIAEoCRITCglzdHJfdmFsdWUYAiABKAlIABIT", 37 "CglpbnRfdmFsdWUYAyABKAVIAEIHCgV2YWx1ZSK8BQoMQ2xpZW50Q29uZmln", 38 "EhYKDnNlcnZlcl90YXJnZXRzGAEgAygJEi0KC2NsaWVudF90eXBlGAIgASgO", 39 "MhguZ3JwYy50ZXN0aW5nLkNsaWVudFR5cGUSNQoPc2VjdXJpdHlfcGFyYW1z", 40 "GAMgASgLMhwuZ3JwYy50ZXN0aW5nLlNlY3VyaXR5UGFyYW1zEiQKHG91dHN0", 41 "YW5kaW5nX3JwY3NfcGVyX2NoYW5uZWwYBCABKAUSFwoPY2xpZW50X2NoYW5u", 42 "ZWxzGAUgASgFEhwKFGFzeW5jX2NsaWVudF90aHJlYWRzGAcgASgFEicKCHJw", 43 "Y190eXBlGAggASgOMhUuZ3JwYy50ZXN0aW5nLlJwY1R5cGUSLQoLbG9hZF9w", 44 "YXJhbXMYCiABKAsyGC5ncnBjLnRlc3RpbmcuTG9hZFBhcmFtcxIzCg5wYXls", 45 "b2FkX2NvbmZpZxgLIAEoCzIbLmdycGMudGVzdGluZy5QYXlsb2FkQ29uZmln", 46 "EjcKEGhpc3RvZ3JhbV9wYXJhbXMYDCABKAsyHS5ncnBjLnRlc3RpbmcuSGlz", 47 "dG9ncmFtUGFyYW1zEhEKCWNvcmVfbGlzdBgNIAMoBRISCgpjb3JlX2xpbWl0", 48 "GA4gASgFEhgKEG90aGVyX2NsaWVudF9hcGkYDyABKAkSLgoMY2hhbm5lbF9h", 49 "cmdzGBAgAygLMhguZ3JwYy50ZXN0aW5nLkNoYW5uZWxBcmcSFgoOdGhyZWFk", 50 "c19wZXJfY3EYESABKAUSGwoTbWVzc2FnZXNfcGVyX3N0cmVhbRgSIAEoBRIY", 51 "ChB1c2VfY29hbGVzY2VfYXBpGBMgASgIEjEKKW1lZGlhbl9sYXRlbmN5X2Nv", 52 "bGxlY3Rpb25faW50ZXJ2YWxfbWlsbGlzGBQgASgFEhgKEGNsaWVudF9wcm9j", 53 "ZXNzZXMYFSABKAUiOAoMQ2xpZW50U3RhdHVzEigKBXN0YXRzGAEgASgLMhku", 54 "Z3JwYy50ZXN0aW5nLkNsaWVudFN0YXRzIhUKBE1hcmsSDQoFcmVzZXQYASAB", 55 "KAgiaAoKQ2xpZW50QXJncxIrCgVzZXR1cBgBIAEoCzIaLmdycGMudGVzdGlu", 56 "Zy5DbGllbnRDb25maWdIABIiCgRtYXJrGAIgASgLMhIuZ3JwYy50ZXN0aW5n", 57 "Lk1hcmtIAEIJCgdhcmd0eXBlIpcDCgxTZXJ2ZXJDb25maWcSLQoLc2VydmVy", 58 "X3R5cGUYASABKA4yGC5ncnBjLnRlc3RpbmcuU2VydmVyVHlwZRI1Cg9zZWN1", 59 "cml0eV9wYXJhbXMYAiABKAsyHC5ncnBjLnRlc3RpbmcuU2VjdXJpdHlQYXJh", 60 "bXMSDAoEcG9ydBgEIAEoBRIcChRhc3luY19zZXJ2ZXJfdGhyZWFkcxgHIAEo", 61 "BRISCgpjb3JlX2xpbWl0GAggASgFEjMKDnBheWxvYWRfY29uZmlnGAkgASgL", 62 "MhsuZ3JwYy50ZXN0aW5nLlBheWxvYWRDb25maWcSEQoJY29yZV9saXN0GAog", 63 "AygFEhgKEG90aGVyX3NlcnZlcl9hcGkYCyABKAkSFgoOdGhyZWFkc19wZXJf", 64 "Y3EYDCABKAUSHAoTcmVzb3VyY2VfcXVvdGFfc2l6ZRjpByABKAUSLwoMY2hh", 65 "bm5lbF9hcmdzGOoHIAMoCzIYLmdycGMudGVzdGluZy5DaGFubmVsQXJnEhgK", 66 "EHNlcnZlcl9wcm9jZXNzZXMYFSABKAUiaAoKU2VydmVyQXJncxIrCgVzZXR1", 67 "cBgBIAEoCzIaLmdycGMudGVzdGluZy5TZXJ2ZXJDb25maWdIABIiCgRtYXJr", 68 "GAIgASgLMhIuZ3JwYy50ZXN0aW5nLk1hcmtIAEIJCgdhcmd0eXBlIlUKDFNl", 69 "cnZlclN0YXR1cxIoCgVzdGF0cxgBIAEoCzIZLmdycGMudGVzdGluZy5TZXJ2", 70 "ZXJTdGF0cxIMCgRwb3J0GAIgASgFEg0KBWNvcmVzGAMgASgFIg0KC0NvcmVS", 71 "ZXF1ZXN0Ih0KDENvcmVSZXNwb25zZRINCgVjb3JlcxgBIAEoBSIGCgRWb2lk", 72 "Iv0BCghTY2VuYXJpbxIMCgRuYW1lGAEgASgJEjEKDWNsaWVudF9jb25maWcY", 73 "AiABKAsyGi5ncnBjLnRlc3RpbmcuQ2xpZW50Q29uZmlnEhMKC251bV9jbGll", 74 "bnRzGAMgASgFEjEKDXNlcnZlcl9jb25maWcYBCABKAsyGi5ncnBjLnRlc3Rp", 75 "bmcuU2VydmVyQ29uZmlnEhMKC251bV9zZXJ2ZXJzGAUgASgFEhYKDndhcm11", 76 "cF9zZWNvbmRzGAYgASgFEhkKEWJlbmNobWFya19zZWNvbmRzGAcgASgFEiAK", 77 "GHNwYXduX2xvY2FsX3dvcmtlcl9jb3VudBgIIAEoBSI2CglTY2VuYXJpb3MS", 78 "KQoJc2NlbmFyaW9zGAEgAygLMhYuZ3JwYy50ZXN0aW5nLlNjZW5hcmlvIoQE", 79 "ChVTY2VuYXJpb1Jlc3VsdFN1bW1hcnkSCwoDcXBzGAEgASgBEhsKE3Fwc19w", 80 "ZXJfc2VydmVyX2NvcmUYAiABKAESGgoSc2VydmVyX3N5c3RlbV90aW1lGAMg", 81 "ASgBEhgKEHNlcnZlcl91c2VyX3RpbWUYBCABKAESGgoSY2xpZW50X3N5c3Rl", 82 "bV90aW1lGAUgASgBEhgKEGNsaWVudF91c2VyX3RpbWUYBiABKAESEgoKbGF0", 83 "ZW5jeV81MBgHIAEoARISCgpsYXRlbmN5XzkwGAggASgBEhIKCmxhdGVuY3lf", 84 "OTUYCSABKAESEgoKbGF0ZW5jeV85ORgKIAEoARITCgtsYXRlbmN5Xzk5ORgL", 85 "IAEoARIYChBzZXJ2ZXJfY3B1X3VzYWdlGAwgASgBEiYKHnN1Y2Nlc3NmdWxf", 86 "cmVxdWVzdHNfcGVyX3NlY29uZBgNIAEoARIiChpmYWlsZWRfcmVxdWVzdHNf", 87 "cGVyX3NlY29uZBgOIAEoARIgChhjbGllbnRfcG9sbHNfcGVyX3JlcXVlc3QY", 88 "DyABKAESIAoYc2VydmVyX3BvbGxzX3Blcl9yZXF1ZXN0GBAgASgBEiIKGnNl", 89 "cnZlcl9xdWVyaWVzX3Blcl9jcHVfc2VjGBEgASgBEiIKGmNsaWVudF9xdWVy", 90 "aWVzX3Blcl9jcHVfc2VjGBIgASgBIoMDCg5TY2VuYXJpb1Jlc3VsdBIoCghz", 91 "Y2VuYXJpbxgBIAEoCzIWLmdycGMudGVzdGluZy5TY2VuYXJpbxIuCglsYXRl", 92 "bmNpZXMYAiABKAsyGy5ncnBjLnRlc3RpbmcuSGlzdG9ncmFtRGF0YRIvCgxj", 93 "bGllbnRfc3RhdHMYAyADKAsyGS5ncnBjLnRlc3RpbmcuQ2xpZW50U3RhdHMS", 94 "LwoMc2VydmVyX3N0YXRzGAQgAygLMhkuZ3JwYy50ZXN0aW5nLlNlcnZlclN0", 95 "YXRzEhQKDHNlcnZlcl9jb3JlcxgFIAMoBRI0CgdzdW1tYXJ5GAYgASgLMiMu", 96 "Z3JwYy50ZXN0aW5nLlNjZW5hcmlvUmVzdWx0U3VtbWFyeRIWCg5jbGllbnRf", 97 "c3VjY2VzcxgHIAMoCBIWCg5zZXJ2ZXJfc3VjY2VzcxgIIAMoCBI5Cg9yZXF1", 98 "ZXN0X3Jlc3VsdHMYCSADKAsyIC5ncnBjLnRlc3RpbmcuUmVxdWVzdFJlc3Vs", 99 "dENvdW50KlYKCkNsaWVudFR5cGUSDwoLU1lOQ19DTElFTlQQABIQCgxBU1lO", 100 "Q19DTElFTlQQARIQCgxPVEhFUl9DTElFTlQQAhITCg9DQUxMQkFDS19DTElF", 101 "TlQQAypwCgpTZXJ2ZXJUeXBlEg8KC1NZTkNfU0VSVkVSEAASEAoMQVNZTkNf", 102 "U0VSVkVSEAESGAoUQVNZTkNfR0VORVJJQ19TRVJWRVIQAhIQCgxPVEhFUl9T", 103 "RVJWRVIQAxITCg9DQUxMQkFDS19TRVJWRVIQBCpyCgdScGNUeXBlEgkKBVVO", 104 "QVJZEAASDQoJU1RSRUFNSU5HEAESGQoVU1RSRUFNSU5HX0ZST01fQ0xJRU5U", 105 "EAISGQoVU1RSRUFNSU5HX0ZST01fU0VSVkVSEAMSFwoTU1RSRUFNSU5HX0JP", 106 "VEhfV0FZUxAEYgZwcm90bzM=")); 107 descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, 108 new pbr::FileDescriptor[] { global::Grpc.Testing.PayloadsReflection.Descriptor, global::Grpc.Testing.StatsReflection.Descriptor, }, 109 new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Grpc.Testing.ClientType), typeof(global::Grpc.Testing.ServerType), typeof(global::Grpc.Testing.RpcType), }, null, new pbr::GeneratedClrTypeInfo[] { 110 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.PoissonParams), global::Grpc.Testing.PoissonParams.Parser, new[]{ "OfferedLoad" }, null, null, null, null), 111 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClosedLoopParams), global::Grpc.Testing.ClosedLoopParams.Parser, null, null, null, null, null), 112 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadParams), global::Grpc.Testing.LoadParams.Parser, new[]{ "ClosedLoop", "Poisson" }, new[]{ "Load" }, null, null, null), 113 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.SecurityParams), global::Grpc.Testing.SecurityParams.Parser, new[]{ "UseTestCa", "ServerHostOverride", "CredType" }, null, null, null, null), 114 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ChannelArg), global::Grpc.Testing.ChannelArg.Parser, new[]{ "Name", "StrValue", "IntValue" }, new[]{ "Value" }, null, null, null), 115 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientConfig), global::Grpc.Testing.ClientConfig.Parser, new[]{ "ServerTargets", "ClientType", "SecurityParams", "OutstandingRpcsPerChannel", "ClientChannels", "AsyncClientThreads", "RpcType", "LoadParams", "PayloadConfig", "HistogramParams", "CoreList", "CoreLimit", "OtherClientApi", "ChannelArgs", "ThreadsPerCq", "MessagesPerStream", "UseCoalesceApi", "MedianLatencyCollectionIntervalMillis", "ClientProcesses" }, null, null, null, null), 116 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientStatus), global::Grpc.Testing.ClientStatus.Parser, new[]{ "Stats" }, null, null, null, null), 117 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Mark), global::Grpc.Testing.Mark.Parser, new[]{ "Reset" }, null, null, null, null), 118 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientArgs), global::Grpc.Testing.ClientArgs.Parser, new[]{ "Setup", "Mark" }, new[]{ "Argtype" }, null, null, null), 119 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ServerConfig), global::Grpc.Testing.ServerConfig.Parser, new[]{ "ServerType", "SecurityParams", "Port", "AsyncServerThreads", "CoreLimit", "PayloadConfig", "CoreList", "OtherServerApi", "ThreadsPerCq", "ResourceQuotaSize", "ChannelArgs", "ServerProcesses" }, null, null, null, null), 120 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ServerArgs), global::Grpc.Testing.ServerArgs.Parser, new[]{ "Setup", "Mark" }, new[]{ "Argtype" }, null, null, null), 121 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ServerStatus), global::Grpc.Testing.ServerStatus.Parser, new[]{ "Stats", "Port", "Cores" }, null, null, null, null), 122 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.CoreRequest), global::Grpc.Testing.CoreRequest.Parser, null, null, null, null, null), 123 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.CoreResponse), global::Grpc.Testing.CoreResponse.Parser, new[]{ "Cores" }, null, null, null, null), 124 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Void), global::Grpc.Testing.Void.Parser, null, null, null, null, null), 125 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Scenario), global::Grpc.Testing.Scenario.Parser, new[]{ "Name", "ClientConfig", "NumClients", "ServerConfig", "NumServers", "WarmupSeconds", "BenchmarkSeconds", "SpawnLocalWorkerCount" }, null, null, null, null), 126 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.Scenarios), global::Grpc.Testing.Scenarios.Parser, new[]{ "Scenarios_" }, null, null, null, null), 127 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ScenarioResultSummary), global::Grpc.Testing.ScenarioResultSummary.Parser, new[]{ "Qps", "QpsPerServerCore", "ServerSystemTime", "ServerUserTime", "ClientSystemTime", "ClientUserTime", "Latency50", "Latency90", "Latency95", "Latency99", "Latency999", "ServerCpuUsage", "SuccessfulRequestsPerSecond", "FailedRequestsPerSecond", "ClientPollsPerRequest", "ServerPollsPerRequest", "ServerQueriesPerCpuSec", "ClientQueriesPerCpuSec" }, null, null, null, null), 128 new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ScenarioResult), global::Grpc.Testing.ScenarioResult.Parser, new[]{ "Scenario", "Latencies", "ClientStats", "ServerStats", "ServerCores", "Summary", "ClientSuccess", "ServerSuccess", "RequestResults" }, null, null, null, null) 129 })); 130 } 131 #endregion 132 133 } 134 #region Enums 135 public enum ClientType { 136 /// <summary> 137 /// Many languages support a basic distinction between using 138 /// sync or async client, and this allows the specification 139 /// </summary> 140 [pbr::OriginalName("SYNC_CLIENT")] SyncClient = 0, 141 [pbr::OriginalName("ASYNC_CLIENT")] AsyncClient = 1, 142 /// <summary> 143 /// used for some language-specific variants 144 /// </summary> 145 [pbr::OriginalName("OTHER_CLIENT")] OtherClient = 2, 146 [pbr::OriginalName("CALLBACK_CLIENT")] CallbackClient = 3, 147 } 148 149 public enum ServerType { 150 [pbr::OriginalName("SYNC_SERVER")] SyncServer = 0, 151 [pbr::OriginalName("ASYNC_SERVER")] AsyncServer = 1, 152 [pbr::OriginalName("ASYNC_GENERIC_SERVER")] AsyncGenericServer = 2, 153 /// <summary> 154 /// used for some language-specific variants 155 /// </summary> 156 [pbr::OriginalName("OTHER_SERVER")] OtherServer = 3, 157 [pbr::OriginalName("CALLBACK_SERVER")] CallbackServer = 4, 158 } 159 160 public enum RpcType { 161 [pbr::OriginalName("UNARY")] Unary = 0, 162 [pbr::OriginalName("STREAMING")] Streaming = 1, 163 [pbr::OriginalName("STREAMING_FROM_CLIENT")] StreamingFromClient = 2, 164 [pbr::OriginalName("STREAMING_FROM_SERVER")] StreamingFromServer = 3, 165 [pbr::OriginalName("STREAMING_BOTH_WAYS")] StreamingBothWays = 4, 166 } 167 168 #endregion 169 170 #region Messages 171 /// <summary> 172 /// Parameters of poisson process distribution, which is a good representation 173 /// of activity coming in from independent identical stationary sources. 174 /// </summary> 175 public sealed partial class PoissonParams : pb::IMessage<PoissonParams> { 176 private static readonly pb::MessageParser<PoissonParams> _parser = new pb::MessageParser<PoissonParams>(() => new PoissonParams()); 177 private pb::UnknownFieldSet _unknownFields; 178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 179 public static pb::MessageParser<PoissonParams> Parser { get { return _parser; } } 180 181 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 182 public static pbr::MessageDescriptor Descriptor { 183 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[0]; } 184 } 185 186 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 187 pbr::MessageDescriptor pb::IMessage.Descriptor { 188 get { return Descriptor; } 189 } 190 191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] PoissonParams()192 public PoissonParams() { 193 OnConstruction(); 194 } 195 OnConstruction()196 partial void OnConstruction(); 197 198 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] PoissonParams(PoissonParams other)199 public PoissonParams(PoissonParams other) : this() { 200 offeredLoad_ = other.offeredLoad_; 201 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 202 } 203 204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()205 public PoissonParams Clone() { 206 return new PoissonParams(this); 207 } 208 209 /// <summary>Field number for the "offered_load" field.</summary> 210 public const int OfferedLoadFieldNumber = 1; 211 private double offeredLoad_; 212 /// <summary> 213 /// The rate of arrivals (a.k.a. lambda parameter of the exp distribution). 214 /// </summary> 215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 216 public double OfferedLoad { 217 get { return offeredLoad_; } 218 set { 219 offeredLoad_ = value; 220 } 221 } 222 223 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)224 public override bool Equals(object other) { 225 return Equals(other as PoissonParams); 226 } 227 228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(PoissonParams other)229 public bool Equals(PoissonParams other) { 230 if (ReferenceEquals(other, null)) { 231 return false; 232 } 233 if (ReferenceEquals(other, this)) { 234 return true; 235 } 236 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(OfferedLoad, other.OfferedLoad)) return false; 237 return Equals(_unknownFields, other._unknownFields); 238 } 239 240 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()241 public override int GetHashCode() { 242 int hash = 1; 243 if (OfferedLoad != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(OfferedLoad); 244 if (_unknownFields != null) { 245 hash ^= _unknownFields.GetHashCode(); 246 } 247 return hash; 248 } 249 250 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()251 public override string ToString() { 252 return pb::JsonFormatter.ToDiagnosticString(this); 253 } 254 255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)256 public void WriteTo(pb::CodedOutputStream output) { 257 if (OfferedLoad != 0D) { 258 output.WriteRawTag(9); 259 output.WriteDouble(OfferedLoad); 260 } 261 if (_unknownFields != null) { 262 _unknownFields.WriteTo(output); 263 } 264 } 265 266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()267 public int CalculateSize() { 268 int size = 0; 269 if (OfferedLoad != 0D) { 270 size += 1 + 8; 271 } 272 if (_unknownFields != null) { 273 size += _unknownFields.CalculateSize(); 274 } 275 return size; 276 } 277 278 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(PoissonParams other)279 public void MergeFrom(PoissonParams other) { 280 if (other == null) { 281 return; 282 } 283 if (other.OfferedLoad != 0D) { 284 OfferedLoad = other.OfferedLoad; 285 } 286 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 287 } 288 289 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)290 public void MergeFrom(pb::CodedInputStream input) { 291 uint tag; 292 while ((tag = input.ReadTag()) != 0) { 293 switch(tag) { 294 default: 295 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 296 break; 297 case 9: { 298 OfferedLoad = input.ReadDouble(); 299 break; 300 } 301 } 302 } 303 } 304 305 } 306 307 /// <summary> 308 /// Once an RPC finishes, immediately start a new one. 309 /// No configuration parameters needed. 310 /// </summary> 311 public sealed partial class ClosedLoopParams : pb::IMessage<ClosedLoopParams> { 312 private static readonly pb::MessageParser<ClosedLoopParams> _parser = new pb::MessageParser<ClosedLoopParams>(() => new ClosedLoopParams()); 313 private pb::UnknownFieldSet _unknownFields; 314 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 315 public static pb::MessageParser<ClosedLoopParams> Parser { get { return _parser; } } 316 317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 318 public static pbr::MessageDescriptor Descriptor { 319 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[1]; } 320 } 321 322 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 323 pbr::MessageDescriptor pb::IMessage.Descriptor { 324 get { return Descriptor; } 325 } 326 327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClosedLoopParams()328 public ClosedLoopParams() { 329 OnConstruction(); 330 } 331 OnConstruction()332 partial void OnConstruction(); 333 334 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClosedLoopParams(ClosedLoopParams other)335 public ClosedLoopParams(ClosedLoopParams other) : this() { 336 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 337 } 338 339 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()340 public ClosedLoopParams Clone() { 341 return new ClosedLoopParams(this); 342 } 343 344 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)345 public override bool Equals(object other) { 346 return Equals(other as ClosedLoopParams); 347 } 348 349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClosedLoopParams other)350 public bool Equals(ClosedLoopParams other) { 351 if (ReferenceEquals(other, null)) { 352 return false; 353 } 354 if (ReferenceEquals(other, this)) { 355 return true; 356 } 357 return Equals(_unknownFields, other._unknownFields); 358 } 359 360 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()361 public override int GetHashCode() { 362 int hash = 1; 363 if (_unknownFields != null) { 364 hash ^= _unknownFields.GetHashCode(); 365 } 366 return hash; 367 } 368 369 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()370 public override string ToString() { 371 return pb::JsonFormatter.ToDiagnosticString(this); 372 } 373 374 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)375 public void WriteTo(pb::CodedOutputStream output) { 376 if (_unknownFields != null) { 377 _unknownFields.WriteTo(output); 378 } 379 } 380 381 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()382 public int CalculateSize() { 383 int size = 0; 384 if (_unknownFields != null) { 385 size += _unknownFields.CalculateSize(); 386 } 387 return size; 388 } 389 390 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClosedLoopParams other)391 public void MergeFrom(ClosedLoopParams other) { 392 if (other == null) { 393 return; 394 } 395 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 396 } 397 398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)399 public void MergeFrom(pb::CodedInputStream input) { 400 uint tag; 401 while ((tag = input.ReadTag()) != 0) { 402 switch(tag) { 403 default: 404 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 405 break; 406 } 407 } 408 } 409 410 } 411 412 public sealed partial class LoadParams : pb::IMessage<LoadParams> { 413 private static readonly pb::MessageParser<LoadParams> _parser = new pb::MessageParser<LoadParams>(() => new LoadParams()); 414 private pb::UnknownFieldSet _unknownFields; 415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 416 public static pb::MessageParser<LoadParams> Parser { get { return _parser; } } 417 418 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 419 public static pbr::MessageDescriptor Descriptor { 420 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[2]; } 421 } 422 423 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 424 pbr::MessageDescriptor pb::IMessage.Descriptor { 425 get { return Descriptor; } 426 } 427 428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] LoadParams()429 public LoadParams() { 430 OnConstruction(); 431 } 432 OnConstruction()433 partial void OnConstruction(); 434 435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] LoadParams(LoadParams other)436 public LoadParams(LoadParams other) : this() { 437 switch (other.LoadCase) { 438 case LoadOneofCase.ClosedLoop: 439 ClosedLoop = other.ClosedLoop.Clone(); 440 break; 441 case LoadOneofCase.Poisson: 442 Poisson = other.Poisson.Clone(); 443 break; 444 } 445 446 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 447 } 448 449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()450 public LoadParams Clone() { 451 return new LoadParams(this); 452 } 453 454 /// <summary>Field number for the "closed_loop" field.</summary> 455 public const int ClosedLoopFieldNumber = 1; 456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 457 public global::Grpc.Testing.ClosedLoopParams ClosedLoop { 458 get { return loadCase_ == LoadOneofCase.ClosedLoop ? (global::Grpc.Testing.ClosedLoopParams) load_ : null; } 459 set { 460 load_ = value; 461 loadCase_ = value == null ? LoadOneofCase.None : LoadOneofCase.ClosedLoop; 462 } 463 } 464 465 /// <summary>Field number for the "poisson" field.</summary> 466 public const int PoissonFieldNumber = 2; 467 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 468 public global::Grpc.Testing.PoissonParams Poisson { 469 get { return loadCase_ == LoadOneofCase.Poisson ? (global::Grpc.Testing.PoissonParams) load_ : null; } 470 set { 471 load_ = value; 472 loadCase_ = value == null ? LoadOneofCase.None : LoadOneofCase.Poisson; 473 } 474 } 475 476 private object load_; 477 /// <summary>Enum of possible cases for the "load" oneof.</summary> 478 public enum LoadOneofCase { 479 None = 0, 480 ClosedLoop = 1, 481 Poisson = 2, 482 } 483 private LoadOneofCase loadCase_ = LoadOneofCase.None; 484 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 485 public LoadOneofCase LoadCase { 486 get { return loadCase_; } 487 } 488 489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearLoad()490 public void ClearLoad() { 491 loadCase_ = LoadOneofCase.None; 492 load_ = null; 493 } 494 495 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)496 public override bool Equals(object other) { 497 return Equals(other as LoadParams); 498 } 499 500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(LoadParams other)501 public bool Equals(LoadParams other) { 502 if (ReferenceEquals(other, null)) { 503 return false; 504 } 505 if (ReferenceEquals(other, this)) { 506 return true; 507 } 508 if (!object.Equals(ClosedLoop, other.ClosedLoop)) return false; 509 if (!object.Equals(Poisson, other.Poisson)) return false; 510 if (LoadCase != other.LoadCase) return false; 511 return Equals(_unknownFields, other._unknownFields); 512 } 513 514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()515 public override int GetHashCode() { 516 int hash = 1; 517 if (loadCase_ == LoadOneofCase.ClosedLoop) hash ^= ClosedLoop.GetHashCode(); 518 if (loadCase_ == LoadOneofCase.Poisson) hash ^= Poisson.GetHashCode(); 519 hash ^= (int) loadCase_; 520 if (_unknownFields != null) { 521 hash ^= _unknownFields.GetHashCode(); 522 } 523 return hash; 524 } 525 526 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()527 public override string ToString() { 528 return pb::JsonFormatter.ToDiagnosticString(this); 529 } 530 531 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)532 public void WriteTo(pb::CodedOutputStream output) { 533 if (loadCase_ == LoadOneofCase.ClosedLoop) { 534 output.WriteRawTag(10); 535 output.WriteMessage(ClosedLoop); 536 } 537 if (loadCase_ == LoadOneofCase.Poisson) { 538 output.WriteRawTag(18); 539 output.WriteMessage(Poisson); 540 } 541 if (_unknownFields != null) { 542 _unknownFields.WriteTo(output); 543 } 544 } 545 546 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()547 public int CalculateSize() { 548 int size = 0; 549 if (loadCase_ == LoadOneofCase.ClosedLoop) { 550 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClosedLoop); 551 } 552 if (loadCase_ == LoadOneofCase.Poisson) { 553 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Poisson); 554 } 555 if (_unknownFields != null) { 556 size += _unknownFields.CalculateSize(); 557 } 558 return size; 559 } 560 561 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(LoadParams other)562 public void MergeFrom(LoadParams other) { 563 if (other == null) { 564 return; 565 } 566 switch (other.LoadCase) { 567 case LoadOneofCase.ClosedLoop: 568 if (ClosedLoop == null) { 569 ClosedLoop = new global::Grpc.Testing.ClosedLoopParams(); 570 } 571 ClosedLoop.MergeFrom(other.ClosedLoop); 572 break; 573 case LoadOneofCase.Poisson: 574 if (Poisson == null) { 575 Poisson = new global::Grpc.Testing.PoissonParams(); 576 } 577 Poisson.MergeFrom(other.Poisson); 578 break; 579 } 580 581 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 582 } 583 584 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)585 public void MergeFrom(pb::CodedInputStream input) { 586 uint tag; 587 while ((tag = input.ReadTag()) != 0) { 588 switch(tag) { 589 default: 590 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 591 break; 592 case 10: { 593 global::Grpc.Testing.ClosedLoopParams subBuilder = new global::Grpc.Testing.ClosedLoopParams(); 594 if (loadCase_ == LoadOneofCase.ClosedLoop) { 595 subBuilder.MergeFrom(ClosedLoop); 596 } 597 input.ReadMessage(subBuilder); 598 ClosedLoop = subBuilder; 599 break; 600 } 601 case 18: { 602 global::Grpc.Testing.PoissonParams subBuilder = new global::Grpc.Testing.PoissonParams(); 603 if (loadCase_ == LoadOneofCase.Poisson) { 604 subBuilder.MergeFrom(Poisson); 605 } 606 input.ReadMessage(subBuilder); 607 Poisson = subBuilder; 608 break; 609 } 610 } 611 } 612 } 613 614 } 615 616 /// <summary> 617 /// presence of SecurityParams implies use of TLS 618 /// </summary> 619 public sealed partial class SecurityParams : pb::IMessage<SecurityParams> { 620 private static readonly pb::MessageParser<SecurityParams> _parser = new pb::MessageParser<SecurityParams>(() => new SecurityParams()); 621 private pb::UnknownFieldSet _unknownFields; 622 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 623 public static pb::MessageParser<SecurityParams> Parser { get { return _parser; } } 624 625 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 626 public static pbr::MessageDescriptor Descriptor { 627 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[3]; } 628 } 629 630 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 631 pbr::MessageDescriptor pb::IMessage.Descriptor { 632 get { return Descriptor; } 633 } 634 635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] SecurityParams()636 public SecurityParams() { 637 OnConstruction(); 638 } 639 OnConstruction()640 partial void OnConstruction(); 641 642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] SecurityParams(SecurityParams other)643 public SecurityParams(SecurityParams other) : this() { 644 useTestCa_ = other.useTestCa_; 645 serverHostOverride_ = other.serverHostOverride_; 646 credType_ = other.credType_; 647 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 648 } 649 650 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()651 public SecurityParams Clone() { 652 return new SecurityParams(this); 653 } 654 655 /// <summary>Field number for the "use_test_ca" field.</summary> 656 public const int UseTestCaFieldNumber = 1; 657 private bool useTestCa_; 658 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 659 public bool UseTestCa { 660 get { return useTestCa_; } 661 set { 662 useTestCa_ = value; 663 } 664 } 665 666 /// <summary>Field number for the "server_host_override" field.</summary> 667 public const int ServerHostOverrideFieldNumber = 2; 668 private string serverHostOverride_ = ""; 669 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 670 public string ServerHostOverride { 671 get { return serverHostOverride_; } 672 set { 673 serverHostOverride_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 674 } 675 } 676 677 /// <summary>Field number for the "cred_type" field.</summary> 678 public const int CredTypeFieldNumber = 3; 679 private string credType_ = ""; 680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 681 public string CredType { 682 get { return credType_; } 683 set { 684 credType_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 685 } 686 } 687 688 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)689 public override bool Equals(object other) { 690 return Equals(other as SecurityParams); 691 } 692 693 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(SecurityParams other)694 public bool Equals(SecurityParams other) { 695 if (ReferenceEquals(other, null)) { 696 return false; 697 } 698 if (ReferenceEquals(other, this)) { 699 return true; 700 } 701 if (UseTestCa != other.UseTestCa) return false; 702 if (ServerHostOverride != other.ServerHostOverride) return false; 703 if (CredType != other.CredType) return false; 704 return Equals(_unknownFields, other._unknownFields); 705 } 706 707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()708 public override int GetHashCode() { 709 int hash = 1; 710 if (UseTestCa != false) hash ^= UseTestCa.GetHashCode(); 711 if (ServerHostOverride.Length != 0) hash ^= ServerHostOverride.GetHashCode(); 712 if (CredType.Length != 0) hash ^= CredType.GetHashCode(); 713 if (_unknownFields != null) { 714 hash ^= _unknownFields.GetHashCode(); 715 } 716 return hash; 717 } 718 719 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()720 public override string ToString() { 721 return pb::JsonFormatter.ToDiagnosticString(this); 722 } 723 724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)725 public void WriteTo(pb::CodedOutputStream output) { 726 if (UseTestCa != false) { 727 output.WriteRawTag(8); 728 output.WriteBool(UseTestCa); 729 } 730 if (ServerHostOverride.Length != 0) { 731 output.WriteRawTag(18); 732 output.WriteString(ServerHostOverride); 733 } 734 if (CredType.Length != 0) { 735 output.WriteRawTag(26); 736 output.WriteString(CredType); 737 } 738 if (_unknownFields != null) { 739 _unknownFields.WriteTo(output); 740 } 741 } 742 743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()744 public int CalculateSize() { 745 int size = 0; 746 if (UseTestCa != false) { 747 size += 1 + 1; 748 } 749 if (ServerHostOverride.Length != 0) { 750 size += 1 + pb::CodedOutputStream.ComputeStringSize(ServerHostOverride); 751 } 752 if (CredType.Length != 0) { 753 size += 1 + pb::CodedOutputStream.ComputeStringSize(CredType); 754 } 755 if (_unknownFields != null) { 756 size += _unknownFields.CalculateSize(); 757 } 758 return size; 759 } 760 761 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(SecurityParams other)762 public void MergeFrom(SecurityParams other) { 763 if (other == null) { 764 return; 765 } 766 if (other.UseTestCa != false) { 767 UseTestCa = other.UseTestCa; 768 } 769 if (other.ServerHostOverride.Length != 0) { 770 ServerHostOverride = other.ServerHostOverride; 771 } 772 if (other.CredType.Length != 0) { 773 CredType = other.CredType; 774 } 775 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 776 } 777 778 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)779 public void MergeFrom(pb::CodedInputStream input) { 780 uint tag; 781 while ((tag = input.ReadTag()) != 0) { 782 switch(tag) { 783 default: 784 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 785 break; 786 case 8: { 787 UseTestCa = input.ReadBool(); 788 break; 789 } 790 case 18: { 791 ServerHostOverride = input.ReadString(); 792 break; 793 } 794 case 26: { 795 CredType = input.ReadString(); 796 break; 797 } 798 } 799 } 800 } 801 802 } 803 804 public sealed partial class ChannelArg : pb::IMessage<ChannelArg> { 805 private static readonly pb::MessageParser<ChannelArg> _parser = new pb::MessageParser<ChannelArg>(() => new ChannelArg()); 806 private pb::UnknownFieldSet _unknownFields; 807 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 808 public static pb::MessageParser<ChannelArg> Parser { get { return _parser; } } 809 810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 811 public static pbr::MessageDescriptor Descriptor { 812 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[4]; } 813 } 814 815 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 816 pbr::MessageDescriptor pb::IMessage.Descriptor { 817 get { return Descriptor; } 818 } 819 820 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ChannelArg()821 public ChannelArg() { 822 OnConstruction(); 823 } 824 OnConstruction()825 partial void OnConstruction(); 826 827 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ChannelArg(ChannelArg other)828 public ChannelArg(ChannelArg other) : this() { 829 name_ = other.name_; 830 switch (other.ValueCase) { 831 case ValueOneofCase.StrValue: 832 StrValue = other.StrValue; 833 break; 834 case ValueOneofCase.IntValue: 835 IntValue = other.IntValue; 836 break; 837 } 838 839 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 840 } 841 842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()843 public ChannelArg Clone() { 844 return new ChannelArg(this); 845 } 846 847 /// <summary>Field number for the "name" field.</summary> 848 public const int NameFieldNumber = 1; 849 private string name_ = ""; 850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 851 public string Name { 852 get { return name_; } 853 set { 854 name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 855 } 856 } 857 858 /// <summary>Field number for the "str_value" field.</summary> 859 public const int StrValueFieldNumber = 2; 860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 861 public string StrValue { 862 get { return valueCase_ == ValueOneofCase.StrValue ? (string) value_ : ""; } 863 set { 864 value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 865 valueCase_ = ValueOneofCase.StrValue; 866 } 867 } 868 869 /// <summary>Field number for the "int_value" field.</summary> 870 public const int IntValueFieldNumber = 3; 871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 872 public int IntValue { 873 get { return valueCase_ == ValueOneofCase.IntValue ? (int) value_ : 0; } 874 set { 875 value_ = value; 876 valueCase_ = ValueOneofCase.IntValue; 877 } 878 } 879 880 private object value_; 881 /// <summary>Enum of possible cases for the "value" oneof.</summary> 882 public enum ValueOneofCase { 883 None = 0, 884 StrValue = 2, 885 IntValue = 3, 886 } 887 private ValueOneofCase valueCase_ = ValueOneofCase.None; 888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 889 public ValueOneofCase ValueCase { 890 get { return valueCase_; } 891 } 892 893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearValue()894 public void ClearValue() { 895 valueCase_ = ValueOneofCase.None; 896 value_ = null; 897 } 898 899 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)900 public override bool Equals(object other) { 901 return Equals(other as ChannelArg); 902 } 903 904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ChannelArg other)905 public bool Equals(ChannelArg other) { 906 if (ReferenceEquals(other, null)) { 907 return false; 908 } 909 if (ReferenceEquals(other, this)) { 910 return true; 911 } 912 if (Name != other.Name) return false; 913 if (StrValue != other.StrValue) return false; 914 if (IntValue != other.IntValue) return false; 915 if (ValueCase != other.ValueCase) return false; 916 return Equals(_unknownFields, other._unknownFields); 917 } 918 919 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()920 public override int GetHashCode() { 921 int hash = 1; 922 if (Name.Length != 0) hash ^= Name.GetHashCode(); 923 if (valueCase_ == ValueOneofCase.StrValue) hash ^= StrValue.GetHashCode(); 924 if (valueCase_ == ValueOneofCase.IntValue) hash ^= IntValue.GetHashCode(); 925 hash ^= (int) valueCase_; 926 if (_unknownFields != null) { 927 hash ^= _unknownFields.GetHashCode(); 928 } 929 return hash; 930 } 931 932 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()933 public override string ToString() { 934 return pb::JsonFormatter.ToDiagnosticString(this); 935 } 936 937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)938 public void WriteTo(pb::CodedOutputStream output) { 939 if (Name.Length != 0) { 940 output.WriteRawTag(10); 941 output.WriteString(Name); 942 } 943 if (valueCase_ == ValueOneofCase.StrValue) { 944 output.WriteRawTag(18); 945 output.WriteString(StrValue); 946 } 947 if (valueCase_ == ValueOneofCase.IntValue) { 948 output.WriteRawTag(24); 949 output.WriteInt32(IntValue); 950 } 951 if (_unknownFields != null) { 952 _unknownFields.WriteTo(output); 953 } 954 } 955 956 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()957 public int CalculateSize() { 958 int size = 0; 959 if (Name.Length != 0) { 960 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); 961 } 962 if (valueCase_ == ValueOneofCase.StrValue) { 963 size += 1 + pb::CodedOutputStream.ComputeStringSize(StrValue); 964 } 965 if (valueCase_ == ValueOneofCase.IntValue) { 966 size += 1 + pb::CodedOutputStream.ComputeInt32Size(IntValue); 967 } 968 if (_unknownFields != null) { 969 size += _unknownFields.CalculateSize(); 970 } 971 return size; 972 } 973 974 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ChannelArg other)975 public void MergeFrom(ChannelArg other) { 976 if (other == null) { 977 return; 978 } 979 if (other.Name.Length != 0) { 980 Name = other.Name; 981 } 982 switch (other.ValueCase) { 983 case ValueOneofCase.StrValue: 984 StrValue = other.StrValue; 985 break; 986 case ValueOneofCase.IntValue: 987 IntValue = other.IntValue; 988 break; 989 } 990 991 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 992 } 993 994 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)995 public void MergeFrom(pb::CodedInputStream input) { 996 uint tag; 997 while ((tag = input.ReadTag()) != 0) { 998 switch(tag) { 999 default: 1000 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 1001 break; 1002 case 10: { 1003 Name = input.ReadString(); 1004 break; 1005 } 1006 case 18: { 1007 StrValue = input.ReadString(); 1008 break; 1009 } 1010 case 24: { 1011 IntValue = input.ReadInt32(); 1012 break; 1013 } 1014 } 1015 } 1016 } 1017 1018 } 1019 1020 public sealed partial class ClientConfig : pb::IMessage<ClientConfig> { 1021 private static readonly pb::MessageParser<ClientConfig> _parser = new pb::MessageParser<ClientConfig>(() => new ClientConfig()); 1022 private pb::UnknownFieldSet _unknownFields; 1023 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1024 public static pb::MessageParser<ClientConfig> Parser { get { return _parser; } } 1025 1026 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1027 public static pbr::MessageDescriptor Descriptor { 1028 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[5]; } 1029 } 1030 1031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1032 pbr::MessageDescriptor pb::IMessage.Descriptor { 1033 get { return Descriptor; } 1034 } 1035 1036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientConfig()1037 public ClientConfig() { 1038 OnConstruction(); 1039 } 1040 OnConstruction()1041 partial void OnConstruction(); 1042 1043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientConfig(ClientConfig other)1044 public ClientConfig(ClientConfig other) : this() { 1045 serverTargets_ = other.serverTargets_.Clone(); 1046 clientType_ = other.clientType_; 1047 securityParams_ = other.securityParams_ != null ? other.securityParams_.Clone() : null; 1048 outstandingRpcsPerChannel_ = other.outstandingRpcsPerChannel_; 1049 clientChannels_ = other.clientChannels_; 1050 asyncClientThreads_ = other.asyncClientThreads_; 1051 rpcType_ = other.rpcType_; 1052 loadParams_ = other.loadParams_ != null ? other.loadParams_.Clone() : null; 1053 payloadConfig_ = other.payloadConfig_ != null ? other.payloadConfig_.Clone() : null; 1054 histogramParams_ = other.histogramParams_ != null ? other.histogramParams_.Clone() : null; 1055 coreList_ = other.coreList_.Clone(); 1056 coreLimit_ = other.coreLimit_; 1057 otherClientApi_ = other.otherClientApi_; 1058 channelArgs_ = other.channelArgs_.Clone(); 1059 threadsPerCq_ = other.threadsPerCq_; 1060 messagesPerStream_ = other.messagesPerStream_; 1061 useCoalesceApi_ = other.useCoalesceApi_; 1062 medianLatencyCollectionIntervalMillis_ = other.medianLatencyCollectionIntervalMillis_; 1063 clientProcesses_ = other.clientProcesses_; 1064 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 1065 } 1066 1067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()1068 public ClientConfig Clone() { 1069 return new ClientConfig(this); 1070 } 1071 1072 /// <summary>Field number for the "server_targets" field.</summary> 1073 public const int ServerTargetsFieldNumber = 1; 1074 private static readonly pb::FieldCodec<string> _repeated_serverTargets_codec 1075 = pb::FieldCodec.ForString(10); 1076 private readonly pbc::RepeatedField<string> serverTargets_ = new pbc::RepeatedField<string>(); 1077 /// <summary> 1078 /// List of targets to connect to. At least one target needs to be specified. 1079 /// </summary> 1080 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1081 public pbc::RepeatedField<string> ServerTargets { 1082 get { return serverTargets_; } 1083 } 1084 1085 /// <summary>Field number for the "client_type" field.</summary> 1086 public const int ClientTypeFieldNumber = 2; 1087 private global::Grpc.Testing.ClientType clientType_ = global::Grpc.Testing.ClientType.SyncClient; 1088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1089 public global::Grpc.Testing.ClientType ClientType { 1090 get { return clientType_; } 1091 set { 1092 clientType_ = value; 1093 } 1094 } 1095 1096 /// <summary>Field number for the "security_params" field.</summary> 1097 public const int SecurityParamsFieldNumber = 3; 1098 private global::Grpc.Testing.SecurityParams securityParams_; 1099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1100 public global::Grpc.Testing.SecurityParams SecurityParams { 1101 get { return securityParams_; } 1102 set { 1103 securityParams_ = value; 1104 } 1105 } 1106 1107 /// <summary>Field number for the "outstanding_rpcs_per_channel" field.</summary> 1108 public const int OutstandingRpcsPerChannelFieldNumber = 4; 1109 private int outstandingRpcsPerChannel_; 1110 /// <summary> 1111 /// How many concurrent RPCs to start for each channel. 1112 /// For synchronous client, use a separate thread for each outstanding RPC. 1113 /// </summary> 1114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1115 public int OutstandingRpcsPerChannel { 1116 get { return outstandingRpcsPerChannel_; } 1117 set { 1118 outstandingRpcsPerChannel_ = value; 1119 } 1120 } 1121 1122 /// <summary>Field number for the "client_channels" field.</summary> 1123 public const int ClientChannelsFieldNumber = 5; 1124 private int clientChannels_; 1125 /// <summary> 1126 /// Number of independent client channels to create. 1127 /// i-th channel will connect to server_target[i % server_targets.size()] 1128 /// </summary> 1129 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1130 public int ClientChannels { 1131 get { return clientChannels_; } 1132 set { 1133 clientChannels_ = value; 1134 } 1135 } 1136 1137 /// <summary>Field number for the "async_client_threads" field.</summary> 1138 public const int AsyncClientThreadsFieldNumber = 7; 1139 private int asyncClientThreads_; 1140 /// <summary> 1141 /// Only for async client. Number of threads to use to start/manage RPCs. 1142 /// </summary> 1143 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1144 public int AsyncClientThreads { 1145 get { return asyncClientThreads_; } 1146 set { 1147 asyncClientThreads_ = value; 1148 } 1149 } 1150 1151 /// <summary>Field number for the "rpc_type" field.</summary> 1152 public const int RpcTypeFieldNumber = 8; 1153 private global::Grpc.Testing.RpcType rpcType_ = global::Grpc.Testing.RpcType.Unary; 1154 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1155 public global::Grpc.Testing.RpcType RpcType { 1156 get { return rpcType_; } 1157 set { 1158 rpcType_ = value; 1159 } 1160 } 1161 1162 /// <summary>Field number for the "load_params" field.</summary> 1163 public const int LoadParamsFieldNumber = 10; 1164 private global::Grpc.Testing.LoadParams loadParams_; 1165 /// <summary> 1166 /// The requested load for the entire client (aggregated over all the threads). 1167 /// </summary> 1168 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1169 public global::Grpc.Testing.LoadParams LoadParams { 1170 get { return loadParams_; } 1171 set { 1172 loadParams_ = value; 1173 } 1174 } 1175 1176 /// <summary>Field number for the "payload_config" field.</summary> 1177 public const int PayloadConfigFieldNumber = 11; 1178 private global::Grpc.Testing.PayloadConfig payloadConfig_; 1179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1180 public global::Grpc.Testing.PayloadConfig PayloadConfig { 1181 get { return payloadConfig_; } 1182 set { 1183 payloadConfig_ = value; 1184 } 1185 } 1186 1187 /// <summary>Field number for the "histogram_params" field.</summary> 1188 public const int HistogramParamsFieldNumber = 12; 1189 private global::Grpc.Testing.HistogramParams histogramParams_; 1190 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1191 public global::Grpc.Testing.HistogramParams HistogramParams { 1192 get { return histogramParams_; } 1193 set { 1194 histogramParams_ = value; 1195 } 1196 } 1197 1198 /// <summary>Field number for the "core_list" field.</summary> 1199 public const int CoreListFieldNumber = 13; 1200 private static readonly pb::FieldCodec<int> _repeated_coreList_codec 1201 = pb::FieldCodec.ForInt32(106); 1202 private readonly pbc::RepeatedField<int> coreList_ = new pbc::RepeatedField<int>(); 1203 /// <summary> 1204 /// Specify the cores we should run the client on, if desired 1205 /// </summary> 1206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1207 public pbc::RepeatedField<int> CoreList { 1208 get { return coreList_; } 1209 } 1210 1211 /// <summary>Field number for the "core_limit" field.</summary> 1212 public const int CoreLimitFieldNumber = 14; 1213 private int coreLimit_; 1214 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1215 public int CoreLimit { 1216 get { return coreLimit_; } 1217 set { 1218 coreLimit_ = value; 1219 } 1220 } 1221 1222 /// <summary>Field number for the "other_client_api" field.</summary> 1223 public const int OtherClientApiFieldNumber = 15; 1224 private string otherClientApi_ = ""; 1225 /// <summary> 1226 /// If we use an OTHER_CLIENT client_type, this string gives more detail 1227 /// </summary> 1228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1229 public string OtherClientApi { 1230 get { return otherClientApi_; } 1231 set { 1232 otherClientApi_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 1233 } 1234 } 1235 1236 /// <summary>Field number for the "channel_args" field.</summary> 1237 public const int ChannelArgsFieldNumber = 16; 1238 private static readonly pb::FieldCodec<global::Grpc.Testing.ChannelArg> _repeated_channelArgs_codec 1239 = pb::FieldCodec.ForMessage(130, global::Grpc.Testing.ChannelArg.Parser); 1240 private readonly pbc::RepeatedField<global::Grpc.Testing.ChannelArg> channelArgs_ = new pbc::RepeatedField<global::Grpc.Testing.ChannelArg>(); 1241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1242 public pbc::RepeatedField<global::Grpc.Testing.ChannelArg> ChannelArgs { 1243 get { return channelArgs_; } 1244 } 1245 1246 /// <summary>Field number for the "threads_per_cq" field.</summary> 1247 public const int ThreadsPerCqFieldNumber = 17; 1248 private int threadsPerCq_; 1249 /// <summary> 1250 /// Number of threads that share each completion queue 1251 /// </summary> 1252 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1253 public int ThreadsPerCq { 1254 get { return threadsPerCq_; } 1255 set { 1256 threadsPerCq_ = value; 1257 } 1258 } 1259 1260 /// <summary>Field number for the "messages_per_stream" field.</summary> 1261 public const int MessagesPerStreamFieldNumber = 18; 1262 private int messagesPerStream_; 1263 /// <summary> 1264 /// Number of messages on a stream before it gets finished/restarted 1265 /// </summary> 1266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1267 public int MessagesPerStream { 1268 get { return messagesPerStream_; } 1269 set { 1270 messagesPerStream_ = value; 1271 } 1272 } 1273 1274 /// <summary>Field number for the "use_coalesce_api" field.</summary> 1275 public const int UseCoalesceApiFieldNumber = 19; 1276 private bool useCoalesceApi_; 1277 /// <summary> 1278 /// Use coalescing API when possible. 1279 /// </summary> 1280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1281 public bool UseCoalesceApi { 1282 get { return useCoalesceApi_; } 1283 set { 1284 useCoalesceApi_ = value; 1285 } 1286 } 1287 1288 /// <summary>Field number for the "median_latency_collection_interval_millis" field.</summary> 1289 public const int MedianLatencyCollectionIntervalMillisFieldNumber = 20; 1290 private int medianLatencyCollectionIntervalMillis_; 1291 /// <summary> 1292 /// If 0, disabled. Else, specifies the period between gathering latency 1293 /// medians in milliseconds. 1294 /// </summary> 1295 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1296 public int MedianLatencyCollectionIntervalMillis { 1297 get { return medianLatencyCollectionIntervalMillis_; } 1298 set { 1299 medianLatencyCollectionIntervalMillis_ = value; 1300 } 1301 } 1302 1303 /// <summary>Field number for the "client_processes" field.</summary> 1304 public const int ClientProcessesFieldNumber = 21; 1305 private int clientProcesses_; 1306 /// <summary> 1307 /// Number of client processes. 0 indicates no restriction. 1308 /// </summary> 1309 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1310 public int ClientProcesses { 1311 get { return clientProcesses_; } 1312 set { 1313 clientProcesses_ = value; 1314 } 1315 } 1316 1317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)1318 public override bool Equals(object other) { 1319 return Equals(other as ClientConfig); 1320 } 1321 1322 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClientConfig other)1323 public bool Equals(ClientConfig other) { 1324 if (ReferenceEquals(other, null)) { 1325 return false; 1326 } 1327 if (ReferenceEquals(other, this)) { 1328 return true; 1329 } 1330 if(!serverTargets_.Equals(other.serverTargets_)) return false; 1331 if (ClientType != other.ClientType) return false; 1332 if (!object.Equals(SecurityParams, other.SecurityParams)) return false; 1333 if (OutstandingRpcsPerChannel != other.OutstandingRpcsPerChannel) return false; 1334 if (ClientChannels != other.ClientChannels) return false; 1335 if (AsyncClientThreads != other.AsyncClientThreads) return false; 1336 if (RpcType != other.RpcType) return false; 1337 if (!object.Equals(LoadParams, other.LoadParams)) return false; 1338 if (!object.Equals(PayloadConfig, other.PayloadConfig)) return false; 1339 if (!object.Equals(HistogramParams, other.HistogramParams)) return false; 1340 if(!coreList_.Equals(other.coreList_)) return false; 1341 if (CoreLimit != other.CoreLimit) return false; 1342 if (OtherClientApi != other.OtherClientApi) return false; 1343 if(!channelArgs_.Equals(other.channelArgs_)) return false; 1344 if (ThreadsPerCq != other.ThreadsPerCq) return false; 1345 if (MessagesPerStream != other.MessagesPerStream) return false; 1346 if (UseCoalesceApi != other.UseCoalesceApi) return false; 1347 if (MedianLatencyCollectionIntervalMillis != other.MedianLatencyCollectionIntervalMillis) return false; 1348 if (ClientProcesses != other.ClientProcesses) return false; 1349 return Equals(_unknownFields, other._unknownFields); 1350 } 1351 1352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()1353 public override int GetHashCode() { 1354 int hash = 1; 1355 hash ^= serverTargets_.GetHashCode(); 1356 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) hash ^= ClientType.GetHashCode(); 1357 if (securityParams_ != null) hash ^= SecurityParams.GetHashCode(); 1358 if (OutstandingRpcsPerChannel != 0) hash ^= OutstandingRpcsPerChannel.GetHashCode(); 1359 if (ClientChannels != 0) hash ^= ClientChannels.GetHashCode(); 1360 if (AsyncClientThreads != 0) hash ^= AsyncClientThreads.GetHashCode(); 1361 if (RpcType != global::Grpc.Testing.RpcType.Unary) hash ^= RpcType.GetHashCode(); 1362 if (loadParams_ != null) hash ^= LoadParams.GetHashCode(); 1363 if (payloadConfig_ != null) hash ^= PayloadConfig.GetHashCode(); 1364 if (histogramParams_ != null) hash ^= HistogramParams.GetHashCode(); 1365 hash ^= coreList_.GetHashCode(); 1366 if (CoreLimit != 0) hash ^= CoreLimit.GetHashCode(); 1367 if (OtherClientApi.Length != 0) hash ^= OtherClientApi.GetHashCode(); 1368 hash ^= channelArgs_.GetHashCode(); 1369 if (ThreadsPerCq != 0) hash ^= ThreadsPerCq.GetHashCode(); 1370 if (MessagesPerStream != 0) hash ^= MessagesPerStream.GetHashCode(); 1371 if (UseCoalesceApi != false) hash ^= UseCoalesceApi.GetHashCode(); 1372 if (MedianLatencyCollectionIntervalMillis != 0) hash ^= MedianLatencyCollectionIntervalMillis.GetHashCode(); 1373 if (ClientProcesses != 0) hash ^= ClientProcesses.GetHashCode(); 1374 if (_unknownFields != null) { 1375 hash ^= _unknownFields.GetHashCode(); 1376 } 1377 return hash; 1378 } 1379 1380 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()1381 public override string ToString() { 1382 return pb::JsonFormatter.ToDiagnosticString(this); 1383 } 1384 1385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)1386 public void WriteTo(pb::CodedOutputStream output) { 1387 serverTargets_.WriteTo(output, _repeated_serverTargets_codec); 1388 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1389 output.WriteRawTag(16); 1390 output.WriteEnum((int) ClientType); 1391 } 1392 if (securityParams_ != null) { 1393 output.WriteRawTag(26); 1394 output.WriteMessage(SecurityParams); 1395 } 1396 if (OutstandingRpcsPerChannel != 0) { 1397 output.WriteRawTag(32); 1398 output.WriteInt32(OutstandingRpcsPerChannel); 1399 } 1400 if (ClientChannels != 0) { 1401 output.WriteRawTag(40); 1402 output.WriteInt32(ClientChannels); 1403 } 1404 if (AsyncClientThreads != 0) { 1405 output.WriteRawTag(56); 1406 output.WriteInt32(AsyncClientThreads); 1407 } 1408 if (RpcType != global::Grpc.Testing.RpcType.Unary) { 1409 output.WriteRawTag(64); 1410 output.WriteEnum((int) RpcType); 1411 } 1412 if (loadParams_ != null) { 1413 output.WriteRawTag(82); 1414 output.WriteMessage(LoadParams); 1415 } 1416 if (payloadConfig_ != null) { 1417 output.WriteRawTag(90); 1418 output.WriteMessage(PayloadConfig); 1419 } 1420 if (histogramParams_ != null) { 1421 output.WriteRawTag(98); 1422 output.WriteMessage(HistogramParams); 1423 } 1424 coreList_.WriteTo(output, _repeated_coreList_codec); 1425 if (CoreLimit != 0) { 1426 output.WriteRawTag(112); 1427 output.WriteInt32(CoreLimit); 1428 } 1429 if (OtherClientApi.Length != 0) { 1430 output.WriteRawTag(122); 1431 output.WriteString(OtherClientApi); 1432 } 1433 channelArgs_.WriteTo(output, _repeated_channelArgs_codec); 1434 if (ThreadsPerCq != 0) { 1435 output.WriteRawTag(136, 1); 1436 output.WriteInt32(ThreadsPerCq); 1437 } 1438 if (MessagesPerStream != 0) { 1439 output.WriteRawTag(144, 1); 1440 output.WriteInt32(MessagesPerStream); 1441 } 1442 if (UseCoalesceApi != false) { 1443 output.WriteRawTag(152, 1); 1444 output.WriteBool(UseCoalesceApi); 1445 } 1446 if (MedianLatencyCollectionIntervalMillis != 0) { 1447 output.WriteRawTag(160, 1); 1448 output.WriteInt32(MedianLatencyCollectionIntervalMillis); 1449 } 1450 if (ClientProcesses != 0) { 1451 output.WriteRawTag(168, 1); 1452 output.WriteInt32(ClientProcesses); 1453 } 1454 if (_unknownFields != null) { 1455 _unknownFields.WriteTo(output); 1456 } 1457 } 1458 1459 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()1460 public int CalculateSize() { 1461 int size = 0; 1462 size += serverTargets_.CalculateSize(_repeated_serverTargets_codec); 1463 if (ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1464 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ClientType); 1465 } 1466 if (securityParams_ != null) { 1467 size += 1 + pb::CodedOutputStream.ComputeMessageSize(SecurityParams); 1468 } 1469 if (OutstandingRpcsPerChannel != 0) { 1470 size += 1 + pb::CodedOutputStream.ComputeInt32Size(OutstandingRpcsPerChannel); 1471 } 1472 if (ClientChannels != 0) { 1473 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClientChannels); 1474 } 1475 if (AsyncClientThreads != 0) { 1476 size += 1 + pb::CodedOutputStream.ComputeInt32Size(AsyncClientThreads); 1477 } 1478 if (RpcType != global::Grpc.Testing.RpcType.Unary) { 1479 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) RpcType); 1480 } 1481 if (loadParams_ != null) { 1482 size += 1 + pb::CodedOutputStream.ComputeMessageSize(LoadParams); 1483 } 1484 if (payloadConfig_ != null) { 1485 size += 1 + pb::CodedOutputStream.ComputeMessageSize(PayloadConfig); 1486 } 1487 if (histogramParams_ != null) { 1488 size += 1 + pb::CodedOutputStream.ComputeMessageSize(HistogramParams); 1489 } 1490 size += coreList_.CalculateSize(_repeated_coreList_codec); 1491 if (CoreLimit != 0) { 1492 size += 1 + pb::CodedOutputStream.ComputeInt32Size(CoreLimit); 1493 } 1494 if (OtherClientApi.Length != 0) { 1495 size += 1 + pb::CodedOutputStream.ComputeStringSize(OtherClientApi); 1496 } 1497 size += channelArgs_.CalculateSize(_repeated_channelArgs_codec); 1498 if (ThreadsPerCq != 0) { 1499 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ThreadsPerCq); 1500 } 1501 if (MessagesPerStream != 0) { 1502 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MessagesPerStream); 1503 } 1504 if (UseCoalesceApi != false) { 1505 size += 2 + 1; 1506 } 1507 if (MedianLatencyCollectionIntervalMillis != 0) { 1508 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MedianLatencyCollectionIntervalMillis); 1509 } 1510 if (ClientProcesses != 0) { 1511 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClientProcesses); 1512 } 1513 if (_unknownFields != null) { 1514 size += _unknownFields.CalculateSize(); 1515 } 1516 return size; 1517 } 1518 1519 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClientConfig other)1520 public void MergeFrom(ClientConfig other) { 1521 if (other == null) { 1522 return; 1523 } 1524 serverTargets_.Add(other.serverTargets_); 1525 if (other.ClientType != global::Grpc.Testing.ClientType.SyncClient) { 1526 ClientType = other.ClientType; 1527 } 1528 if (other.securityParams_ != null) { 1529 if (securityParams_ == null) { 1530 SecurityParams = new global::Grpc.Testing.SecurityParams(); 1531 } 1532 SecurityParams.MergeFrom(other.SecurityParams); 1533 } 1534 if (other.OutstandingRpcsPerChannel != 0) { 1535 OutstandingRpcsPerChannel = other.OutstandingRpcsPerChannel; 1536 } 1537 if (other.ClientChannels != 0) { 1538 ClientChannels = other.ClientChannels; 1539 } 1540 if (other.AsyncClientThreads != 0) { 1541 AsyncClientThreads = other.AsyncClientThreads; 1542 } 1543 if (other.RpcType != global::Grpc.Testing.RpcType.Unary) { 1544 RpcType = other.RpcType; 1545 } 1546 if (other.loadParams_ != null) { 1547 if (loadParams_ == null) { 1548 LoadParams = new global::Grpc.Testing.LoadParams(); 1549 } 1550 LoadParams.MergeFrom(other.LoadParams); 1551 } 1552 if (other.payloadConfig_ != null) { 1553 if (payloadConfig_ == null) { 1554 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 1555 } 1556 PayloadConfig.MergeFrom(other.PayloadConfig); 1557 } 1558 if (other.histogramParams_ != null) { 1559 if (histogramParams_ == null) { 1560 HistogramParams = new global::Grpc.Testing.HistogramParams(); 1561 } 1562 HistogramParams.MergeFrom(other.HistogramParams); 1563 } 1564 coreList_.Add(other.coreList_); 1565 if (other.CoreLimit != 0) { 1566 CoreLimit = other.CoreLimit; 1567 } 1568 if (other.OtherClientApi.Length != 0) { 1569 OtherClientApi = other.OtherClientApi; 1570 } 1571 channelArgs_.Add(other.channelArgs_); 1572 if (other.ThreadsPerCq != 0) { 1573 ThreadsPerCq = other.ThreadsPerCq; 1574 } 1575 if (other.MessagesPerStream != 0) { 1576 MessagesPerStream = other.MessagesPerStream; 1577 } 1578 if (other.UseCoalesceApi != false) { 1579 UseCoalesceApi = other.UseCoalesceApi; 1580 } 1581 if (other.MedianLatencyCollectionIntervalMillis != 0) { 1582 MedianLatencyCollectionIntervalMillis = other.MedianLatencyCollectionIntervalMillis; 1583 } 1584 if (other.ClientProcesses != 0) { 1585 ClientProcesses = other.ClientProcesses; 1586 } 1587 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 1588 } 1589 1590 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)1591 public void MergeFrom(pb::CodedInputStream input) { 1592 uint tag; 1593 while ((tag = input.ReadTag()) != 0) { 1594 switch(tag) { 1595 default: 1596 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 1597 break; 1598 case 10: { 1599 serverTargets_.AddEntriesFrom(input, _repeated_serverTargets_codec); 1600 break; 1601 } 1602 case 16: { 1603 ClientType = (global::Grpc.Testing.ClientType) input.ReadEnum(); 1604 break; 1605 } 1606 case 26: { 1607 if (securityParams_ == null) { 1608 SecurityParams = new global::Grpc.Testing.SecurityParams(); 1609 } 1610 input.ReadMessage(SecurityParams); 1611 break; 1612 } 1613 case 32: { 1614 OutstandingRpcsPerChannel = input.ReadInt32(); 1615 break; 1616 } 1617 case 40: { 1618 ClientChannels = input.ReadInt32(); 1619 break; 1620 } 1621 case 56: { 1622 AsyncClientThreads = input.ReadInt32(); 1623 break; 1624 } 1625 case 64: { 1626 RpcType = (global::Grpc.Testing.RpcType) input.ReadEnum(); 1627 break; 1628 } 1629 case 82: { 1630 if (loadParams_ == null) { 1631 LoadParams = new global::Grpc.Testing.LoadParams(); 1632 } 1633 input.ReadMessage(LoadParams); 1634 break; 1635 } 1636 case 90: { 1637 if (payloadConfig_ == null) { 1638 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 1639 } 1640 input.ReadMessage(PayloadConfig); 1641 break; 1642 } 1643 case 98: { 1644 if (histogramParams_ == null) { 1645 HistogramParams = new global::Grpc.Testing.HistogramParams(); 1646 } 1647 input.ReadMessage(HistogramParams); 1648 break; 1649 } 1650 case 106: 1651 case 104: { 1652 coreList_.AddEntriesFrom(input, _repeated_coreList_codec); 1653 break; 1654 } 1655 case 112: { 1656 CoreLimit = input.ReadInt32(); 1657 break; 1658 } 1659 case 122: { 1660 OtherClientApi = input.ReadString(); 1661 break; 1662 } 1663 case 130: { 1664 channelArgs_.AddEntriesFrom(input, _repeated_channelArgs_codec); 1665 break; 1666 } 1667 case 136: { 1668 ThreadsPerCq = input.ReadInt32(); 1669 break; 1670 } 1671 case 144: { 1672 MessagesPerStream = input.ReadInt32(); 1673 break; 1674 } 1675 case 152: { 1676 UseCoalesceApi = input.ReadBool(); 1677 break; 1678 } 1679 case 160: { 1680 MedianLatencyCollectionIntervalMillis = input.ReadInt32(); 1681 break; 1682 } 1683 case 168: { 1684 ClientProcesses = input.ReadInt32(); 1685 break; 1686 } 1687 } 1688 } 1689 } 1690 1691 } 1692 1693 public sealed partial class ClientStatus : pb::IMessage<ClientStatus> { 1694 private static readonly pb::MessageParser<ClientStatus> _parser = new pb::MessageParser<ClientStatus>(() => new ClientStatus()); 1695 private pb::UnknownFieldSet _unknownFields; 1696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1697 public static pb::MessageParser<ClientStatus> Parser { get { return _parser; } } 1698 1699 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1700 public static pbr::MessageDescriptor Descriptor { 1701 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[6]; } 1702 } 1703 1704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1705 pbr::MessageDescriptor pb::IMessage.Descriptor { 1706 get { return Descriptor; } 1707 } 1708 1709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientStatus()1710 public ClientStatus() { 1711 OnConstruction(); 1712 } 1713 OnConstruction()1714 partial void OnConstruction(); 1715 1716 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientStatus(ClientStatus other)1717 public ClientStatus(ClientStatus other) : this() { 1718 stats_ = other.stats_ != null ? other.stats_.Clone() : null; 1719 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 1720 } 1721 1722 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()1723 public ClientStatus Clone() { 1724 return new ClientStatus(this); 1725 } 1726 1727 /// <summary>Field number for the "stats" field.</summary> 1728 public const int StatsFieldNumber = 1; 1729 private global::Grpc.Testing.ClientStats stats_; 1730 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1731 public global::Grpc.Testing.ClientStats Stats { 1732 get { return stats_; } 1733 set { 1734 stats_ = value; 1735 } 1736 } 1737 1738 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)1739 public override bool Equals(object other) { 1740 return Equals(other as ClientStatus); 1741 } 1742 1743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClientStatus other)1744 public bool Equals(ClientStatus other) { 1745 if (ReferenceEquals(other, null)) { 1746 return false; 1747 } 1748 if (ReferenceEquals(other, this)) { 1749 return true; 1750 } 1751 if (!object.Equals(Stats, other.Stats)) return false; 1752 return Equals(_unknownFields, other._unknownFields); 1753 } 1754 1755 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()1756 public override int GetHashCode() { 1757 int hash = 1; 1758 if (stats_ != null) hash ^= Stats.GetHashCode(); 1759 if (_unknownFields != null) { 1760 hash ^= _unknownFields.GetHashCode(); 1761 } 1762 return hash; 1763 } 1764 1765 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()1766 public override string ToString() { 1767 return pb::JsonFormatter.ToDiagnosticString(this); 1768 } 1769 1770 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)1771 public void WriteTo(pb::CodedOutputStream output) { 1772 if (stats_ != null) { 1773 output.WriteRawTag(10); 1774 output.WriteMessage(Stats); 1775 } 1776 if (_unknownFields != null) { 1777 _unknownFields.WriteTo(output); 1778 } 1779 } 1780 1781 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()1782 public int CalculateSize() { 1783 int size = 0; 1784 if (stats_ != null) { 1785 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Stats); 1786 } 1787 if (_unknownFields != null) { 1788 size += _unknownFields.CalculateSize(); 1789 } 1790 return size; 1791 } 1792 1793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClientStatus other)1794 public void MergeFrom(ClientStatus other) { 1795 if (other == null) { 1796 return; 1797 } 1798 if (other.stats_ != null) { 1799 if (stats_ == null) { 1800 Stats = new global::Grpc.Testing.ClientStats(); 1801 } 1802 Stats.MergeFrom(other.Stats); 1803 } 1804 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 1805 } 1806 1807 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)1808 public void MergeFrom(pb::CodedInputStream input) { 1809 uint tag; 1810 while ((tag = input.ReadTag()) != 0) { 1811 switch(tag) { 1812 default: 1813 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 1814 break; 1815 case 10: { 1816 if (stats_ == null) { 1817 Stats = new global::Grpc.Testing.ClientStats(); 1818 } 1819 input.ReadMessage(Stats); 1820 break; 1821 } 1822 } 1823 } 1824 } 1825 1826 } 1827 1828 /// <summary> 1829 /// Request current stats 1830 /// </summary> 1831 public sealed partial class Mark : pb::IMessage<Mark> { 1832 private static readonly pb::MessageParser<Mark> _parser = new pb::MessageParser<Mark>(() => new Mark()); 1833 private pb::UnknownFieldSet _unknownFields; 1834 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1835 public static pb::MessageParser<Mark> Parser { get { return _parser; } } 1836 1837 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1838 public static pbr::MessageDescriptor Descriptor { 1839 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[7]; } 1840 } 1841 1842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1843 pbr::MessageDescriptor pb::IMessage.Descriptor { 1844 get { return Descriptor; } 1845 } 1846 1847 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Mark()1848 public Mark() { 1849 OnConstruction(); 1850 } 1851 OnConstruction()1852 partial void OnConstruction(); 1853 1854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Mark(Mark other)1855 public Mark(Mark other) : this() { 1856 reset_ = other.reset_; 1857 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 1858 } 1859 1860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()1861 public Mark Clone() { 1862 return new Mark(this); 1863 } 1864 1865 /// <summary>Field number for the "reset" field.</summary> 1866 public const int ResetFieldNumber = 1; 1867 private bool reset_; 1868 /// <summary> 1869 /// if true, the stats will be reset after taking their snapshot. 1870 /// </summary> 1871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1872 public bool Reset { 1873 get { return reset_; } 1874 set { 1875 reset_ = value; 1876 } 1877 } 1878 1879 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)1880 public override bool Equals(object other) { 1881 return Equals(other as Mark); 1882 } 1883 1884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Mark other)1885 public bool Equals(Mark other) { 1886 if (ReferenceEquals(other, null)) { 1887 return false; 1888 } 1889 if (ReferenceEquals(other, this)) { 1890 return true; 1891 } 1892 if (Reset != other.Reset) return false; 1893 return Equals(_unknownFields, other._unknownFields); 1894 } 1895 1896 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()1897 public override int GetHashCode() { 1898 int hash = 1; 1899 if (Reset != false) hash ^= Reset.GetHashCode(); 1900 if (_unknownFields != null) { 1901 hash ^= _unknownFields.GetHashCode(); 1902 } 1903 return hash; 1904 } 1905 1906 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()1907 public override string ToString() { 1908 return pb::JsonFormatter.ToDiagnosticString(this); 1909 } 1910 1911 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)1912 public void WriteTo(pb::CodedOutputStream output) { 1913 if (Reset != false) { 1914 output.WriteRawTag(8); 1915 output.WriteBool(Reset); 1916 } 1917 if (_unknownFields != null) { 1918 _unknownFields.WriteTo(output); 1919 } 1920 } 1921 1922 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()1923 public int CalculateSize() { 1924 int size = 0; 1925 if (Reset != false) { 1926 size += 1 + 1; 1927 } 1928 if (_unknownFields != null) { 1929 size += _unknownFields.CalculateSize(); 1930 } 1931 return size; 1932 } 1933 1934 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Mark other)1935 public void MergeFrom(Mark other) { 1936 if (other == null) { 1937 return; 1938 } 1939 if (other.Reset != false) { 1940 Reset = other.Reset; 1941 } 1942 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 1943 } 1944 1945 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)1946 public void MergeFrom(pb::CodedInputStream input) { 1947 uint tag; 1948 while ((tag = input.ReadTag()) != 0) { 1949 switch(tag) { 1950 default: 1951 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 1952 break; 1953 case 8: { 1954 Reset = input.ReadBool(); 1955 break; 1956 } 1957 } 1958 } 1959 } 1960 1961 } 1962 1963 public sealed partial class ClientArgs : pb::IMessage<ClientArgs> { 1964 private static readonly pb::MessageParser<ClientArgs> _parser = new pb::MessageParser<ClientArgs>(() => new ClientArgs()); 1965 private pb::UnknownFieldSet _unknownFields; 1966 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1967 public static pb::MessageParser<ClientArgs> Parser { get { return _parser; } } 1968 1969 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1970 public static pbr::MessageDescriptor Descriptor { 1971 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[8]; } 1972 } 1973 1974 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 1975 pbr::MessageDescriptor pb::IMessage.Descriptor { 1976 get { return Descriptor; } 1977 } 1978 1979 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientArgs()1980 public ClientArgs() { 1981 OnConstruction(); 1982 } 1983 OnConstruction()1984 partial void OnConstruction(); 1985 1986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClientArgs(ClientArgs other)1987 public ClientArgs(ClientArgs other) : this() { 1988 switch (other.ArgtypeCase) { 1989 case ArgtypeOneofCase.Setup: 1990 Setup = other.Setup.Clone(); 1991 break; 1992 case ArgtypeOneofCase.Mark: 1993 Mark = other.Mark.Clone(); 1994 break; 1995 } 1996 1997 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 1998 } 1999 2000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2001 public ClientArgs Clone() { 2002 return new ClientArgs(this); 2003 } 2004 2005 /// <summary>Field number for the "setup" field.</summary> 2006 public const int SetupFieldNumber = 1; 2007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2008 public global::Grpc.Testing.ClientConfig Setup { 2009 get { return argtypeCase_ == ArgtypeOneofCase.Setup ? (global::Grpc.Testing.ClientConfig) argtype_ : null; } 2010 set { 2011 argtype_ = value; 2012 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Setup; 2013 } 2014 } 2015 2016 /// <summary>Field number for the "mark" field.</summary> 2017 public const int MarkFieldNumber = 2; 2018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2019 public global::Grpc.Testing.Mark Mark { 2020 get { return argtypeCase_ == ArgtypeOneofCase.Mark ? (global::Grpc.Testing.Mark) argtype_ : null; } 2021 set { 2022 argtype_ = value; 2023 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Mark; 2024 } 2025 } 2026 2027 private object argtype_; 2028 /// <summary>Enum of possible cases for the "argtype" oneof.</summary> 2029 public enum ArgtypeOneofCase { 2030 None = 0, 2031 Setup = 1, 2032 Mark = 2, 2033 } 2034 private ArgtypeOneofCase argtypeCase_ = ArgtypeOneofCase.None; 2035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2036 public ArgtypeOneofCase ArgtypeCase { 2037 get { return argtypeCase_; } 2038 } 2039 2040 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearArgtype()2041 public void ClearArgtype() { 2042 argtypeCase_ = ArgtypeOneofCase.None; 2043 argtype_ = null; 2044 } 2045 2046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2047 public override bool Equals(object other) { 2048 return Equals(other as ClientArgs); 2049 } 2050 2051 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ClientArgs other)2052 public bool Equals(ClientArgs other) { 2053 if (ReferenceEquals(other, null)) { 2054 return false; 2055 } 2056 if (ReferenceEquals(other, this)) { 2057 return true; 2058 } 2059 if (!object.Equals(Setup, other.Setup)) return false; 2060 if (!object.Equals(Mark, other.Mark)) return false; 2061 if (ArgtypeCase != other.ArgtypeCase) return false; 2062 return Equals(_unknownFields, other._unknownFields); 2063 } 2064 2065 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2066 public override int GetHashCode() { 2067 int hash = 1; 2068 if (argtypeCase_ == ArgtypeOneofCase.Setup) hash ^= Setup.GetHashCode(); 2069 if (argtypeCase_ == ArgtypeOneofCase.Mark) hash ^= Mark.GetHashCode(); 2070 hash ^= (int) argtypeCase_; 2071 if (_unknownFields != null) { 2072 hash ^= _unknownFields.GetHashCode(); 2073 } 2074 return hash; 2075 } 2076 2077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2078 public override string ToString() { 2079 return pb::JsonFormatter.ToDiagnosticString(this); 2080 } 2081 2082 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2083 public void WriteTo(pb::CodedOutputStream output) { 2084 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2085 output.WriteRawTag(10); 2086 output.WriteMessage(Setup); 2087 } 2088 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2089 output.WriteRawTag(18); 2090 output.WriteMessage(Mark); 2091 } 2092 if (_unknownFields != null) { 2093 _unknownFields.WriteTo(output); 2094 } 2095 } 2096 2097 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2098 public int CalculateSize() { 2099 int size = 0; 2100 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2101 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Setup); 2102 } 2103 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2104 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Mark); 2105 } 2106 if (_unknownFields != null) { 2107 size += _unknownFields.CalculateSize(); 2108 } 2109 return size; 2110 } 2111 2112 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ClientArgs other)2113 public void MergeFrom(ClientArgs other) { 2114 if (other == null) { 2115 return; 2116 } 2117 switch (other.ArgtypeCase) { 2118 case ArgtypeOneofCase.Setup: 2119 if (Setup == null) { 2120 Setup = new global::Grpc.Testing.ClientConfig(); 2121 } 2122 Setup.MergeFrom(other.Setup); 2123 break; 2124 case ArgtypeOneofCase.Mark: 2125 if (Mark == null) { 2126 Mark = new global::Grpc.Testing.Mark(); 2127 } 2128 Mark.MergeFrom(other.Mark); 2129 break; 2130 } 2131 2132 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 2133 } 2134 2135 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)2136 public void MergeFrom(pb::CodedInputStream input) { 2137 uint tag; 2138 while ((tag = input.ReadTag()) != 0) { 2139 switch(tag) { 2140 default: 2141 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 2142 break; 2143 case 10: { 2144 global::Grpc.Testing.ClientConfig subBuilder = new global::Grpc.Testing.ClientConfig(); 2145 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2146 subBuilder.MergeFrom(Setup); 2147 } 2148 input.ReadMessage(subBuilder); 2149 Setup = subBuilder; 2150 break; 2151 } 2152 case 18: { 2153 global::Grpc.Testing.Mark subBuilder = new global::Grpc.Testing.Mark(); 2154 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2155 subBuilder.MergeFrom(Mark); 2156 } 2157 input.ReadMessage(subBuilder); 2158 Mark = subBuilder; 2159 break; 2160 } 2161 } 2162 } 2163 } 2164 2165 } 2166 2167 public sealed partial class ServerConfig : pb::IMessage<ServerConfig> { 2168 private static readonly pb::MessageParser<ServerConfig> _parser = new pb::MessageParser<ServerConfig>(() => new ServerConfig()); 2169 private pb::UnknownFieldSet _unknownFields; 2170 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2171 public static pb::MessageParser<ServerConfig> Parser { get { return _parser; } } 2172 2173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2174 public static pbr::MessageDescriptor Descriptor { 2175 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[9]; } 2176 } 2177 2178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2179 pbr::MessageDescriptor pb::IMessage.Descriptor { 2180 get { return Descriptor; } 2181 } 2182 2183 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerConfig()2184 public ServerConfig() { 2185 OnConstruction(); 2186 } 2187 OnConstruction()2188 partial void OnConstruction(); 2189 2190 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerConfig(ServerConfig other)2191 public ServerConfig(ServerConfig other) : this() { 2192 serverType_ = other.serverType_; 2193 securityParams_ = other.securityParams_ != null ? other.securityParams_.Clone() : null; 2194 port_ = other.port_; 2195 asyncServerThreads_ = other.asyncServerThreads_; 2196 coreLimit_ = other.coreLimit_; 2197 payloadConfig_ = other.payloadConfig_ != null ? other.payloadConfig_.Clone() : null; 2198 coreList_ = other.coreList_.Clone(); 2199 otherServerApi_ = other.otherServerApi_; 2200 threadsPerCq_ = other.threadsPerCq_; 2201 resourceQuotaSize_ = other.resourceQuotaSize_; 2202 channelArgs_ = other.channelArgs_.Clone(); 2203 serverProcesses_ = other.serverProcesses_; 2204 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2205 } 2206 2207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2208 public ServerConfig Clone() { 2209 return new ServerConfig(this); 2210 } 2211 2212 /// <summary>Field number for the "server_type" field.</summary> 2213 public const int ServerTypeFieldNumber = 1; 2214 private global::Grpc.Testing.ServerType serverType_ = global::Grpc.Testing.ServerType.SyncServer; 2215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2216 public global::Grpc.Testing.ServerType ServerType { 2217 get { return serverType_; } 2218 set { 2219 serverType_ = value; 2220 } 2221 } 2222 2223 /// <summary>Field number for the "security_params" field.</summary> 2224 public const int SecurityParamsFieldNumber = 2; 2225 private global::Grpc.Testing.SecurityParams securityParams_; 2226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2227 public global::Grpc.Testing.SecurityParams SecurityParams { 2228 get { return securityParams_; } 2229 set { 2230 securityParams_ = value; 2231 } 2232 } 2233 2234 /// <summary>Field number for the "port" field.</summary> 2235 public const int PortFieldNumber = 4; 2236 private int port_; 2237 /// <summary> 2238 /// Port on which to listen. Zero means pick unused port. 2239 /// </summary> 2240 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2241 public int Port { 2242 get { return port_; } 2243 set { 2244 port_ = value; 2245 } 2246 } 2247 2248 /// <summary>Field number for the "async_server_threads" field.</summary> 2249 public const int AsyncServerThreadsFieldNumber = 7; 2250 private int asyncServerThreads_; 2251 /// <summary> 2252 /// Only for async server. Number of threads used to serve the requests. 2253 /// </summary> 2254 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2255 public int AsyncServerThreads { 2256 get { return asyncServerThreads_; } 2257 set { 2258 asyncServerThreads_ = value; 2259 } 2260 } 2261 2262 /// <summary>Field number for the "core_limit" field.</summary> 2263 public const int CoreLimitFieldNumber = 8; 2264 private int coreLimit_; 2265 /// <summary> 2266 /// Specify the number of cores to limit server to, if desired 2267 /// </summary> 2268 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2269 public int CoreLimit { 2270 get { return coreLimit_; } 2271 set { 2272 coreLimit_ = value; 2273 } 2274 } 2275 2276 /// <summary>Field number for the "payload_config" field.</summary> 2277 public const int PayloadConfigFieldNumber = 9; 2278 private global::Grpc.Testing.PayloadConfig payloadConfig_; 2279 /// <summary> 2280 /// payload config, used in generic server. 2281 /// Note this must NOT be used in proto (non-generic) servers. For proto servers, 2282 /// 'response sizes' must be configured from the 'response_size' field of the 2283 /// 'SimpleRequest' objects in RPC requests. 2284 /// </summary> 2285 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2286 public global::Grpc.Testing.PayloadConfig PayloadConfig { 2287 get { return payloadConfig_; } 2288 set { 2289 payloadConfig_ = value; 2290 } 2291 } 2292 2293 /// <summary>Field number for the "core_list" field.</summary> 2294 public const int CoreListFieldNumber = 10; 2295 private static readonly pb::FieldCodec<int> _repeated_coreList_codec 2296 = pb::FieldCodec.ForInt32(82); 2297 private readonly pbc::RepeatedField<int> coreList_ = new pbc::RepeatedField<int>(); 2298 /// <summary> 2299 /// Specify the cores we should run the server on, if desired 2300 /// </summary> 2301 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2302 public pbc::RepeatedField<int> CoreList { 2303 get { return coreList_; } 2304 } 2305 2306 /// <summary>Field number for the "other_server_api" field.</summary> 2307 public const int OtherServerApiFieldNumber = 11; 2308 private string otherServerApi_ = ""; 2309 /// <summary> 2310 /// If we use an OTHER_SERVER client_type, this string gives more detail 2311 /// </summary> 2312 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2313 public string OtherServerApi { 2314 get { return otherServerApi_; } 2315 set { 2316 otherServerApi_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 2317 } 2318 } 2319 2320 /// <summary>Field number for the "threads_per_cq" field.</summary> 2321 public const int ThreadsPerCqFieldNumber = 12; 2322 private int threadsPerCq_; 2323 /// <summary> 2324 /// Number of threads that share each completion queue 2325 /// </summary> 2326 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2327 public int ThreadsPerCq { 2328 get { return threadsPerCq_; } 2329 set { 2330 threadsPerCq_ = value; 2331 } 2332 } 2333 2334 /// <summary>Field number for the "resource_quota_size" field.</summary> 2335 public const int ResourceQuotaSizeFieldNumber = 1001; 2336 private int resourceQuotaSize_; 2337 /// <summary> 2338 /// Buffer pool size (no buffer pool specified if unset) 2339 /// </summary> 2340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2341 public int ResourceQuotaSize { 2342 get { return resourceQuotaSize_; } 2343 set { 2344 resourceQuotaSize_ = value; 2345 } 2346 } 2347 2348 /// <summary>Field number for the "channel_args" field.</summary> 2349 public const int ChannelArgsFieldNumber = 1002; 2350 private static readonly pb::FieldCodec<global::Grpc.Testing.ChannelArg> _repeated_channelArgs_codec 2351 = pb::FieldCodec.ForMessage(8018, global::Grpc.Testing.ChannelArg.Parser); 2352 private readonly pbc::RepeatedField<global::Grpc.Testing.ChannelArg> channelArgs_ = new pbc::RepeatedField<global::Grpc.Testing.ChannelArg>(); 2353 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2354 public pbc::RepeatedField<global::Grpc.Testing.ChannelArg> ChannelArgs { 2355 get { return channelArgs_; } 2356 } 2357 2358 /// <summary>Field number for the "server_processes" field.</summary> 2359 public const int ServerProcessesFieldNumber = 21; 2360 private int serverProcesses_; 2361 /// <summary> 2362 /// Number of server processes. 0 indicates no restriction. 2363 /// </summary> 2364 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2365 public int ServerProcesses { 2366 get { return serverProcesses_; } 2367 set { 2368 serverProcesses_ = value; 2369 } 2370 } 2371 2372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2373 public override bool Equals(object other) { 2374 return Equals(other as ServerConfig); 2375 } 2376 2377 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ServerConfig other)2378 public bool Equals(ServerConfig other) { 2379 if (ReferenceEquals(other, null)) { 2380 return false; 2381 } 2382 if (ReferenceEquals(other, this)) { 2383 return true; 2384 } 2385 if (ServerType != other.ServerType) return false; 2386 if (!object.Equals(SecurityParams, other.SecurityParams)) return false; 2387 if (Port != other.Port) return false; 2388 if (AsyncServerThreads != other.AsyncServerThreads) return false; 2389 if (CoreLimit != other.CoreLimit) return false; 2390 if (!object.Equals(PayloadConfig, other.PayloadConfig)) return false; 2391 if(!coreList_.Equals(other.coreList_)) return false; 2392 if (OtherServerApi != other.OtherServerApi) return false; 2393 if (ThreadsPerCq != other.ThreadsPerCq) return false; 2394 if (ResourceQuotaSize != other.ResourceQuotaSize) return false; 2395 if(!channelArgs_.Equals(other.channelArgs_)) return false; 2396 if (ServerProcesses != other.ServerProcesses) return false; 2397 return Equals(_unknownFields, other._unknownFields); 2398 } 2399 2400 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2401 public override int GetHashCode() { 2402 int hash = 1; 2403 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) hash ^= ServerType.GetHashCode(); 2404 if (securityParams_ != null) hash ^= SecurityParams.GetHashCode(); 2405 if (Port != 0) hash ^= Port.GetHashCode(); 2406 if (AsyncServerThreads != 0) hash ^= AsyncServerThreads.GetHashCode(); 2407 if (CoreLimit != 0) hash ^= CoreLimit.GetHashCode(); 2408 if (payloadConfig_ != null) hash ^= PayloadConfig.GetHashCode(); 2409 hash ^= coreList_.GetHashCode(); 2410 if (OtherServerApi.Length != 0) hash ^= OtherServerApi.GetHashCode(); 2411 if (ThreadsPerCq != 0) hash ^= ThreadsPerCq.GetHashCode(); 2412 if (ResourceQuotaSize != 0) hash ^= ResourceQuotaSize.GetHashCode(); 2413 hash ^= channelArgs_.GetHashCode(); 2414 if (ServerProcesses != 0) hash ^= ServerProcesses.GetHashCode(); 2415 if (_unknownFields != null) { 2416 hash ^= _unknownFields.GetHashCode(); 2417 } 2418 return hash; 2419 } 2420 2421 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2422 public override string ToString() { 2423 return pb::JsonFormatter.ToDiagnosticString(this); 2424 } 2425 2426 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2427 public void WriteTo(pb::CodedOutputStream output) { 2428 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) { 2429 output.WriteRawTag(8); 2430 output.WriteEnum((int) ServerType); 2431 } 2432 if (securityParams_ != null) { 2433 output.WriteRawTag(18); 2434 output.WriteMessage(SecurityParams); 2435 } 2436 if (Port != 0) { 2437 output.WriteRawTag(32); 2438 output.WriteInt32(Port); 2439 } 2440 if (AsyncServerThreads != 0) { 2441 output.WriteRawTag(56); 2442 output.WriteInt32(AsyncServerThreads); 2443 } 2444 if (CoreLimit != 0) { 2445 output.WriteRawTag(64); 2446 output.WriteInt32(CoreLimit); 2447 } 2448 if (payloadConfig_ != null) { 2449 output.WriteRawTag(74); 2450 output.WriteMessage(PayloadConfig); 2451 } 2452 coreList_.WriteTo(output, _repeated_coreList_codec); 2453 if (OtherServerApi.Length != 0) { 2454 output.WriteRawTag(90); 2455 output.WriteString(OtherServerApi); 2456 } 2457 if (ThreadsPerCq != 0) { 2458 output.WriteRawTag(96); 2459 output.WriteInt32(ThreadsPerCq); 2460 } 2461 if (ServerProcesses != 0) { 2462 output.WriteRawTag(168, 1); 2463 output.WriteInt32(ServerProcesses); 2464 } 2465 if (ResourceQuotaSize != 0) { 2466 output.WriteRawTag(200, 62); 2467 output.WriteInt32(ResourceQuotaSize); 2468 } 2469 channelArgs_.WriteTo(output, _repeated_channelArgs_codec); 2470 if (_unknownFields != null) { 2471 _unknownFields.WriteTo(output); 2472 } 2473 } 2474 2475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2476 public int CalculateSize() { 2477 int size = 0; 2478 if (ServerType != global::Grpc.Testing.ServerType.SyncServer) { 2479 size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) ServerType); 2480 } 2481 if (securityParams_ != null) { 2482 size += 1 + pb::CodedOutputStream.ComputeMessageSize(SecurityParams); 2483 } 2484 if (Port != 0) { 2485 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Port); 2486 } 2487 if (AsyncServerThreads != 0) { 2488 size += 1 + pb::CodedOutputStream.ComputeInt32Size(AsyncServerThreads); 2489 } 2490 if (CoreLimit != 0) { 2491 size += 1 + pb::CodedOutputStream.ComputeInt32Size(CoreLimit); 2492 } 2493 if (payloadConfig_ != null) { 2494 size += 1 + pb::CodedOutputStream.ComputeMessageSize(PayloadConfig); 2495 } 2496 size += coreList_.CalculateSize(_repeated_coreList_codec); 2497 if (OtherServerApi.Length != 0) { 2498 size += 1 + pb::CodedOutputStream.ComputeStringSize(OtherServerApi); 2499 } 2500 if (ThreadsPerCq != 0) { 2501 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ThreadsPerCq); 2502 } 2503 if (ResourceQuotaSize != 0) { 2504 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ResourceQuotaSize); 2505 } 2506 size += channelArgs_.CalculateSize(_repeated_channelArgs_codec); 2507 if (ServerProcesses != 0) { 2508 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ServerProcesses); 2509 } 2510 if (_unknownFields != null) { 2511 size += _unknownFields.CalculateSize(); 2512 } 2513 return size; 2514 } 2515 2516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ServerConfig other)2517 public void MergeFrom(ServerConfig other) { 2518 if (other == null) { 2519 return; 2520 } 2521 if (other.ServerType != global::Grpc.Testing.ServerType.SyncServer) { 2522 ServerType = other.ServerType; 2523 } 2524 if (other.securityParams_ != null) { 2525 if (securityParams_ == null) { 2526 SecurityParams = new global::Grpc.Testing.SecurityParams(); 2527 } 2528 SecurityParams.MergeFrom(other.SecurityParams); 2529 } 2530 if (other.Port != 0) { 2531 Port = other.Port; 2532 } 2533 if (other.AsyncServerThreads != 0) { 2534 AsyncServerThreads = other.AsyncServerThreads; 2535 } 2536 if (other.CoreLimit != 0) { 2537 CoreLimit = other.CoreLimit; 2538 } 2539 if (other.payloadConfig_ != null) { 2540 if (payloadConfig_ == null) { 2541 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 2542 } 2543 PayloadConfig.MergeFrom(other.PayloadConfig); 2544 } 2545 coreList_.Add(other.coreList_); 2546 if (other.OtherServerApi.Length != 0) { 2547 OtherServerApi = other.OtherServerApi; 2548 } 2549 if (other.ThreadsPerCq != 0) { 2550 ThreadsPerCq = other.ThreadsPerCq; 2551 } 2552 if (other.ResourceQuotaSize != 0) { 2553 ResourceQuotaSize = other.ResourceQuotaSize; 2554 } 2555 channelArgs_.Add(other.channelArgs_); 2556 if (other.ServerProcesses != 0) { 2557 ServerProcesses = other.ServerProcesses; 2558 } 2559 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 2560 } 2561 2562 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)2563 public void MergeFrom(pb::CodedInputStream input) { 2564 uint tag; 2565 while ((tag = input.ReadTag()) != 0) { 2566 switch(tag) { 2567 default: 2568 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 2569 break; 2570 case 8: { 2571 ServerType = (global::Grpc.Testing.ServerType) input.ReadEnum(); 2572 break; 2573 } 2574 case 18: { 2575 if (securityParams_ == null) { 2576 SecurityParams = new global::Grpc.Testing.SecurityParams(); 2577 } 2578 input.ReadMessage(SecurityParams); 2579 break; 2580 } 2581 case 32: { 2582 Port = input.ReadInt32(); 2583 break; 2584 } 2585 case 56: { 2586 AsyncServerThreads = input.ReadInt32(); 2587 break; 2588 } 2589 case 64: { 2590 CoreLimit = input.ReadInt32(); 2591 break; 2592 } 2593 case 74: { 2594 if (payloadConfig_ == null) { 2595 PayloadConfig = new global::Grpc.Testing.PayloadConfig(); 2596 } 2597 input.ReadMessage(PayloadConfig); 2598 break; 2599 } 2600 case 82: 2601 case 80: { 2602 coreList_.AddEntriesFrom(input, _repeated_coreList_codec); 2603 break; 2604 } 2605 case 90: { 2606 OtherServerApi = input.ReadString(); 2607 break; 2608 } 2609 case 96: { 2610 ThreadsPerCq = input.ReadInt32(); 2611 break; 2612 } 2613 case 168: { 2614 ServerProcesses = input.ReadInt32(); 2615 break; 2616 } 2617 case 8008: { 2618 ResourceQuotaSize = input.ReadInt32(); 2619 break; 2620 } 2621 case 8018: { 2622 channelArgs_.AddEntriesFrom(input, _repeated_channelArgs_codec); 2623 break; 2624 } 2625 } 2626 } 2627 } 2628 2629 } 2630 2631 public sealed partial class ServerArgs : pb::IMessage<ServerArgs> { 2632 private static readonly pb::MessageParser<ServerArgs> _parser = new pb::MessageParser<ServerArgs>(() => new ServerArgs()); 2633 private pb::UnknownFieldSet _unknownFields; 2634 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2635 public static pb::MessageParser<ServerArgs> Parser { get { return _parser; } } 2636 2637 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2638 public static pbr::MessageDescriptor Descriptor { 2639 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[10]; } 2640 } 2641 2642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2643 pbr::MessageDescriptor pb::IMessage.Descriptor { 2644 get { return Descriptor; } 2645 } 2646 2647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerArgs()2648 public ServerArgs() { 2649 OnConstruction(); 2650 } 2651 OnConstruction()2652 partial void OnConstruction(); 2653 2654 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerArgs(ServerArgs other)2655 public ServerArgs(ServerArgs other) : this() { 2656 switch (other.ArgtypeCase) { 2657 case ArgtypeOneofCase.Setup: 2658 Setup = other.Setup.Clone(); 2659 break; 2660 case ArgtypeOneofCase.Mark: 2661 Mark = other.Mark.Clone(); 2662 break; 2663 } 2664 2665 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2666 } 2667 2668 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2669 public ServerArgs Clone() { 2670 return new ServerArgs(this); 2671 } 2672 2673 /// <summary>Field number for the "setup" field.</summary> 2674 public const int SetupFieldNumber = 1; 2675 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2676 public global::Grpc.Testing.ServerConfig Setup { 2677 get { return argtypeCase_ == ArgtypeOneofCase.Setup ? (global::Grpc.Testing.ServerConfig) argtype_ : null; } 2678 set { 2679 argtype_ = value; 2680 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Setup; 2681 } 2682 } 2683 2684 /// <summary>Field number for the "mark" field.</summary> 2685 public const int MarkFieldNumber = 2; 2686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2687 public global::Grpc.Testing.Mark Mark { 2688 get { return argtypeCase_ == ArgtypeOneofCase.Mark ? (global::Grpc.Testing.Mark) argtype_ : null; } 2689 set { 2690 argtype_ = value; 2691 argtypeCase_ = value == null ? ArgtypeOneofCase.None : ArgtypeOneofCase.Mark; 2692 } 2693 } 2694 2695 private object argtype_; 2696 /// <summary>Enum of possible cases for the "argtype" oneof.</summary> 2697 public enum ArgtypeOneofCase { 2698 None = 0, 2699 Setup = 1, 2700 Mark = 2, 2701 } 2702 private ArgtypeOneofCase argtypeCase_ = ArgtypeOneofCase.None; 2703 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2704 public ArgtypeOneofCase ArgtypeCase { 2705 get { return argtypeCase_; } 2706 } 2707 2708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ClearArgtype()2709 public void ClearArgtype() { 2710 argtypeCase_ = ArgtypeOneofCase.None; 2711 argtype_ = null; 2712 } 2713 2714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2715 public override bool Equals(object other) { 2716 return Equals(other as ServerArgs); 2717 } 2718 2719 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ServerArgs other)2720 public bool Equals(ServerArgs other) { 2721 if (ReferenceEquals(other, null)) { 2722 return false; 2723 } 2724 if (ReferenceEquals(other, this)) { 2725 return true; 2726 } 2727 if (!object.Equals(Setup, other.Setup)) return false; 2728 if (!object.Equals(Mark, other.Mark)) return false; 2729 if (ArgtypeCase != other.ArgtypeCase) return false; 2730 return Equals(_unknownFields, other._unknownFields); 2731 } 2732 2733 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2734 public override int GetHashCode() { 2735 int hash = 1; 2736 if (argtypeCase_ == ArgtypeOneofCase.Setup) hash ^= Setup.GetHashCode(); 2737 if (argtypeCase_ == ArgtypeOneofCase.Mark) hash ^= Mark.GetHashCode(); 2738 hash ^= (int) argtypeCase_; 2739 if (_unknownFields != null) { 2740 hash ^= _unknownFields.GetHashCode(); 2741 } 2742 return hash; 2743 } 2744 2745 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2746 public override string ToString() { 2747 return pb::JsonFormatter.ToDiagnosticString(this); 2748 } 2749 2750 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2751 public void WriteTo(pb::CodedOutputStream output) { 2752 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2753 output.WriteRawTag(10); 2754 output.WriteMessage(Setup); 2755 } 2756 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2757 output.WriteRawTag(18); 2758 output.WriteMessage(Mark); 2759 } 2760 if (_unknownFields != null) { 2761 _unknownFields.WriteTo(output); 2762 } 2763 } 2764 2765 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2766 public int CalculateSize() { 2767 int size = 0; 2768 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2769 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Setup); 2770 } 2771 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2772 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Mark); 2773 } 2774 if (_unknownFields != null) { 2775 size += _unknownFields.CalculateSize(); 2776 } 2777 return size; 2778 } 2779 2780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ServerArgs other)2781 public void MergeFrom(ServerArgs other) { 2782 if (other == null) { 2783 return; 2784 } 2785 switch (other.ArgtypeCase) { 2786 case ArgtypeOneofCase.Setup: 2787 if (Setup == null) { 2788 Setup = new global::Grpc.Testing.ServerConfig(); 2789 } 2790 Setup.MergeFrom(other.Setup); 2791 break; 2792 case ArgtypeOneofCase.Mark: 2793 if (Mark == null) { 2794 Mark = new global::Grpc.Testing.Mark(); 2795 } 2796 Mark.MergeFrom(other.Mark); 2797 break; 2798 } 2799 2800 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 2801 } 2802 2803 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)2804 public void MergeFrom(pb::CodedInputStream input) { 2805 uint tag; 2806 while ((tag = input.ReadTag()) != 0) { 2807 switch(tag) { 2808 default: 2809 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 2810 break; 2811 case 10: { 2812 global::Grpc.Testing.ServerConfig subBuilder = new global::Grpc.Testing.ServerConfig(); 2813 if (argtypeCase_ == ArgtypeOneofCase.Setup) { 2814 subBuilder.MergeFrom(Setup); 2815 } 2816 input.ReadMessage(subBuilder); 2817 Setup = subBuilder; 2818 break; 2819 } 2820 case 18: { 2821 global::Grpc.Testing.Mark subBuilder = new global::Grpc.Testing.Mark(); 2822 if (argtypeCase_ == ArgtypeOneofCase.Mark) { 2823 subBuilder.MergeFrom(Mark); 2824 } 2825 input.ReadMessage(subBuilder); 2826 Mark = subBuilder; 2827 break; 2828 } 2829 } 2830 } 2831 } 2832 2833 } 2834 2835 public sealed partial class ServerStatus : pb::IMessage<ServerStatus> { 2836 private static readonly pb::MessageParser<ServerStatus> _parser = new pb::MessageParser<ServerStatus>(() => new ServerStatus()); 2837 private pb::UnknownFieldSet _unknownFields; 2838 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2839 public static pb::MessageParser<ServerStatus> Parser { get { return _parser; } } 2840 2841 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2842 public static pbr::MessageDescriptor Descriptor { 2843 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[11]; } 2844 } 2845 2846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2847 pbr::MessageDescriptor pb::IMessage.Descriptor { 2848 get { return Descriptor; } 2849 } 2850 2851 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerStatus()2852 public ServerStatus() { 2853 OnConstruction(); 2854 } 2855 OnConstruction()2856 partial void OnConstruction(); 2857 2858 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ServerStatus(ServerStatus other)2859 public ServerStatus(ServerStatus other) : this() { 2860 stats_ = other.stats_ != null ? other.stats_.Clone() : null; 2861 port_ = other.port_; 2862 cores_ = other.cores_; 2863 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 2864 } 2865 2866 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()2867 public ServerStatus Clone() { 2868 return new ServerStatus(this); 2869 } 2870 2871 /// <summary>Field number for the "stats" field.</summary> 2872 public const int StatsFieldNumber = 1; 2873 private global::Grpc.Testing.ServerStats stats_; 2874 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2875 public global::Grpc.Testing.ServerStats Stats { 2876 get { return stats_; } 2877 set { 2878 stats_ = value; 2879 } 2880 } 2881 2882 /// <summary>Field number for the "port" field.</summary> 2883 public const int PortFieldNumber = 2; 2884 private int port_; 2885 /// <summary> 2886 /// the port bound by the server 2887 /// </summary> 2888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2889 public int Port { 2890 get { return port_; } 2891 set { 2892 port_ = value; 2893 } 2894 } 2895 2896 /// <summary>Field number for the "cores" field.</summary> 2897 public const int CoresFieldNumber = 3; 2898 private int cores_; 2899 /// <summary> 2900 /// Number of cores available to the server 2901 /// </summary> 2902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 2903 public int Cores { 2904 get { return cores_; } 2905 set { 2906 cores_ = value; 2907 } 2908 } 2909 2910 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)2911 public override bool Equals(object other) { 2912 return Equals(other as ServerStatus); 2913 } 2914 2915 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ServerStatus other)2916 public bool Equals(ServerStatus other) { 2917 if (ReferenceEquals(other, null)) { 2918 return false; 2919 } 2920 if (ReferenceEquals(other, this)) { 2921 return true; 2922 } 2923 if (!object.Equals(Stats, other.Stats)) return false; 2924 if (Port != other.Port) return false; 2925 if (Cores != other.Cores) return false; 2926 return Equals(_unknownFields, other._unknownFields); 2927 } 2928 2929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()2930 public override int GetHashCode() { 2931 int hash = 1; 2932 if (stats_ != null) hash ^= Stats.GetHashCode(); 2933 if (Port != 0) hash ^= Port.GetHashCode(); 2934 if (Cores != 0) hash ^= Cores.GetHashCode(); 2935 if (_unknownFields != null) { 2936 hash ^= _unknownFields.GetHashCode(); 2937 } 2938 return hash; 2939 } 2940 2941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()2942 public override string ToString() { 2943 return pb::JsonFormatter.ToDiagnosticString(this); 2944 } 2945 2946 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)2947 public void WriteTo(pb::CodedOutputStream output) { 2948 if (stats_ != null) { 2949 output.WriteRawTag(10); 2950 output.WriteMessage(Stats); 2951 } 2952 if (Port != 0) { 2953 output.WriteRawTag(16); 2954 output.WriteInt32(Port); 2955 } 2956 if (Cores != 0) { 2957 output.WriteRawTag(24); 2958 output.WriteInt32(Cores); 2959 } 2960 if (_unknownFields != null) { 2961 _unknownFields.WriteTo(output); 2962 } 2963 } 2964 2965 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()2966 public int CalculateSize() { 2967 int size = 0; 2968 if (stats_ != null) { 2969 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Stats); 2970 } 2971 if (Port != 0) { 2972 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Port); 2973 } 2974 if (Cores != 0) { 2975 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Cores); 2976 } 2977 if (_unknownFields != null) { 2978 size += _unknownFields.CalculateSize(); 2979 } 2980 return size; 2981 } 2982 2983 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ServerStatus other)2984 public void MergeFrom(ServerStatus other) { 2985 if (other == null) { 2986 return; 2987 } 2988 if (other.stats_ != null) { 2989 if (stats_ == null) { 2990 Stats = new global::Grpc.Testing.ServerStats(); 2991 } 2992 Stats.MergeFrom(other.Stats); 2993 } 2994 if (other.Port != 0) { 2995 Port = other.Port; 2996 } 2997 if (other.Cores != 0) { 2998 Cores = other.Cores; 2999 } 3000 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3001 } 3002 3003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3004 public void MergeFrom(pb::CodedInputStream input) { 3005 uint tag; 3006 while ((tag = input.ReadTag()) != 0) { 3007 switch(tag) { 3008 default: 3009 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3010 break; 3011 case 10: { 3012 if (stats_ == null) { 3013 Stats = new global::Grpc.Testing.ServerStats(); 3014 } 3015 input.ReadMessage(Stats); 3016 break; 3017 } 3018 case 16: { 3019 Port = input.ReadInt32(); 3020 break; 3021 } 3022 case 24: { 3023 Cores = input.ReadInt32(); 3024 break; 3025 } 3026 } 3027 } 3028 } 3029 3030 } 3031 3032 public sealed partial class CoreRequest : pb::IMessage<CoreRequest> { 3033 private static readonly pb::MessageParser<CoreRequest> _parser = new pb::MessageParser<CoreRequest>(() => new CoreRequest()); 3034 private pb::UnknownFieldSet _unknownFields; 3035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3036 public static pb::MessageParser<CoreRequest> Parser { get { return _parser; } } 3037 3038 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3039 public static pbr::MessageDescriptor Descriptor { 3040 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[12]; } 3041 } 3042 3043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3044 pbr::MessageDescriptor pb::IMessage.Descriptor { 3045 get { return Descriptor; } 3046 } 3047 3048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreRequest()3049 public CoreRequest() { 3050 OnConstruction(); 3051 } 3052 OnConstruction()3053 partial void OnConstruction(); 3054 3055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreRequest(CoreRequest other)3056 public CoreRequest(CoreRequest other) : this() { 3057 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3058 } 3059 3060 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3061 public CoreRequest Clone() { 3062 return new CoreRequest(this); 3063 } 3064 3065 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3066 public override bool Equals(object other) { 3067 return Equals(other as CoreRequest); 3068 } 3069 3070 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(CoreRequest other)3071 public bool Equals(CoreRequest other) { 3072 if (ReferenceEquals(other, null)) { 3073 return false; 3074 } 3075 if (ReferenceEquals(other, this)) { 3076 return true; 3077 } 3078 return Equals(_unknownFields, other._unknownFields); 3079 } 3080 3081 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3082 public override int GetHashCode() { 3083 int hash = 1; 3084 if (_unknownFields != null) { 3085 hash ^= _unknownFields.GetHashCode(); 3086 } 3087 return hash; 3088 } 3089 3090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3091 public override string ToString() { 3092 return pb::JsonFormatter.ToDiagnosticString(this); 3093 } 3094 3095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3096 public void WriteTo(pb::CodedOutputStream output) { 3097 if (_unknownFields != null) { 3098 _unknownFields.WriteTo(output); 3099 } 3100 } 3101 3102 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3103 public int CalculateSize() { 3104 int size = 0; 3105 if (_unknownFields != null) { 3106 size += _unknownFields.CalculateSize(); 3107 } 3108 return size; 3109 } 3110 3111 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(CoreRequest other)3112 public void MergeFrom(CoreRequest other) { 3113 if (other == null) { 3114 return; 3115 } 3116 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3117 } 3118 3119 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3120 public void MergeFrom(pb::CodedInputStream input) { 3121 uint tag; 3122 while ((tag = input.ReadTag()) != 0) { 3123 switch(tag) { 3124 default: 3125 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3126 break; 3127 } 3128 } 3129 } 3130 3131 } 3132 3133 public sealed partial class CoreResponse : pb::IMessage<CoreResponse> { 3134 private static readonly pb::MessageParser<CoreResponse> _parser = new pb::MessageParser<CoreResponse>(() => new CoreResponse()); 3135 private pb::UnknownFieldSet _unknownFields; 3136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3137 public static pb::MessageParser<CoreResponse> Parser { get { return _parser; } } 3138 3139 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3140 public static pbr::MessageDescriptor Descriptor { 3141 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[13]; } 3142 } 3143 3144 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3145 pbr::MessageDescriptor pb::IMessage.Descriptor { 3146 get { return Descriptor; } 3147 } 3148 3149 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreResponse()3150 public CoreResponse() { 3151 OnConstruction(); 3152 } 3153 OnConstruction()3154 partial void OnConstruction(); 3155 3156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CoreResponse(CoreResponse other)3157 public CoreResponse(CoreResponse other) : this() { 3158 cores_ = other.cores_; 3159 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3160 } 3161 3162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3163 public CoreResponse Clone() { 3164 return new CoreResponse(this); 3165 } 3166 3167 /// <summary>Field number for the "cores" field.</summary> 3168 public const int CoresFieldNumber = 1; 3169 private int cores_; 3170 /// <summary> 3171 /// Number of cores available on the server 3172 /// </summary> 3173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3174 public int Cores { 3175 get { return cores_; } 3176 set { 3177 cores_ = value; 3178 } 3179 } 3180 3181 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3182 public override bool Equals(object other) { 3183 return Equals(other as CoreResponse); 3184 } 3185 3186 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(CoreResponse other)3187 public bool Equals(CoreResponse other) { 3188 if (ReferenceEquals(other, null)) { 3189 return false; 3190 } 3191 if (ReferenceEquals(other, this)) { 3192 return true; 3193 } 3194 if (Cores != other.Cores) return false; 3195 return Equals(_unknownFields, other._unknownFields); 3196 } 3197 3198 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3199 public override int GetHashCode() { 3200 int hash = 1; 3201 if (Cores != 0) hash ^= Cores.GetHashCode(); 3202 if (_unknownFields != null) { 3203 hash ^= _unknownFields.GetHashCode(); 3204 } 3205 return hash; 3206 } 3207 3208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3209 public override string ToString() { 3210 return pb::JsonFormatter.ToDiagnosticString(this); 3211 } 3212 3213 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3214 public void WriteTo(pb::CodedOutputStream output) { 3215 if (Cores != 0) { 3216 output.WriteRawTag(8); 3217 output.WriteInt32(Cores); 3218 } 3219 if (_unknownFields != null) { 3220 _unknownFields.WriteTo(output); 3221 } 3222 } 3223 3224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3225 public int CalculateSize() { 3226 int size = 0; 3227 if (Cores != 0) { 3228 size += 1 + pb::CodedOutputStream.ComputeInt32Size(Cores); 3229 } 3230 if (_unknownFields != null) { 3231 size += _unknownFields.CalculateSize(); 3232 } 3233 return size; 3234 } 3235 3236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(CoreResponse other)3237 public void MergeFrom(CoreResponse other) { 3238 if (other == null) { 3239 return; 3240 } 3241 if (other.Cores != 0) { 3242 Cores = other.Cores; 3243 } 3244 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3245 } 3246 3247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3248 public void MergeFrom(pb::CodedInputStream input) { 3249 uint tag; 3250 while ((tag = input.ReadTag()) != 0) { 3251 switch(tag) { 3252 default: 3253 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3254 break; 3255 case 8: { 3256 Cores = input.ReadInt32(); 3257 break; 3258 } 3259 } 3260 } 3261 } 3262 3263 } 3264 3265 public sealed partial class Void : pb::IMessage<Void> { 3266 private static readonly pb::MessageParser<Void> _parser = new pb::MessageParser<Void>(() => new Void()); 3267 private pb::UnknownFieldSet _unknownFields; 3268 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3269 public static pb::MessageParser<Void> Parser { get { return _parser; } } 3270 3271 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3272 public static pbr::MessageDescriptor Descriptor { 3273 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[14]; } 3274 } 3275 3276 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3277 pbr::MessageDescriptor pb::IMessage.Descriptor { 3278 get { return Descriptor; } 3279 } 3280 3281 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Void()3282 public Void() { 3283 OnConstruction(); 3284 } 3285 OnConstruction()3286 partial void OnConstruction(); 3287 3288 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Void(Void other)3289 public Void(Void other) : this() { 3290 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3291 } 3292 3293 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3294 public Void Clone() { 3295 return new Void(this); 3296 } 3297 3298 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3299 public override bool Equals(object other) { 3300 return Equals(other as Void); 3301 } 3302 3303 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Void other)3304 public bool Equals(Void other) { 3305 if (ReferenceEquals(other, null)) { 3306 return false; 3307 } 3308 if (ReferenceEquals(other, this)) { 3309 return true; 3310 } 3311 return Equals(_unknownFields, other._unknownFields); 3312 } 3313 3314 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3315 public override int GetHashCode() { 3316 int hash = 1; 3317 if (_unknownFields != null) { 3318 hash ^= _unknownFields.GetHashCode(); 3319 } 3320 return hash; 3321 } 3322 3323 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3324 public override string ToString() { 3325 return pb::JsonFormatter.ToDiagnosticString(this); 3326 } 3327 3328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3329 public void WriteTo(pb::CodedOutputStream output) { 3330 if (_unknownFields != null) { 3331 _unknownFields.WriteTo(output); 3332 } 3333 } 3334 3335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3336 public int CalculateSize() { 3337 int size = 0; 3338 if (_unknownFields != null) { 3339 size += _unknownFields.CalculateSize(); 3340 } 3341 return size; 3342 } 3343 3344 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Void other)3345 public void MergeFrom(Void other) { 3346 if (other == null) { 3347 return; 3348 } 3349 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3350 } 3351 3352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3353 public void MergeFrom(pb::CodedInputStream input) { 3354 uint tag; 3355 while ((tag = input.ReadTag()) != 0) { 3356 switch(tag) { 3357 default: 3358 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3359 break; 3360 } 3361 } 3362 } 3363 3364 } 3365 3366 /// <summary> 3367 /// A single performance scenario: input to qps_json_driver 3368 /// </summary> 3369 public sealed partial class Scenario : pb::IMessage<Scenario> { 3370 private static readonly pb::MessageParser<Scenario> _parser = new pb::MessageParser<Scenario>(() => new Scenario()); 3371 private pb::UnknownFieldSet _unknownFields; 3372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3373 public static pb::MessageParser<Scenario> Parser { get { return _parser; } } 3374 3375 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3376 public static pbr::MessageDescriptor Descriptor { 3377 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[15]; } 3378 } 3379 3380 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3381 pbr::MessageDescriptor pb::IMessage.Descriptor { 3382 get { return Descriptor; } 3383 } 3384 3385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenario()3386 public Scenario() { 3387 OnConstruction(); 3388 } 3389 OnConstruction()3390 partial void OnConstruction(); 3391 3392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenario(Scenario other)3393 public Scenario(Scenario other) : this() { 3394 name_ = other.name_; 3395 clientConfig_ = other.clientConfig_ != null ? other.clientConfig_.Clone() : null; 3396 numClients_ = other.numClients_; 3397 serverConfig_ = other.serverConfig_ != null ? other.serverConfig_.Clone() : null; 3398 numServers_ = other.numServers_; 3399 warmupSeconds_ = other.warmupSeconds_; 3400 benchmarkSeconds_ = other.benchmarkSeconds_; 3401 spawnLocalWorkerCount_ = other.spawnLocalWorkerCount_; 3402 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3403 } 3404 3405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3406 public Scenario Clone() { 3407 return new Scenario(this); 3408 } 3409 3410 /// <summary>Field number for the "name" field.</summary> 3411 public const int NameFieldNumber = 1; 3412 private string name_ = ""; 3413 /// <summary> 3414 /// Human readable name for this scenario 3415 /// </summary> 3416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3417 public string Name { 3418 get { return name_; } 3419 set { 3420 name_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); 3421 } 3422 } 3423 3424 /// <summary>Field number for the "client_config" field.</summary> 3425 public const int ClientConfigFieldNumber = 2; 3426 private global::Grpc.Testing.ClientConfig clientConfig_; 3427 /// <summary> 3428 /// Client configuration 3429 /// </summary> 3430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3431 public global::Grpc.Testing.ClientConfig ClientConfig { 3432 get { return clientConfig_; } 3433 set { 3434 clientConfig_ = value; 3435 } 3436 } 3437 3438 /// <summary>Field number for the "num_clients" field.</summary> 3439 public const int NumClientsFieldNumber = 3; 3440 private int numClients_; 3441 /// <summary> 3442 /// Number of clients to start for the test 3443 /// </summary> 3444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3445 public int NumClients { 3446 get { return numClients_; } 3447 set { 3448 numClients_ = value; 3449 } 3450 } 3451 3452 /// <summary>Field number for the "server_config" field.</summary> 3453 public const int ServerConfigFieldNumber = 4; 3454 private global::Grpc.Testing.ServerConfig serverConfig_; 3455 /// <summary> 3456 /// Server configuration 3457 /// </summary> 3458 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3459 public global::Grpc.Testing.ServerConfig ServerConfig { 3460 get { return serverConfig_; } 3461 set { 3462 serverConfig_ = value; 3463 } 3464 } 3465 3466 /// <summary>Field number for the "num_servers" field.</summary> 3467 public const int NumServersFieldNumber = 5; 3468 private int numServers_; 3469 /// <summary> 3470 /// Number of servers to start for the test 3471 /// </summary> 3472 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3473 public int NumServers { 3474 get { return numServers_; } 3475 set { 3476 numServers_ = value; 3477 } 3478 } 3479 3480 /// <summary>Field number for the "warmup_seconds" field.</summary> 3481 public const int WarmupSecondsFieldNumber = 6; 3482 private int warmupSeconds_; 3483 /// <summary> 3484 /// Warmup period, in seconds 3485 /// </summary> 3486 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3487 public int WarmupSeconds { 3488 get { return warmupSeconds_; } 3489 set { 3490 warmupSeconds_ = value; 3491 } 3492 } 3493 3494 /// <summary>Field number for the "benchmark_seconds" field.</summary> 3495 public const int BenchmarkSecondsFieldNumber = 7; 3496 private int benchmarkSeconds_; 3497 /// <summary> 3498 /// Benchmark time, in seconds 3499 /// </summary> 3500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3501 public int BenchmarkSeconds { 3502 get { return benchmarkSeconds_; } 3503 set { 3504 benchmarkSeconds_ = value; 3505 } 3506 } 3507 3508 /// <summary>Field number for the "spawn_local_worker_count" field.</summary> 3509 public const int SpawnLocalWorkerCountFieldNumber = 8; 3510 private int spawnLocalWorkerCount_; 3511 /// <summary> 3512 /// Number of workers to spawn locally (usually zero) 3513 /// </summary> 3514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3515 public int SpawnLocalWorkerCount { 3516 get { return spawnLocalWorkerCount_; } 3517 set { 3518 spawnLocalWorkerCount_ = value; 3519 } 3520 } 3521 3522 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3523 public override bool Equals(object other) { 3524 return Equals(other as Scenario); 3525 } 3526 3527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Scenario other)3528 public bool Equals(Scenario other) { 3529 if (ReferenceEquals(other, null)) { 3530 return false; 3531 } 3532 if (ReferenceEquals(other, this)) { 3533 return true; 3534 } 3535 if (Name != other.Name) return false; 3536 if (!object.Equals(ClientConfig, other.ClientConfig)) return false; 3537 if (NumClients != other.NumClients) return false; 3538 if (!object.Equals(ServerConfig, other.ServerConfig)) return false; 3539 if (NumServers != other.NumServers) return false; 3540 if (WarmupSeconds != other.WarmupSeconds) return false; 3541 if (BenchmarkSeconds != other.BenchmarkSeconds) return false; 3542 if (SpawnLocalWorkerCount != other.SpawnLocalWorkerCount) return false; 3543 return Equals(_unknownFields, other._unknownFields); 3544 } 3545 3546 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3547 public override int GetHashCode() { 3548 int hash = 1; 3549 if (Name.Length != 0) hash ^= Name.GetHashCode(); 3550 if (clientConfig_ != null) hash ^= ClientConfig.GetHashCode(); 3551 if (NumClients != 0) hash ^= NumClients.GetHashCode(); 3552 if (serverConfig_ != null) hash ^= ServerConfig.GetHashCode(); 3553 if (NumServers != 0) hash ^= NumServers.GetHashCode(); 3554 if (WarmupSeconds != 0) hash ^= WarmupSeconds.GetHashCode(); 3555 if (BenchmarkSeconds != 0) hash ^= BenchmarkSeconds.GetHashCode(); 3556 if (SpawnLocalWorkerCount != 0) hash ^= SpawnLocalWorkerCount.GetHashCode(); 3557 if (_unknownFields != null) { 3558 hash ^= _unknownFields.GetHashCode(); 3559 } 3560 return hash; 3561 } 3562 3563 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3564 public override string ToString() { 3565 return pb::JsonFormatter.ToDiagnosticString(this); 3566 } 3567 3568 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3569 public void WriteTo(pb::CodedOutputStream output) { 3570 if (Name.Length != 0) { 3571 output.WriteRawTag(10); 3572 output.WriteString(Name); 3573 } 3574 if (clientConfig_ != null) { 3575 output.WriteRawTag(18); 3576 output.WriteMessage(ClientConfig); 3577 } 3578 if (NumClients != 0) { 3579 output.WriteRawTag(24); 3580 output.WriteInt32(NumClients); 3581 } 3582 if (serverConfig_ != null) { 3583 output.WriteRawTag(34); 3584 output.WriteMessage(ServerConfig); 3585 } 3586 if (NumServers != 0) { 3587 output.WriteRawTag(40); 3588 output.WriteInt32(NumServers); 3589 } 3590 if (WarmupSeconds != 0) { 3591 output.WriteRawTag(48); 3592 output.WriteInt32(WarmupSeconds); 3593 } 3594 if (BenchmarkSeconds != 0) { 3595 output.WriteRawTag(56); 3596 output.WriteInt32(BenchmarkSeconds); 3597 } 3598 if (SpawnLocalWorkerCount != 0) { 3599 output.WriteRawTag(64); 3600 output.WriteInt32(SpawnLocalWorkerCount); 3601 } 3602 if (_unknownFields != null) { 3603 _unknownFields.WriteTo(output); 3604 } 3605 } 3606 3607 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3608 public int CalculateSize() { 3609 int size = 0; 3610 if (Name.Length != 0) { 3611 size += 1 + pb::CodedOutputStream.ComputeStringSize(Name); 3612 } 3613 if (clientConfig_ != null) { 3614 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ClientConfig); 3615 } 3616 if (NumClients != 0) { 3617 size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumClients); 3618 } 3619 if (serverConfig_ != null) { 3620 size += 1 + pb::CodedOutputStream.ComputeMessageSize(ServerConfig); 3621 } 3622 if (NumServers != 0) { 3623 size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumServers); 3624 } 3625 if (WarmupSeconds != 0) { 3626 size += 1 + pb::CodedOutputStream.ComputeInt32Size(WarmupSeconds); 3627 } 3628 if (BenchmarkSeconds != 0) { 3629 size += 1 + pb::CodedOutputStream.ComputeInt32Size(BenchmarkSeconds); 3630 } 3631 if (SpawnLocalWorkerCount != 0) { 3632 size += 1 + pb::CodedOutputStream.ComputeInt32Size(SpawnLocalWorkerCount); 3633 } 3634 if (_unknownFields != null) { 3635 size += _unknownFields.CalculateSize(); 3636 } 3637 return size; 3638 } 3639 3640 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Scenario other)3641 public void MergeFrom(Scenario other) { 3642 if (other == null) { 3643 return; 3644 } 3645 if (other.Name.Length != 0) { 3646 Name = other.Name; 3647 } 3648 if (other.clientConfig_ != null) { 3649 if (clientConfig_ == null) { 3650 ClientConfig = new global::Grpc.Testing.ClientConfig(); 3651 } 3652 ClientConfig.MergeFrom(other.ClientConfig); 3653 } 3654 if (other.NumClients != 0) { 3655 NumClients = other.NumClients; 3656 } 3657 if (other.serverConfig_ != null) { 3658 if (serverConfig_ == null) { 3659 ServerConfig = new global::Grpc.Testing.ServerConfig(); 3660 } 3661 ServerConfig.MergeFrom(other.ServerConfig); 3662 } 3663 if (other.NumServers != 0) { 3664 NumServers = other.NumServers; 3665 } 3666 if (other.WarmupSeconds != 0) { 3667 WarmupSeconds = other.WarmupSeconds; 3668 } 3669 if (other.BenchmarkSeconds != 0) { 3670 BenchmarkSeconds = other.BenchmarkSeconds; 3671 } 3672 if (other.SpawnLocalWorkerCount != 0) { 3673 SpawnLocalWorkerCount = other.SpawnLocalWorkerCount; 3674 } 3675 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3676 } 3677 3678 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3679 public void MergeFrom(pb::CodedInputStream input) { 3680 uint tag; 3681 while ((tag = input.ReadTag()) != 0) { 3682 switch(tag) { 3683 default: 3684 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3685 break; 3686 case 10: { 3687 Name = input.ReadString(); 3688 break; 3689 } 3690 case 18: { 3691 if (clientConfig_ == null) { 3692 ClientConfig = new global::Grpc.Testing.ClientConfig(); 3693 } 3694 input.ReadMessage(ClientConfig); 3695 break; 3696 } 3697 case 24: { 3698 NumClients = input.ReadInt32(); 3699 break; 3700 } 3701 case 34: { 3702 if (serverConfig_ == null) { 3703 ServerConfig = new global::Grpc.Testing.ServerConfig(); 3704 } 3705 input.ReadMessage(ServerConfig); 3706 break; 3707 } 3708 case 40: { 3709 NumServers = input.ReadInt32(); 3710 break; 3711 } 3712 case 48: { 3713 WarmupSeconds = input.ReadInt32(); 3714 break; 3715 } 3716 case 56: { 3717 BenchmarkSeconds = input.ReadInt32(); 3718 break; 3719 } 3720 case 64: { 3721 SpawnLocalWorkerCount = input.ReadInt32(); 3722 break; 3723 } 3724 } 3725 } 3726 } 3727 3728 } 3729 3730 /// <summary> 3731 /// A set of scenarios to be run with qps_json_driver 3732 /// </summary> 3733 public sealed partial class Scenarios : pb::IMessage<Scenarios> { 3734 private static readonly pb::MessageParser<Scenarios> _parser = new pb::MessageParser<Scenarios>(() => new Scenarios()); 3735 private pb::UnknownFieldSet _unknownFields; 3736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3737 public static pb::MessageParser<Scenarios> Parser { get { return _parser; } } 3738 3739 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3740 public static pbr::MessageDescriptor Descriptor { 3741 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[16]; } 3742 } 3743 3744 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3745 pbr::MessageDescriptor pb::IMessage.Descriptor { 3746 get { return Descriptor; } 3747 } 3748 3749 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenarios()3750 public Scenarios() { 3751 OnConstruction(); 3752 } 3753 OnConstruction()3754 partial void OnConstruction(); 3755 3756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Scenarios(Scenarios other)3757 public Scenarios(Scenarios other) : this() { 3758 scenarios_ = other.scenarios_.Clone(); 3759 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3760 } 3761 3762 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3763 public Scenarios Clone() { 3764 return new Scenarios(this); 3765 } 3766 3767 /// <summary>Field number for the "scenarios" field.</summary> 3768 public const int Scenarios_FieldNumber = 1; 3769 private static readonly pb::FieldCodec<global::Grpc.Testing.Scenario> _repeated_scenarios_codec 3770 = pb::FieldCodec.ForMessage(10, global::Grpc.Testing.Scenario.Parser); 3771 private readonly pbc::RepeatedField<global::Grpc.Testing.Scenario> scenarios_ = new pbc::RepeatedField<global::Grpc.Testing.Scenario>(); 3772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3773 public pbc::RepeatedField<global::Grpc.Testing.Scenario> Scenarios_ { 3774 get { return scenarios_; } 3775 } 3776 3777 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)3778 public override bool Equals(object other) { 3779 return Equals(other as Scenarios); 3780 } 3781 3782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(Scenarios other)3783 public bool Equals(Scenarios other) { 3784 if (ReferenceEquals(other, null)) { 3785 return false; 3786 } 3787 if (ReferenceEquals(other, this)) { 3788 return true; 3789 } 3790 if(!scenarios_.Equals(other.scenarios_)) return false; 3791 return Equals(_unknownFields, other._unknownFields); 3792 } 3793 3794 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()3795 public override int GetHashCode() { 3796 int hash = 1; 3797 hash ^= scenarios_.GetHashCode(); 3798 if (_unknownFields != null) { 3799 hash ^= _unknownFields.GetHashCode(); 3800 } 3801 return hash; 3802 } 3803 3804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()3805 public override string ToString() { 3806 return pb::JsonFormatter.ToDiagnosticString(this); 3807 } 3808 3809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)3810 public void WriteTo(pb::CodedOutputStream output) { 3811 scenarios_.WriteTo(output, _repeated_scenarios_codec); 3812 if (_unknownFields != null) { 3813 _unknownFields.WriteTo(output); 3814 } 3815 } 3816 3817 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()3818 public int CalculateSize() { 3819 int size = 0; 3820 size += scenarios_.CalculateSize(_repeated_scenarios_codec); 3821 if (_unknownFields != null) { 3822 size += _unknownFields.CalculateSize(); 3823 } 3824 return size; 3825 } 3826 3827 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(Scenarios other)3828 public void MergeFrom(Scenarios other) { 3829 if (other == null) { 3830 return; 3831 } 3832 scenarios_.Add(other.scenarios_); 3833 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 3834 } 3835 3836 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)3837 public void MergeFrom(pb::CodedInputStream input) { 3838 uint tag; 3839 while ((tag = input.ReadTag()) != 0) { 3840 switch(tag) { 3841 default: 3842 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 3843 break; 3844 case 10: { 3845 scenarios_.AddEntriesFrom(input, _repeated_scenarios_codec); 3846 break; 3847 } 3848 } 3849 } 3850 } 3851 3852 } 3853 3854 /// <summary> 3855 /// Basic summary that can be computed from ClientStats and ServerStats 3856 /// once the scenario has finished. 3857 /// </summary> 3858 public sealed partial class ScenarioResultSummary : pb::IMessage<ScenarioResultSummary> { 3859 private static readonly pb::MessageParser<ScenarioResultSummary> _parser = new pb::MessageParser<ScenarioResultSummary>(() => new ScenarioResultSummary()); 3860 private pb::UnknownFieldSet _unknownFields; 3861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3862 public static pb::MessageParser<ScenarioResultSummary> Parser { get { return _parser; } } 3863 3864 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3865 public static pbr::MessageDescriptor Descriptor { 3866 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[17]; } 3867 } 3868 3869 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3870 pbr::MessageDescriptor pb::IMessage.Descriptor { 3871 get { return Descriptor; } 3872 } 3873 3874 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResultSummary()3875 public ScenarioResultSummary() { 3876 OnConstruction(); 3877 } 3878 OnConstruction()3879 partial void OnConstruction(); 3880 3881 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResultSummary(ScenarioResultSummary other)3882 public ScenarioResultSummary(ScenarioResultSummary other) : this() { 3883 qps_ = other.qps_; 3884 qpsPerServerCore_ = other.qpsPerServerCore_; 3885 serverSystemTime_ = other.serverSystemTime_; 3886 serverUserTime_ = other.serverUserTime_; 3887 clientSystemTime_ = other.clientSystemTime_; 3888 clientUserTime_ = other.clientUserTime_; 3889 latency50_ = other.latency50_; 3890 latency90_ = other.latency90_; 3891 latency95_ = other.latency95_; 3892 latency99_ = other.latency99_; 3893 latency999_ = other.latency999_; 3894 serverCpuUsage_ = other.serverCpuUsage_; 3895 successfulRequestsPerSecond_ = other.successfulRequestsPerSecond_; 3896 failedRequestsPerSecond_ = other.failedRequestsPerSecond_; 3897 clientPollsPerRequest_ = other.clientPollsPerRequest_; 3898 serverPollsPerRequest_ = other.serverPollsPerRequest_; 3899 serverQueriesPerCpuSec_ = other.serverQueriesPerCpuSec_; 3900 clientQueriesPerCpuSec_ = other.clientQueriesPerCpuSec_; 3901 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 3902 } 3903 3904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()3905 public ScenarioResultSummary Clone() { 3906 return new ScenarioResultSummary(this); 3907 } 3908 3909 /// <summary>Field number for the "qps" field.</summary> 3910 public const int QpsFieldNumber = 1; 3911 private double qps_; 3912 /// <summary> 3913 /// Total number of operations per second over all clients. What is counted as 1 'operation' depends on the benchmark scenarios: 3914 /// For unary benchmarks, an operation is processing of a single unary RPC. 3915 /// For streaming benchmarks, an operation is processing of a single ping pong of request and response. 3916 /// </summary> 3917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3918 public double Qps { 3919 get { return qps_; } 3920 set { 3921 qps_ = value; 3922 } 3923 } 3924 3925 /// <summary>Field number for the "qps_per_server_core" field.</summary> 3926 public const int QpsPerServerCoreFieldNumber = 2; 3927 private double qpsPerServerCore_; 3928 /// <summary> 3929 /// QPS per server core. 3930 /// </summary> 3931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3932 public double QpsPerServerCore { 3933 get { return qpsPerServerCore_; } 3934 set { 3935 qpsPerServerCore_ = value; 3936 } 3937 } 3938 3939 /// <summary>Field number for the "server_system_time" field.</summary> 3940 public const int ServerSystemTimeFieldNumber = 3; 3941 private double serverSystemTime_; 3942 /// <summary> 3943 /// The total server cpu load based on system time across all server processes, expressed as percentage of a single cpu core. 3944 /// For example, 85 implies 85% of a cpu core, 125 implies 125% of a cpu core. Since we are accumulating the cpu load across all the server 3945 /// processes, the value could > 100 when there are multiple servers or a single server using multiple threads and cores. 3946 /// Same explanation for the total client cpu load below. 3947 /// </summary> 3948 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3949 public double ServerSystemTime { 3950 get { return serverSystemTime_; } 3951 set { 3952 serverSystemTime_ = value; 3953 } 3954 } 3955 3956 /// <summary>Field number for the "server_user_time" field.</summary> 3957 public const int ServerUserTimeFieldNumber = 4; 3958 private double serverUserTime_; 3959 /// <summary> 3960 /// The total server cpu load based on user time across all server processes, expressed as percentage of a single cpu core. (85 => 85%, 125 => 125%) 3961 /// </summary> 3962 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3963 public double ServerUserTime { 3964 get { return serverUserTime_; } 3965 set { 3966 serverUserTime_ = value; 3967 } 3968 } 3969 3970 /// <summary>Field number for the "client_system_time" field.</summary> 3971 public const int ClientSystemTimeFieldNumber = 5; 3972 private double clientSystemTime_; 3973 /// <summary> 3974 /// The total client cpu load based on system time across all client processes, expressed as percentage of a single cpu core. (85 => 85%, 125 => 125%) 3975 /// </summary> 3976 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3977 public double ClientSystemTime { 3978 get { return clientSystemTime_; } 3979 set { 3980 clientSystemTime_ = value; 3981 } 3982 } 3983 3984 /// <summary>Field number for the "client_user_time" field.</summary> 3985 public const int ClientUserTimeFieldNumber = 6; 3986 private double clientUserTime_; 3987 /// <summary> 3988 /// The total client cpu load based on user time across all client processes, expressed as percentage of a single cpu core. (85 => 85%, 125 => 125%) 3989 /// </summary> 3990 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 3991 public double ClientUserTime { 3992 get { return clientUserTime_; } 3993 set { 3994 clientUserTime_ = value; 3995 } 3996 } 3997 3998 /// <summary>Field number for the "latency_50" field.</summary> 3999 public const int Latency50FieldNumber = 7; 4000 private double latency50_; 4001 /// <summary> 4002 /// X% latency percentiles (in nanoseconds) 4003 /// </summary> 4004 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4005 public double Latency50 { 4006 get { return latency50_; } 4007 set { 4008 latency50_ = value; 4009 } 4010 } 4011 4012 /// <summary>Field number for the "latency_90" field.</summary> 4013 public const int Latency90FieldNumber = 8; 4014 private double latency90_; 4015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4016 public double Latency90 { 4017 get { return latency90_; } 4018 set { 4019 latency90_ = value; 4020 } 4021 } 4022 4023 /// <summary>Field number for the "latency_95" field.</summary> 4024 public const int Latency95FieldNumber = 9; 4025 private double latency95_; 4026 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4027 public double Latency95 { 4028 get { return latency95_; } 4029 set { 4030 latency95_ = value; 4031 } 4032 } 4033 4034 /// <summary>Field number for the "latency_99" field.</summary> 4035 public const int Latency99FieldNumber = 10; 4036 private double latency99_; 4037 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4038 public double Latency99 { 4039 get { return latency99_; } 4040 set { 4041 latency99_ = value; 4042 } 4043 } 4044 4045 /// <summary>Field number for the "latency_999" field.</summary> 4046 public const int Latency999FieldNumber = 11; 4047 private double latency999_; 4048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4049 public double Latency999 { 4050 get { return latency999_; } 4051 set { 4052 latency999_ = value; 4053 } 4054 } 4055 4056 /// <summary>Field number for the "server_cpu_usage" field.</summary> 4057 public const int ServerCpuUsageFieldNumber = 12; 4058 private double serverCpuUsage_; 4059 /// <summary> 4060 /// server cpu usage percentage 4061 /// </summary> 4062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4063 public double ServerCpuUsage { 4064 get { return serverCpuUsage_; } 4065 set { 4066 serverCpuUsage_ = value; 4067 } 4068 } 4069 4070 /// <summary>Field number for the "successful_requests_per_second" field.</summary> 4071 public const int SuccessfulRequestsPerSecondFieldNumber = 13; 4072 private double successfulRequestsPerSecond_; 4073 /// <summary> 4074 /// Number of requests that succeeded/failed 4075 /// </summary> 4076 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4077 public double SuccessfulRequestsPerSecond { 4078 get { return successfulRequestsPerSecond_; } 4079 set { 4080 successfulRequestsPerSecond_ = value; 4081 } 4082 } 4083 4084 /// <summary>Field number for the "failed_requests_per_second" field.</summary> 4085 public const int FailedRequestsPerSecondFieldNumber = 14; 4086 private double failedRequestsPerSecond_; 4087 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4088 public double FailedRequestsPerSecond { 4089 get { return failedRequestsPerSecond_; } 4090 set { 4091 failedRequestsPerSecond_ = value; 4092 } 4093 } 4094 4095 /// <summary>Field number for the "client_polls_per_request" field.</summary> 4096 public const int ClientPollsPerRequestFieldNumber = 15; 4097 private double clientPollsPerRequest_; 4098 /// <summary> 4099 /// Number of polls called inside completion queue per request 4100 /// </summary> 4101 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4102 public double ClientPollsPerRequest { 4103 get { return clientPollsPerRequest_; } 4104 set { 4105 clientPollsPerRequest_ = value; 4106 } 4107 } 4108 4109 /// <summary>Field number for the "server_polls_per_request" field.</summary> 4110 public const int ServerPollsPerRequestFieldNumber = 16; 4111 private double serverPollsPerRequest_; 4112 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4113 public double ServerPollsPerRequest { 4114 get { return serverPollsPerRequest_; } 4115 set { 4116 serverPollsPerRequest_ = value; 4117 } 4118 } 4119 4120 /// <summary>Field number for the "server_queries_per_cpu_sec" field.</summary> 4121 public const int ServerQueriesPerCpuSecFieldNumber = 17; 4122 private double serverQueriesPerCpuSec_; 4123 /// <summary> 4124 /// Queries per CPU-sec over all servers or clients 4125 /// </summary> 4126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4127 public double ServerQueriesPerCpuSec { 4128 get { return serverQueriesPerCpuSec_; } 4129 set { 4130 serverQueriesPerCpuSec_ = value; 4131 } 4132 } 4133 4134 /// <summary>Field number for the "client_queries_per_cpu_sec" field.</summary> 4135 public const int ClientQueriesPerCpuSecFieldNumber = 18; 4136 private double clientQueriesPerCpuSec_; 4137 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4138 public double ClientQueriesPerCpuSec { 4139 get { return clientQueriesPerCpuSec_; } 4140 set { 4141 clientQueriesPerCpuSec_ = value; 4142 } 4143 } 4144 4145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)4146 public override bool Equals(object other) { 4147 return Equals(other as ScenarioResultSummary); 4148 } 4149 4150 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ScenarioResultSummary other)4151 public bool Equals(ScenarioResultSummary other) { 4152 if (ReferenceEquals(other, null)) { 4153 return false; 4154 } 4155 if (ReferenceEquals(other, this)) { 4156 return true; 4157 } 4158 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Qps, other.Qps)) return false; 4159 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(QpsPerServerCore, other.QpsPerServerCore)) return false; 4160 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerSystemTime, other.ServerSystemTime)) return false; 4161 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerUserTime, other.ServerUserTime)) return false; 4162 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientSystemTime, other.ClientSystemTime)) return false; 4163 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientUserTime, other.ClientUserTime)) return false; 4164 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency50, other.Latency50)) return false; 4165 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency90, other.Latency90)) return false; 4166 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency95, other.Latency95)) return false; 4167 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency99, other.Latency99)) return false; 4168 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Latency999, other.Latency999)) return false; 4169 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerCpuUsage, other.ServerCpuUsage)) return false; 4170 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SuccessfulRequestsPerSecond, other.SuccessfulRequestsPerSecond)) return false; 4171 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(FailedRequestsPerSecond, other.FailedRequestsPerSecond)) return false; 4172 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientPollsPerRequest, other.ClientPollsPerRequest)) return false; 4173 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerPollsPerRequest, other.ServerPollsPerRequest)) return false; 4174 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ServerQueriesPerCpuSec, other.ServerQueriesPerCpuSec)) return false; 4175 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ClientQueriesPerCpuSec, other.ClientQueriesPerCpuSec)) return false; 4176 return Equals(_unknownFields, other._unknownFields); 4177 } 4178 4179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()4180 public override int GetHashCode() { 4181 int hash = 1; 4182 if (Qps != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Qps); 4183 if (QpsPerServerCore != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(QpsPerServerCore); 4184 if (ServerSystemTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerSystemTime); 4185 if (ServerUserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerUserTime); 4186 if (ClientSystemTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientSystemTime); 4187 if (ClientUserTime != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientUserTime); 4188 if (Latency50 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency50); 4189 if (Latency90 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency90); 4190 if (Latency95 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency95); 4191 if (Latency99 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency99); 4192 if (Latency999 != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Latency999); 4193 if (ServerCpuUsage != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerCpuUsage); 4194 if (SuccessfulRequestsPerSecond != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SuccessfulRequestsPerSecond); 4195 if (FailedRequestsPerSecond != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(FailedRequestsPerSecond); 4196 if (ClientPollsPerRequest != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientPollsPerRequest); 4197 if (ServerPollsPerRequest != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerPollsPerRequest); 4198 if (ServerQueriesPerCpuSec != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ServerQueriesPerCpuSec); 4199 if (ClientQueriesPerCpuSec != 0D) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClientQueriesPerCpuSec); 4200 if (_unknownFields != null) { 4201 hash ^= _unknownFields.GetHashCode(); 4202 } 4203 return hash; 4204 } 4205 4206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()4207 public override string ToString() { 4208 return pb::JsonFormatter.ToDiagnosticString(this); 4209 } 4210 4211 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)4212 public void WriteTo(pb::CodedOutputStream output) { 4213 if (Qps != 0D) { 4214 output.WriteRawTag(9); 4215 output.WriteDouble(Qps); 4216 } 4217 if (QpsPerServerCore != 0D) { 4218 output.WriteRawTag(17); 4219 output.WriteDouble(QpsPerServerCore); 4220 } 4221 if (ServerSystemTime != 0D) { 4222 output.WriteRawTag(25); 4223 output.WriteDouble(ServerSystemTime); 4224 } 4225 if (ServerUserTime != 0D) { 4226 output.WriteRawTag(33); 4227 output.WriteDouble(ServerUserTime); 4228 } 4229 if (ClientSystemTime != 0D) { 4230 output.WriteRawTag(41); 4231 output.WriteDouble(ClientSystemTime); 4232 } 4233 if (ClientUserTime != 0D) { 4234 output.WriteRawTag(49); 4235 output.WriteDouble(ClientUserTime); 4236 } 4237 if (Latency50 != 0D) { 4238 output.WriteRawTag(57); 4239 output.WriteDouble(Latency50); 4240 } 4241 if (Latency90 != 0D) { 4242 output.WriteRawTag(65); 4243 output.WriteDouble(Latency90); 4244 } 4245 if (Latency95 != 0D) { 4246 output.WriteRawTag(73); 4247 output.WriteDouble(Latency95); 4248 } 4249 if (Latency99 != 0D) { 4250 output.WriteRawTag(81); 4251 output.WriteDouble(Latency99); 4252 } 4253 if (Latency999 != 0D) { 4254 output.WriteRawTag(89); 4255 output.WriteDouble(Latency999); 4256 } 4257 if (ServerCpuUsage != 0D) { 4258 output.WriteRawTag(97); 4259 output.WriteDouble(ServerCpuUsage); 4260 } 4261 if (SuccessfulRequestsPerSecond != 0D) { 4262 output.WriteRawTag(105); 4263 output.WriteDouble(SuccessfulRequestsPerSecond); 4264 } 4265 if (FailedRequestsPerSecond != 0D) { 4266 output.WriteRawTag(113); 4267 output.WriteDouble(FailedRequestsPerSecond); 4268 } 4269 if (ClientPollsPerRequest != 0D) { 4270 output.WriteRawTag(121); 4271 output.WriteDouble(ClientPollsPerRequest); 4272 } 4273 if (ServerPollsPerRequest != 0D) { 4274 output.WriteRawTag(129, 1); 4275 output.WriteDouble(ServerPollsPerRequest); 4276 } 4277 if (ServerQueriesPerCpuSec != 0D) { 4278 output.WriteRawTag(137, 1); 4279 output.WriteDouble(ServerQueriesPerCpuSec); 4280 } 4281 if (ClientQueriesPerCpuSec != 0D) { 4282 output.WriteRawTag(145, 1); 4283 output.WriteDouble(ClientQueriesPerCpuSec); 4284 } 4285 if (_unknownFields != null) { 4286 _unknownFields.WriteTo(output); 4287 } 4288 } 4289 4290 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()4291 public int CalculateSize() { 4292 int size = 0; 4293 if (Qps != 0D) { 4294 size += 1 + 8; 4295 } 4296 if (QpsPerServerCore != 0D) { 4297 size += 1 + 8; 4298 } 4299 if (ServerSystemTime != 0D) { 4300 size += 1 + 8; 4301 } 4302 if (ServerUserTime != 0D) { 4303 size += 1 + 8; 4304 } 4305 if (ClientSystemTime != 0D) { 4306 size += 1 + 8; 4307 } 4308 if (ClientUserTime != 0D) { 4309 size += 1 + 8; 4310 } 4311 if (Latency50 != 0D) { 4312 size += 1 + 8; 4313 } 4314 if (Latency90 != 0D) { 4315 size += 1 + 8; 4316 } 4317 if (Latency95 != 0D) { 4318 size += 1 + 8; 4319 } 4320 if (Latency99 != 0D) { 4321 size += 1 + 8; 4322 } 4323 if (Latency999 != 0D) { 4324 size += 1 + 8; 4325 } 4326 if (ServerCpuUsage != 0D) { 4327 size += 1 + 8; 4328 } 4329 if (SuccessfulRequestsPerSecond != 0D) { 4330 size += 1 + 8; 4331 } 4332 if (FailedRequestsPerSecond != 0D) { 4333 size += 1 + 8; 4334 } 4335 if (ClientPollsPerRequest != 0D) { 4336 size += 1 + 8; 4337 } 4338 if (ServerPollsPerRequest != 0D) { 4339 size += 2 + 8; 4340 } 4341 if (ServerQueriesPerCpuSec != 0D) { 4342 size += 2 + 8; 4343 } 4344 if (ClientQueriesPerCpuSec != 0D) { 4345 size += 2 + 8; 4346 } 4347 if (_unknownFields != null) { 4348 size += _unknownFields.CalculateSize(); 4349 } 4350 return size; 4351 } 4352 4353 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ScenarioResultSummary other)4354 public void MergeFrom(ScenarioResultSummary other) { 4355 if (other == null) { 4356 return; 4357 } 4358 if (other.Qps != 0D) { 4359 Qps = other.Qps; 4360 } 4361 if (other.QpsPerServerCore != 0D) { 4362 QpsPerServerCore = other.QpsPerServerCore; 4363 } 4364 if (other.ServerSystemTime != 0D) { 4365 ServerSystemTime = other.ServerSystemTime; 4366 } 4367 if (other.ServerUserTime != 0D) { 4368 ServerUserTime = other.ServerUserTime; 4369 } 4370 if (other.ClientSystemTime != 0D) { 4371 ClientSystemTime = other.ClientSystemTime; 4372 } 4373 if (other.ClientUserTime != 0D) { 4374 ClientUserTime = other.ClientUserTime; 4375 } 4376 if (other.Latency50 != 0D) { 4377 Latency50 = other.Latency50; 4378 } 4379 if (other.Latency90 != 0D) { 4380 Latency90 = other.Latency90; 4381 } 4382 if (other.Latency95 != 0D) { 4383 Latency95 = other.Latency95; 4384 } 4385 if (other.Latency99 != 0D) { 4386 Latency99 = other.Latency99; 4387 } 4388 if (other.Latency999 != 0D) { 4389 Latency999 = other.Latency999; 4390 } 4391 if (other.ServerCpuUsage != 0D) { 4392 ServerCpuUsage = other.ServerCpuUsage; 4393 } 4394 if (other.SuccessfulRequestsPerSecond != 0D) { 4395 SuccessfulRequestsPerSecond = other.SuccessfulRequestsPerSecond; 4396 } 4397 if (other.FailedRequestsPerSecond != 0D) { 4398 FailedRequestsPerSecond = other.FailedRequestsPerSecond; 4399 } 4400 if (other.ClientPollsPerRequest != 0D) { 4401 ClientPollsPerRequest = other.ClientPollsPerRequest; 4402 } 4403 if (other.ServerPollsPerRequest != 0D) { 4404 ServerPollsPerRequest = other.ServerPollsPerRequest; 4405 } 4406 if (other.ServerQueriesPerCpuSec != 0D) { 4407 ServerQueriesPerCpuSec = other.ServerQueriesPerCpuSec; 4408 } 4409 if (other.ClientQueriesPerCpuSec != 0D) { 4410 ClientQueriesPerCpuSec = other.ClientQueriesPerCpuSec; 4411 } 4412 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 4413 } 4414 4415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)4416 public void MergeFrom(pb::CodedInputStream input) { 4417 uint tag; 4418 while ((tag = input.ReadTag()) != 0) { 4419 switch(tag) { 4420 default: 4421 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 4422 break; 4423 case 9: { 4424 Qps = input.ReadDouble(); 4425 break; 4426 } 4427 case 17: { 4428 QpsPerServerCore = input.ReadDouble(); 4429 break; 4430 } 4431 case 25: { 4432 ServerSystemTime = input.ReadDouble(); 4433 break; 4434 } 4435 case 33: { 4436 ServerUserTime = input.ReadDouble(); 4437 break; 4438 } 4439 case 41: { 4440 ClientSystemTime = input.ReadDouble(); 4441 break; 4442 } 4443 case 49: { 4444 ClientUserTime = input.ReadDouble(); 4445 break; 4446 } 4447 case 57: { 4448 Latency50 = input.ReadDouble(); 4449 break; 4450 } 4451 case 65: { 4452 Latency90 = input.ReadDouble(); 4453 break; 4454 } 4455 case 73: { 4456 Latency95 = input.ReadDouble(); 4457 break; 4458 } 4459 case 81: { 4460 Latency99 = input.ReadDouble(); 4461 break; 4462 } 4463 case 89: { 4464 Latency999 = input.ReadDouble(); 4465 break; 4466 } 4467 case 97: { 4468 ServerCpuUsage = input.ReadDouble(); 4469 break; 4470 } 4471 case 105: { 4472 SuccessfulRequestsPerSecond = input.ReadDouble(); 4473 break; 4474 } 4475 case 113: { 4476 FailedRequestsPerSecond = input.ReadDouble(); 4477 break; 4478 } 4479 case 121: { 4480 ClientPollsPerRequest = input.ReadDouble(); 4481 break; 4482 } 4483 case 129: { 4484 ServerPollsPerRequest = input.ReadDouble(); 4485 break; 4486 } 4487 case 137: { 4488 ServerQueriesPerCpuSec = input.ReadDouble(); 4489 break; 4490 } 4491 case 145: { 4492 ClientQueriesPerCpuSec = input.ReadDouble(); 4493 break; 4494 } 4495 } 4496 } 4497 } 4498 4499 } 4500 4501 /// <summary> 4502 /// Results of a single benchmark scenario. 4503 /// </summary> 4504 public sealed partial class ScenarioResult : pb::IMessage<ScenarioResult> { 4505 private static readonly pb::MessageParser<ScenarioResult> _parser = new pb::MessageParser<ScenarioResult>(() => new ScenarioResult()); 4506 private pb::UnknownFieldSet _unknownFields; 4507 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4508 public static pb::MessageParser<ScenarioResult> Parser { get { return _parser; } } 4509 4510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4511 public static pbr::MessageDescriptor Descriptor { 4512 get { return global::Grpc.Testing.ControlReflection.Descriptor.MessageTypes[18]; } 4513 } 4514 4515 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4516 pbr::MessageDescriptor pb::IMessage.Descriptor { 4517 get { return Descriptor; } 4518 } 4519 4520 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResult()4521 public ScenarioResult() { 4522 OnConstruction(); 4523 } 4524 OnConstruction()4525 partial void OnConstruction(); 4526 4527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ScenarioResult(ScenarioResult other)4528 public ScenarioResult(ScenarioResult other) : this() { 4529 scenario_ = other.scenario_ != null ? other.scenario_.Clone() : null; 4530 latencies_ = other.latencies_ != null ? other.latencies_.Clone() : null; 4531 clientStats_ = other.clientStats_.Clone(); 4532 serverStats_ = other.serverStats_.Clone(); 4533 serverCores_ = other.serverCores_.Clone(); 4534 summary_ = other.summary_ != null ? other.summary_.Clone() : null; 4535 clientSuccess_ = other.clientSuccess_.Clone(); 4536 serverSuccess_ = other.serverSuccess_.Clone(); 4537 requestResults_ = other.requestResults_.Clone(); 4538 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); 4539 } 4540 4541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Clone()4542 public ScenarioResult Clone() { 4543 return new ScenarioResult(this); 4544 } 4545 4546 /// <summary>Field number for the "scenario" field.</summary> 4547 public const int ScenarioFieldNumber = 1; 4548 private global::Grpc.Testing.Scenario scenario_; 4549 /// <summary> 4550 /// Inputs used to run the scenario. 4551 /// </summary> 4552 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4553 public global::Grpc.Testing.Scenario Scenario { 4554 get { return scenario_; } 4555 set { 4556 scenario_ = value; 4557 } 4558 } 4559 4560 /// <summary>Field number for the "latencies" field.</summary> 4561 public const int LatenciesFieldNumber = 2; 4562 private global::Grpc.Testing.HistogramData latencies_; 4563 /// <summary> 4564 /// Histograms from all clients merged into one histogram. 4565 /// </summary> 4566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4567 public global::Grpc.Testing.HistogramData Latencies { 4568 get { return latencies_; } 4569 set { 4570 latencies_ = value; 4571 } 4572 } 4573 4574 /// <summary>Field number for the "client_stats" field.</summary> 4575 public const int ClientStatsFieldNumber = 3; 4576 private static readonly pb::FieldCodec<global::Grpc.Testing.ClientStats> _repeated_clientStats_codec 4577 = pb::FieldCodec.ForMessage(26, global::Grpc.Testing.ClientStats.Parser); 4578 private readonly pbc::RepeatedField<global::Grpc.Testing.ClientStats> clientStats_ = new pbc::RepeatedField<global::Grpc.Testing.ClientStats>(); 4579 /// <summary> 4580 /// Client stats for each client 4581 /// </summary> 4582 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4583 public pbc::RepeatedField<global::Grpc.Testing.ClientStats> ClientStats { 4584 get { return clientStats_; } 4585 } 4586 4587 /// <summary>Field number for the "server_stats" field.</summary> 4588 public const int ServerStatsFieldNumber = 4; 4589 private static readonly pb::FieldCodec<global::Grpc.Testing.ServerStats> _repeated_serverStats_codec 4590 = pb::FieldCodec.ForMessage(34, global::Grpc.Testing.ServerStats.Parser); 4591 private readonly pbc::RepeatedField<global::Grpc.Testing.ServerStats> serverStats_ = new pbc::RepeatedField<global::Grpc.Testing.ServerStats>(); 4592 /// <summary> 4593 /// Server stats for each server 4594 /// </summary> 4595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4596 public pbc::RepeatedField<global::Grpc.Testing.ServerStats> ServerStats { 4597 get { return serverStats_; } 4598 } 4599 4600 /// <summary>Field number for the "server_cores" field.</summary> 4601 public const int ServerCoresFieldNumber = 5; 4602 private static readonly pb::FieldCodec<int> _repeated_serverCores_codec 4603 = pb::FieldCodec.ForInt32(42); 4604 private readonly pbc::RepeatedField<int> serverCores_ = new pbc::RepeatedField<int>(); 4605 /// <summary> 4606 /// Number of cores available to each server 4607 /// </summary> 4608 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4609 public pbc::RepeatedField<int> ServerCores { 4610 get { return serverCores_; } 4611 } 4612 4613 /// <summary>Field number for the "summary" field.</summary> 4614 public const int SummaryFieldNumber = 6; 4615 private global::Grpc.Testing.ScenarioResultSummary summary_; 4616 /// <summary> 4617 /// An after-the-fact computed summary 4618 /// </summary> 4619 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4620 public global::Grpc.Testing.ScenarioResultSummary Summary { 4621 get { return summary_; } 4622 set { 4623 summary_ = value; 4624 } 4625 } 4626 4627 /// <summary>Field number for the "client_success" field.</summary> 4628 public const int ClientSuccessFieldNumber = 7; 4629 private static readonly pb::FieldCodec<bool> _repeated_clientSuccess_codec 4630 = pb::FieldCodec.ForBool(58); 4631 private readonly pbc::RepeatedField<bool> clientSuccess_ = new pbc::RepeatedField<bool>(); 4632 /// <summary> 4633 /// Information on success or failure of each worker 4634 /// </summary> 4635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4636 public pbc::RepeatedField<bool> ClientSuccess { 4637 get { return clientSuccess_; } 4638 } 4639 4640 /// <summary>Field number for the "server_success" field.</summary> 4641 public const int ServerSuccessFieldNumber = 8; 4642 private static readonly pb::FieldCodec<bool> _repeated_serverSuccess_codec 4643 = pb::FieldCodec.ForBool(66); 4644 private readonly pbc::RepeatedField<bool> serverSuccess_ = new pbc::RepeatedField<bool>(); 4645 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4646 public pbc::RepeatedField<bool> ServerSuccess { 4647 get { return serverSuccess_; } 4648 } 4649 4650 /// <summary>Field number for the "request_results" field.</summary> 4651 public const int RequestResultsFieldNumber = 9; 4652 private static readonly pb::FieldCodec<global::Grpc.Testing.RequestResultCount> _repeated_requestResults_codec 4653 = pb::FieldCodec.ForMessage(74, global::Grpc.Testing.RequestResultCount.Parser); 4654 private readonly pbc::RepeatedField<global::Grpc.Testing.RequestResultCount> requestResults_ = new pbc::RepeatedField<global::Grpc.Testing.RequestResultCount>(); 4655 /// <summary> 4656 /// Number of failed requests (one row per status code seen) 4657 /// </summary> 4658 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] 4659 public pbc::RepeatedField<global::Grpc.Testing.RequestResultCount> RequestResults { 4660 get { return requestResults_; } 4661 } 4662 4663 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(object other)4664 public override bool Equals(object other) { 4665 return Equals(other as ScenarioResult); 4666 } 4667 4668 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] Equals(ScenarioResult other)4669 public bool Equals(ScenarioResult other) { 4670 if (ReferenceEquals(other, null)) { 4671 return false; 4672 } 4673 if (ReferenceEquals(other, this)) { 4674 return true; 4675 } 4676 if (!object.Equals(Scenario, other.Scenario)) return false; 4677 if (!object.Equals(Latencies, other.Latencies)) return false; 4678 if(!clientStats_.Equals(other.clientStats_)) return false; 4679 if(!serverStats_.Equals(other.serverStats_)) return false; 4680 if(!serverCores_.Equals(other.serverCores_)) return false; 4681 if (!object.Equals(Summary, other.Summary)) return false; 4682 if(!clientSuccess_.Equals(other.clientSuccess_)) return false; 4683 if(!serverSuccess_.Equals(other.serverSuccess_)) return false; 4684 if(!requestResults_.Equals(other.requestResults_)) return false; 4685 return Equals(_unknownFields, other._unknownFields); 4686 } 4687 4688 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] GetHashCode()4689 public override int GetHashCode() { 4690 int hash = 1; 4691 if (scenario_ != null) hash ^= Scenario.GetHashCode(); 4692 if (latencies_ != null) hash ^= Latencies.GetHashCode(); 4693 hash ^= clientStats_.GetHashCode(); 4694 hash ^= serverStats_.GetHashCode(); 4695 hash ^= serverCores_.GetHashCode(); 4696 if (summary_ != null) hash ^= Summary.GetHashCode(); 4697 hash ^= clientSuccess_.GetHashCode(); 4698 hash ^= serverSuccess_.GetHashCode(); 4699 hash ^= requestResults_.GetHashCode(); 4700 if (_unknownFields != null) { 4701 hash ^= _unknownFields.GetHashCode(); 4702 } 4703 return hash; 4704 } 4705 4706 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] ToString()4707 public override string ToString() { 4708 return pb::JsonFormatter.ToDiagnosticString(this); 4709 } 4710 4711 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] WriteTo(pb::CodedOutputStream output)4712 public void WriteTo(pb::CodedOutputStream output) { 4713 if (scenario_ != null) { 4714 output.WriteRawTag(10); 4715 output.WriteMessage(Scenario); 4716 } 4717 if (latencies_ != null) { 4718 output.WriteRawTag(18); 4719 output.WriteMessage(Latencies); 4720 } 4721 clientStats_.WriteTo(output, _repeated_clientStats_codec); 4722 serverStats_.WriteTo(output, _repeated_serverStats_codec); 4723 serverCores_.WriteTo(output, _repeated_serverCores_codec); 4724 if (summary_ != null) { 4725 output.WriteRawTag(50); 4726 output.WriteMessage(Summary); 4727 } 4728 clientSuccess_.WriteTo(output, _repeated_clientSuccess_codec); 4729 serverSuccess_.WriteTo(output, _repeated_serverSuccess_codec); 4730 requestResults_.WriteTo(output, _repeated_requestResults_codec); 4731 if (_unknownFields != null) { 4732 _unknownFields.WriteTo(output); 4733 } 4734 } 4735 4736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] CalculateSize()4737 public int CalculateSize() { 4738 int size = 0; 4739 if (scenario_ != null) { 4740 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Scenario); 4741 } 4742 if (latencies_ != null) { 4743 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Latencies); 4744 } 4745 size += clientStats_.CalculateSize(_repeated_clientStats_codec); 4746 size += serverStats_.CalculateSize(_repeated_serverStats_codec); 4747 size += serverCores_.CalculateSize(_repeated_serverCores_codec); 4748 if (summary_ != null) { 4749 size += 1 + pb::CodedOutputStream.ComputeMessageSize(Summary); 4750 } 4751 size += clientSuccess_.CalculateSize(_repeated_clientSuccess_codec); 4752 size += serverSuccess_.CalculateSize(_repeated_serverSuccess_codec); 4753 size += requestResults_.CalculateSize(_repeated_requestResults_codec); 4754 if (_unknownFields != null) { 4755 size += _unknownFields.CalculateSize(); 4756 } 4757 return size; 4758 } 4759 4760 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(ScenarioResult other)4761 public void MergeFrom(ScenarioResult other) { 4762 if (other == null) { 4763 return; 4764 } 4765 if (other.scenario_ != null) { 4766 if (scenario_ == null) { 4767 Scenario = new global::Grpc.Testing.Scenario(); 4768 } 4769 Scenario.MergeFrom(other.Scenario); 4770 } 4771 if (other.latencies_ != null) { 4772 if (latencies_ == null) { 4773 Latencies = new global::Grpc.Testing.HistogramData(); 4774 } 4775 Latencies.MergeFrom(other.Latencies); 4776 } 4777 clientStats_.Add(other.clientStats_); 4778 serverStats_.Add(other.serverStats_); 4779 serverCores_.Add(other.serverCores_); 4780 if (other.summary_ != null) { 4781 if (summary_ == null) { 4782 Summary = new global::Grpc.Testing.ScenarioResultSummary(); 4783 } 4784 Summary.MergeFrom(other.Summary); 4785 } 4786 clientSuccess_.Add(other.clientSuccess_); 4787 serverSuccess_.Add(other.serverSuccess_); 4788 requestResults_.Add(other.requestResults_); 4789 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); 4790 } 4791 4792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute] MergeFrom(pb::CodedInputStream input)4793 public void MergeFrom(pb::CodedInputStream input) { 4794 uint tag; 4795 while ((tag = input.ReadTag()) != 0) { 4796 switch(tag) { 4797 default: 4798 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); 4799 break; 4800 case 10: { 4801 if (scenario_ == null) { 4802 Scenario = new global::Grpc.Testing.Scenario(); 4803 } 4804 input.ReadMessage(Scenario); 4805 break; 4806 } 4807 case 18: { 4808 if (latencies_ == null) { 4809 Latencies = new global::Grpc.Testing.HistogramData(); 4810 } 4811 input.ReadMessage(Latencies); 4812 break; 4813 } 4814 case 26: { 4815 clientStats_.AddEntriesFrom(input, _repeated_clientStats_codec); 4816 break; 4817 } 4818 case 34: { 4819 serverStats_.AddEntriesFrom(input, _repeated_serverStats_codec); 4820 break; 4821 } 4822 case 42: 4823 case 40: { 4824 serverCores_.AddEntriesFrom(input, _repeated_serverCores_codec); 4825 break; 4826 } 4827 case 50: { 4828 if (summary_ == null) { 4829 Summary = new global::Grpc.Testing.ScenarioResultSummary(); 4830 } 4831 input.ReadMessage(Summary); 4832 break; 4833 } 4834 case 58: 4835 case 56: { 4836 clientSuccess_.AddEntriesFrom(input, _repeated_clientSuccess_codec); 4837 break; 4838 } 4839 case 66: 4840 case 64: { 4841 serverSuccess_.AddEntriesFrom(input, _repeated_serverSuccess_codec); 4842 break; 4843 } 4844 case 74: { 4845 requestResults_.AddEntriesFrom(input, _repeated_requestResults_codec); 4846 break; 4847 } 4848 } 4849 } 4850 } 4851 4852 } 4853 4854 #endregion 4855 4856 } 4857 4858 #endregion Designer generated code 4859