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