From 9c8818d2ee7453b1006240bccff2adf85388ce4f Mon Sep 17 00:00:00 2001 From: Jan Tattermusch Date: Mon, 30 Nov 2020 18:27:18 +0100 Subject: [PATCH] regenerate proto files for csharp, php, ruby --- .../Grpc.IntegrationTesting/Messages.cs | 997 +++++++++++++++++- src/csharp/Grpc.IntegrationTesting/Test.cs | 20 +- .../Grpc.IntegrationTesting/TestGrpc.cs | 230 +++- .../tests/generated_code/GPBMetadata/Math.php | Bin 1222 -> 849 bytes .../Src/Proto/Grpc/Testing/Messages.php | Bin 6886 -> 3709 bytes .../Src/Proto/Grpc/Testing/PBEmpty.php | 9 +- .../Src/Proto/Grpc/Testing/Test.php | Bin 3991 -> 2324 bytes 7 files changed, 1239 insertions(+), 17 deletions(-) diff --git a/src/csharp/Grpc.IntegrationTesting/Messages.cs b/src/csharp/Grpc.IntegrationTesting/Messages.cs index 083dbb22af7..9fe22e97de1 100644 --- a/src/csharp/Grpc.IntegrationTesting/Messages.cs +++ b/src/csharp/Grpc.IntegrationTesting/Messages.cs @@ -69,11 +69,32 @@ namespace Grpc.Testing { "IAEoCRINCgV2YWx1ZRgCIAEoBToCOAEaMQoPUnBjc0J5UGVlckVudHJ5EgsK", "A2tleRgBIAEoCRINCgV2YWx1ZRgCIAEoBToCOAEaZwoRUnBjc0J5TWV0aG9k", "RW50cnkSCwoDa2V5GAEgASgJEkEKBXZhbHVlGAIgASgLMjIuZ3JwYy50ZXN0", - "aW5nLkxvYWRCYWxhbmNlclN0YXRzUmVzcG9uc2UuUnBjc0J5UGVlcjoCOAEq", - "HwoLUGF5bG9hZFR5cGUSEAoMQ09NUFJFU1NBQkxFEAAqbwoPR3JwY2xiUm91", - "dGVUeXBlEh0KGUdSUENMQl9ST1VURV9UWVBFX1VOS05PV04QABIeChpHUlBD", - "TEJfUk9VVEVfVFlQRV9GQUxMQkFDSxABEh0KGUdSUENMQl9ST1VURV9UWVBF", - "X0JBQ0tFTkQQAmIGcHJvdG8z")); + "aW5nLkxvYWRCYWxhbmNlclN0YXRzUmVzcG9uc2UuUnBjc0J5UGVlcjoCOAEi", + "JQojTG9hZEJhbGFuY2VyQWNjdW11bGF0ZWRTdGF0c1JlcXVlc3QiwgQKJExv", + "YWRCYWxhbmNlckFjY3VtdWxhdGVkU3RhdHNSZXNwb25zZRJyChpudW1fcnBj", + "c19zdGFydGVkX2J5X21ldGhvZBgBIAMoCzJOLmdycGMudGVzdGluZy5Mb2Fk", + "QmFsYW5jZXJBY2N1bXVsYXRlZFN0YXRzUmVzcG9uc2UuTnVtUnBjc1N0YXJ0", + "ZWRCeU1ldGhvZEVudHJ5EnYKHG51bV9ycGNzX3N1Y2NlZWRlZF9ieV9tZXRo", + "b2QYAiADKAsyUC5ncnBjLnRlc3RpbmcuTG9hZEJhbGFuY2VyQWNjdW11bGF0", + "ZWRTdGF0c1Jlc3BvbnNlLk51bVJwY3NTdWNjZWVkZWRCeU1ldGhvZEVudHJ5", + "EnAKGW51bV9ycGNzX2ZhaWxlZF9ieV9tZXRob2QYAyADKAsyTS5ncnBjLnRl", + "c3RpbmcuTG9hZEJhbGFuY2VyQWNjdW11bGF0ZWRTdGF0c1Jlc3BvbnNlLk51", + "bVJwY3NGYWlsZWRCeU1ldGhvZEVudHJ5Gj0KG051bVJwY3NTdGFydGVkQnlN", + "ZXRob2RFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAU6AjgBGj8K", + "HU51bVJwY3NTdWNjZWVkZWRCeU1ldGhvZEVudHJ5EgsKA2tleRgBIAEoCRIN", + "CgV2YWx1ZRgCIAEoBToCOAEaPAoaTnVtUnBjc0ZhaWxlZEJ5TWV0aG9kRW50", + "cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgFOgI4ASKlAgoWQ2xpZW50", + "Q29uZmlndXJlUmVxdWVzdBI7CgV0eXBlcxgBIAMoDjIsLmdycGMudGVzdGlu", + "Zy5DbGllbnRDb25maWd1cmVSZXF1ZXN0LlJwY1R5cGUSPwoIbWV0YWRhdGEY", + "AiADKAsyLS5ncnBjLnRlc3RpbmcuQ2xpZW50Q29uZmlndXJlUmVxdWVzdC5N", + "ZXRhZGF0YRpiCghNZXRhZGF0YRI6CgR0eXBlGAEgASgOMiwuZ3JwYy50ZXN0", + "aW5nLkNsaWVudENvbmZpZ3VyZVJlcXVlc3QuUnBjVHlwZRILCgNrZXkYAiAB", + "KAkSDQoFdmFsdWUYAyABKAkiKQoHUnBjVHlwZRIOCgpFTVBUWV9DQUxMEAAS", + "DgoKVU5BUllfQ0FMTBABIhkKF0NsaWVudENvbmZpZ3VyZVJlc3BvbnNlKh8K", + "C1BheWxvYWRUeXBlEhAKDENPTVBSRVNTQUJMRRAAKm8KD0dycGNsYlJvdXRl", + "VHlwZRIdChlHUlBDTEJfUk9VVEVfVFlQRV9VTktOT1dOEAASHgoaR1JQQ0xC", + "X1JPVVRFX1RZUEVfRkFMTEJBQ0sQARIdChlHUlBDTEJfUk9VVEVfVFlQRV9C", + "QUNLRU5EEAJiBnByb3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Grpc.Testing.PayloadType), typeof(global::Grpc.Testing.GrpclbRouteType), }, null, new pbr::GeneratedClrTypeInfo[] { @@ -91,7 +112,11 @@ namespace Grpc.Testing { new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ReconnectInfo), global::Grpc.Testing.ReconnectInfo.Parser, new[]{ "Passed", "BackoffMs" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadBalancerStatsRequest), global::Grpc.Testing.LoadBalancerStatsRequest.Parser, new[]{ "NumRpcs", "TimeoutSec" }, null, null, null, null), new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadBalancerStatsResponse), global::Grpc.Testing.LoadBalancerStatsResponse.Parser, new[]{ "RpcsByPeer", "NumFailures", "RpcsByMethod" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadBalancerStatsResponse.Types.RpcsByPeer), global::Grpc.Testing.LoadBalancerStatsResponse.Types.RpcsByPeer.Parser, new[]{ "RpcsByPeer_" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, }), - null, null, }) + null, null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest), global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest.Parser, null, null, null, null, null), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.LoadBalancerAccumulatedStatsResponse), global::Grpc.Testing.LoadBalancerAccumulatedStatsResponse.Parser, new[]{ "NumRpcsStartedByMethod", "NumRpcsSucceededByMethod", "NumRpcsFailedByMethod" }, null, null, null, new pbr::GeneratedClrTypeInfo[] { null, null, null, }), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientConfigureRequest), global::Grpc.Testing.ClientConfigureRequest.Parser, new[]{ "Types_", "Metadata" }, null, new[]{ typeof(global::Grpc.Testing.ClientConfigureRequest.Types.RpcType) }, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientConfigureRequest.Types.Metadata), global::Grpc.Testing.ClientConfigureRequest.Types.Metadata.Parser, new[]{ "Type", "Key", "Value" }, null, null, null, null)}), + new pbr::GeneratedClrTypeInfo(typeof(global::Grpc.Testing.ClientConfigureResponse), global::Grpc.Testing.ClientConfigureResponse.Parser, null, null, null, null, null) })); } #endregion @@ -3866,6 +3891,966 @@ namespace Grpc.Testing { } + /// + /// Request for retrieving a test client's accumulated stats. + /// + public sealed partial class LoadBalancerAccumulatedStatsRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LoadBalancerAccumulatedStatsRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Testing.MessagesReflection.Descriptor.MessageTypes[14]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public LoadBalancerAccumulatedStatsRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public LoadBalancerAccumulatedStatsRequest(LoadBalancerAccumulatedStatsRequest other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public LoadBalancerAccumulatedStatsRequest Clone() { + return new LoadBalancerAccumulatedStatsRequest(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as LoadBalancerAccumulatedStatsRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(LoadBalancerAccumulatedStatsRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(LoadBalancerAccumulatedStatsRequest other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + + /// + /// Accumulated stats for RPCs sent by a test client. + /// + public sealed partial class LoadBalancerAccumulatedStatsResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new LoadBalancerAccumulatedStatsResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Testing.MessagesReflection.Descriptor.MessageTypes[15]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public LoadBalancerAccumulatedStatsResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public LoadBalancerAccumulatedStatsResponse(LoadBalancerAccumulatedStatsResponse other) : this() { + numRpcsStartedByMethod_ = other.numRpcsStartedByMethod_.Clone(); + numRpcsSucceededByMethod_ = other.numRpcsSucceededByMethod_.Clone(); + numRpcsFailedByMethod_ = other.numRpcsFailedByMethod_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public LoadBalancerAccumulatedStatsResponse Clone() { + return new LoadBalancerAccumulatedStatsResponse(this); + } + + /// Field number for the "num_rpcs_started_by_method" field. + public const int NumRpcsStartedByMethodFieldNumber = 1; + private static readonly pbc::MapField.Codec _map_numRpcsStartedByMethod_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForInt32(16, 0), 10); + private readonly pbc::MapField numRpcsStartedByMethod_ = new pbc::MapField(); + /// + /// The total number of RPCs have ever issued for each type. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField NumRpcsStartedByMethod { + get { return numRpcsStartedByMethod_; } + } + + /// Field number for the "num_rpcs_succeeded_by_method" field. + public const int NumRpcsSucceededByMethodFieldNumber = 2; + private static readonly pbc::MapField.Codec _map_numRpcsSucceededByMethod_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForInt32(16, 0), 18); + private readonly pbc::MapField numRpcsSucceededByMethod_ = new pbc::MapField(); + /// + /// The total number of RPCs have ever completed successfully for each type. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField NumRpcsSucceededByMethod { + get { return numRpcsSucceededByMethod_; } + } + + /// Field number for the "num_rpcs_failed_by_method" field. + public const int NumRpcsFailedByMethodFieldNumber = 3; + private static readonly pbc::MapField.Codec _map_numRpcsFailedByMethod_codec + = new pbc::MapField.Codec(pb::FieldCodec.ForString(10, ""), pb::FieldCodec.ForInt32(16, 0), 26); + private readonly pbc::MapField numRpcsFailedByMethod_ = new pbc::MapField(); + /// + /// The total number of RPCs have ever failed for each type. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::MapField NumRpcsFailedByMethod { + get { return numRpcsFailedByMethod_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as LoadBalancerAccumulatedStatsResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(LoadBalancerAccumulatedStatsResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (!NumRpcsStartedByMethod.Equals(other.NumRpcsStartedByMethod)) return false; + if (!NumRpcsSucceededByMethod.Equals(other.NumRpcsSucceededByMethod)) return false; + if (!NumRpcsFailedByMethod.Equals(other.NumRpcsFailedByMethod)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= NumRpcsStartedByMethod.GetHashCode(); + hash ^= NumRpcsSucceededByMethod.GetHashCode(); + hash ^= NumRpcsFailedByMethod.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + numRpcsStartedByMethod_.WriteTo(output, _map_numRpcsStartedByMethod_codec); + numRpcsSucceededByMethod_.WriteTo(output, _map_numRpcsSucceededByMethod_codec); + numRpcsFailedByMethod_.WriteTo(output, _map_numRpcsFailedByMethod_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + numRpcsStartedByMethod_.WriteTo(ref output, _map_numRpcsStartedByMethod_codec); + numRpcsSucceededByMethod_.WriteTo(ref output, _map_numRpcsSucceededByMethod_codec); + numRpcsFailedByMethod_.WriteTo(ref output, _map_numRpcsFailedByMethod_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += numRpcsStartedByMethod_.CalculateSize(_map_numRpcsStartedByMethod_codec); + size += numRpcsSucceededByMethod_.CalculateSize(_map_numRpcsSucceededByMethod_codec); + size += numRpcsFailedByMethod_.CalculateSize(_map_numRpcsFailedByMethod_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(LoadBalancerAccumulatedStatsResponse other) { + if (other == null) { + return; + } + numRpcsStartedByMethod_.Add(other.numRpcsStartedByMethod_); + numRpcsSucceededByMethod_.Add(other.numRpcsSucceededByMethod_); + numRpcsFailedByMethod_.Add(other.numRpcsFailedByMethod_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: { + numRpcsStartedByMethod_.AddEntriesFrom(input, _map_numRpcsStartedByMethod_codec); + break; + } + case 18: { + numRpcsSucceededByMethod_.AddEntriesFrom(input, _map_numRpcsSucceededByMethod_codec); + break; + } + case 26: { + numRpcsFailedByMethod_.AddEntriesFrom(input, _map_numRpcsFailedByMethod_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: { + numRpcsStartedByMethod_.AddEntriesFrom(ref input, _map_numRpcsStartedByMethod_codec); + break; + } + case 18: { + numRpcsSucceededByMethod_.AddEntriesFrom(ref input, _map_numRpcsSucceededByMethod_codec); + break; + } + case 26: { + numRpcsFailedByMethod_.AddEntriesFrom(ref input, _map_numRpcsFailedByMethod_codec); + break; + } + } + } + } + #endif + + } + + /// + /// Configurations for a test client. + /// + public sealed partial class ClientConfigureRequest : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ClientConfigureRequest()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Testing.MessagesReflection.Descriptor.MessageTypes[16]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ClientConfigureRequest() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ClientConfigureRequest(ClientConfigureRequest other) : this() { + types_ = other.types_.Clone(); + metadata_ = other.metadata_.Clone(); + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ClientConfigureRequest Clone() { + return new ClientConfigureRequest(this); + } + + /// Field number for the "types" field. + public const int Types_FieldNumber = 1; + private static readonly pb::FieldCodec _repeated_types_codec + = pb::FieldCodec.ForEnum(10, x => (int) x, x => (global::Grpc.Testing.ClientConfigureRequest.Types.RpcType) x); + private readonly pbc::RepeatedField types_ = new pbc::RepeatedField(); + /// + /// The types of RPCs the client sends. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Types_ { + get { return types_; } + } + + /// Field number for the "metadata" field. + public const int MetadataFieldNumber = 2; + private static readonly pb::FieldCodec _repeated_metadata_codec + = pb::FieldCodec.ForMessage(18, global::Grpc.Testing.ClientConfigureRequest.Types.Metadata.Parser); + private readonly pbc::RepeatedField metadata_ = new pbc::RepeatedField(); + /// + /// The collection of custom metadata to be attached to RPCs sent by the client. + /// + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public pbc::RepeatedField Metadata { + get { return metadata_; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ClientConfigureRequest); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ClientConfigureRequest other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if(!types_.Equals(other.types_)) return false; + if(!metadata_.Equals(other.metadata_)) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + hash ^= types_.GetHashCode(); + hash ^= metadata_.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + types_.WriteTo(output, _repeated_types_codec); + metadata_.WriteTo(output, _repeated_metadata_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + types_.WriteTo(ref output, _repeated_types_codec); + metadata_.WriteTo(ref output, _repeated_metadata_codec); + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + size += types_.CalculateSize(_repeated_types_codec); + size += metadata_.CalculateSize(_repeated_metadata_codec); + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ClientConfigureRequest other) { + if (other == null) { + return; + } + types_.Add(other.types_); + metadata_.Add(other.metadata_); + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 10: + case 8: { + types_.AddEntriesFrom(input, _repeated_types_codec); + break; + } + case 18: { + metadata_.AddEntriesFrom(input, _repeated_metadata_codec); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 10: + case 8: { + types_.AddEntriesFrom(ref input, _repeated_types_codec); + break; + } + case 18: { + metadata_.AddEntriesFrom(ref input, _repeated_metadata_codec); + break; + } + } + } + } + #endif + + #region Nested types + /// Container for nested types declared in the ClientConfigureRequest message type. + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static partial class Types { + /// + /// Type of RPCs to send. + /// + public enum RpcType { + [pbr::OriginalName("EMPTY_CALL")] EmptyCall = 0, + [pbr::OriginalName("UNARY_CALL")] UnaryCall = 1, + } + + /// + /// Metadata to be attached for the given type of RPCs. + /// + public sealed partial class Metadata : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new Metadata()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Testing.ClientConfigureRequest.Descriptor.NestedTypes[0]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Metadata() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Metadata(Metadata other) : this() { + type_ = other.type_; + key_ = other.key_; + value_ = other.value_; + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public Metadata Clone() { + return new Metadata(this); + } + + /// Field number for the "type" field. + public const int TypeFieldNumber = 1; + private global::Grpc.Testing.ClientConfigureRequest.Types.RpcType type_ = global::Grpc.Testing.ClientConfigureRequest.Types.RpcType.EmptyCall; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public global::Grpc.Testing.ClientConfigureRequest.Types.RpcType Type { + get { return type_; } + set { + type_ = value; + } + } + + /// Field number for the "key" field. + public const int KeyFieldNumber = 2; + private string key_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Key { + get { return key_; } + set { + key_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + /// Field number for the "value" field. + public const int ValueFieldNumber = 3; + private string value_ = ""; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public string Value { + get { return value_; } + set { + value_ = pb::ProtoPreconditions.CheckNotNull(value, "value"); + } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as Metadata); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(Metadata other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + if (Type != other.Type) return false; + if (Key != other.Key) return false; + if (Value != other.Value) return false; + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (Type != global::Grpc.Testing.ClientConfigureRequest.Types.RpcType.EmptyCall) hash ^= Type.GetHashCode(); + if (Key.Length != 0) hash ^= Key.GetHashCode(); + if (Value.Length != 0) hash ^= Value.GetHashCode(); + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (Type != global::Grpc.Testing.ClientConfigureRequest.Types.RpcType.EmptyCall) { + output.WriteRawTag(8); + output.WriteEnum((int) Type); + } + if (Key.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Key); + } + if (Value.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (Type != global::Grpc.Testing.ClientConfigureRequest.Types.RpcType.EmptyCall) { + output.WriteRawTag(8); + output.WriteEnum((int) Type); + } + if (Key.Length != 0) { + output.WriteRawTag(18); + output.WriteString(Key); + } + if (Value.Length != 0) { + output.WriteRawTag(26); + output.WriteString(Value); + } + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (Type != global::Grpc.Testing.ClientConfigureRequest.Types.RpcType.EmptyCall) { + size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type); + } + if (Key.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Key); + } + if (Value.Length != 0) { + size += 1 + pb::CodedOutputStream.ComputeStringSize(Value); + } + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(Metadata other) { + if (other == null) { + return; + } + if (other.Type != global::Grpc.Testing.ClientConfigureRequest.Types.RpcType.EmptyCall) { + Type = other.Type; + } + if (other.Key.Length != 0) { + Key = other.Key; + } + if (other.Value.Length != 0) { + Value = other.Value; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + case 8: { + Type = (global::Grpc.Testing.ClientConfigureRequest.Types.RpcType) input.ReadEnum(); + break; + } + case 18: { + Key = input.ReadString(); + break; + } + case 26: { + Value = input.ReadString(); + break; + } + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + case 8: { + Type = (global::Grpc.Testing.ClientConfigureRequest.Types.RpcType) input.ReadEnum(); + break; + } + case 18: { + Key = input.ReadString(); + break; + } + case 26: { + Value = input.ReadString(); + break; + } + } + } + } + #endif + + } + + } + #endregion + + } + + /// + /// Response for updating a test client's configuration. + /// + public sealed partial class ClientConfigureResponse : pb::IMessage + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + , pb::IBufferMessage + #endif + { + private static readonly pb::MessageParser _parser = new pb::MessageParser(() => new ClientConfigureResponse()); + private pb::UnknownFieldSet _unknownFields; + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pb::MessageParser Parser { get { return _parser; } } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public static pbr::MessageDescriptor Descriptor { + get { return global::Grpc.Testing.MessagesReflection.Descriptor.MessageTypes[17]; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + pbr::MessageDescriptor pb::IMessage.Descriptor { + get { return Descriptor; } + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ClientConfigureResponse() { + OnConstruction(); + } + + partial void OnConstruction(); + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ClientConfigureResponse(ClientConfigureResponse other) : this() { + _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public ClientConfigureResponse Clone() { + return new ClientConfigureResponse(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override bool Equals(object other) { + return Equals(other as ClientConfigureResponse); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public bool Equals(ClientConfigureResponse other) { + if (ReferenceEquals(other, null)) { + return false; + } + if (ReferenceEquals(other, this)) { + return true; + } + return Equals(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override int GetHashCode() { + int hash = 1; + if (_unknownFields != null) { + hash ^= _unknownFields.GetHashCode(); + } + return hash; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public override string ToString() { + return pb::JsonFormatter.ToDiagnosticString(this); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void WriteTo(pb::CodedOutputStream output) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + output.WriteRawMessage(this); + #else + if (_unknownFields != null) { + _unknownFields.WriteTo(output); + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) { + if (_unknownFields != null) { + _unknownFields.WriteTo(ref output); + } + } + #endif + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public int CalculateSize() { + int size = 0; + if (_unknownFields != null) { + size += _unknownFields.CalculateSize(); + } + return size; + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(ClientConfigureResponse other) { + if (other == null) { + return; + } + _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields); + } + + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + public void MergeFrom(pb::CodedInputStream input) { + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + input.ReadRawMessage(this); + #else + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input); + break; + } + } + #endif + } + + #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE + [global::System.Diagnostics.DebuggerNonUserCodeAttribute] + void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) { + uint tag; + while ((tag = input.ReadTag()) != 0) { + switch(tag) { + default: + _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input); + break; + } + } + } + #endif + + } + #endregion } diff --git a/src/csharp/Grpc.IntegrationTesting/Test.cs b/src/csharp/Grpc.IntegrationTesting/Test.cs index 8967af6f3d9..f82862a52c9 100644 --- a/src/csharp/Grpc.IntegrationTesting/Test.cs +++ b/src/csharp/Grpc.IntegrationTesting/Test.cs @@ -47,13 +47,19 @@ namespace Grpc.Testing { "bmcuRW1wdHkaEy5ncnBjLnRlc3RpbmcuRW1wdHkyiQEKEFJlY29ubmVjdFNl", "cnZpY2USOwoFU3RhcnQSHS5ncnBjLnRlc3RpbmcuUmVjb25uZWN0UGFyYW1z", "GhMuZ3JwYy50ZXN0aW5nLkVtcHR5EjgKBFN0b3ASEy5ncnBjLnRlc3Rpbmcu", - "RW1wdHkaGy5ncnBjLnRlc3RpbmcuUmVjb25uZWN0SW5mbzJ/ChhMb2FkQmFs", - "YW5jZXJTdGF0c1NlcnZpY2USYwoOR2V0Q2xpZW50U3RhdHMSJi5ncnBjLnRl", - "c3RpbmcuTG9hZEJhbGFuY2VyU3RhdHNSZXF1ZXN0GicuZ3JwYy50ZXN0aW5n", - "LkxvYWRCYWxhbmNlclN0YXRzUmVzcG9uc2UiADKLAQoWWGRzVXBkYXRlSGVh", - "bHRoU2VydmljZRI2CgpTZXRTZXJ2aW5nEhMuZ3JwYy50ZXN0aW5nLkVtcHR5", - "GhMuZ3JwYy50ZXN0aW5nLkVtcHR5EjkKDVNldE5vdFNlcnZpbmcSEy5ncnBj", - "LnRlc3RpbmcuRW1wdHkaEy5ncnBjLnRlc3RpbmcuRW1wdHliBnByb3RvMw==")); + "RW1wdHkaGy5ncnBjLnRlc3RpbmcuUmVjb25uZWN0SW5mbzKGAgoYTG9hZEJh", + "bGFuY2VyU3RhdHNTZXJ2aWNlEmMKDkdldENsaWVudFN0YXRzEiYuZ3JwYy50", + "ZXN0aW5nLkxvYWRCYWxhbmNlclN0YXRzUmVxdWVzdBonLmdycGMudGVzdGlu", + "Zy5Mb2FkQmFsYW5jZXJTdGF0c1Jlc3BvbnNlIgAShAEKGUdldENsaWVudEFj", + "Y3VtdWxhdGVkU3RhdHMSMS5ncnBjLnRlc3RpbmcuTG9hZEJhbGFuY2VyQWNj", + "dW11bGF0ZWRTdGF0c1JlcXVlc3QaMi5ncnBjLnRlc3RpbmcuTG9hZEJhbGFu", + "Y2VyQWNjdW11bGF0ZWRTdGF0c1Jlc3BvbnNlIgAyiwEKFlhkc1VwZGF0ZUhl", + "YWx0aFNlcnZpY2USNgoKU2V0U2VydmluZxITLmdycGMudGVzdGluZy5FbXB0", + "eRoTLmdycGMudGVzdGluZy5FbXB0eRI5Cg1TZXROb3RTZXJ2aW5nEhMuZ3Jw", + "Yy50ZXN0aW5nLkVtcHR5GhMuZ3JwYy50ZXN0aW5nLkVtcHR5MnsKH1hkc1Vw", + "ZGF0ZUNsaWVudENvbmZpZ3VyZVNlcnZpY2USWAoJQ29uZmlndXJlEiQuZ3Jw", + "Yy50ZXN0aW5nLkNsaWVudENvbmZpZ3VyZVJlcXVlc3QaJS5ncnBjLnRlc3Rp", + "bmcuQ2xpZW50Q29uZmlndXJlUmVzcG9uc2ViBnByb3RvMw==")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { global::Grpc.Testing.EmptyReflection.Descriptor, global::Grpc.Testing.MessagesReflection.Descriptor, }, new pbr::GeneratedClrTypeInfo(null, null, null)); diff --git a/src/csharp/Grpc.IntegrationTesting/TestGrpc.cs b/src/csharp/Grpc.IntegrationTesting/TestGrpc.cs index 168c0892bae..8c1e0123879 100644 --- a/src/csharp/Grpc.IntegrationTesting/TestGrpc.cs +++ b/src/csharp/Grpc.IntegrationTesting/TestGrpc.cs @@ -947,6 +947,8 @@ namespace Grpc.Testing { static readonly grpc::Marshaller __Marshaller_grpc_testing_LoadBalancerStatsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Grpc.Testing.LoadBalancerStatsRequest.Parser)); static readonly grpc::Marshaller __Marshaller_grpc_testing_LoadBalancerStatsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Grpc.Testing.LoadBalancerStatsResponse.Parser)); + static readonly grpc::Marshaller __Marshaller_grpc_testing_LoadBalancerAccumulatedStatsRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest.Parser)); + static readonly grpc::Marshaller __Marshaller_grpc_testing_LoadBalancerAccumulatedStatsResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Grpc.Testing.LoadBalancerAccumulatedStatsResponse.Parser)); static readonly grpc::Method __Method_GetClientStats = new grpc::Method( grpc::MethodType.Unary, @@ -955,6 +957,13 @@ namespace Grpc.Testing { __Marshaller_grpc_testing_LoadBalancerStatsRequest, __Marshaller_grpc_testing_LoadBalancerStatsResponse); + static readonly grpc::Method __Method_GetClientAccumulatedStats = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "GetClientAccumulatedStats", + __Marshaller_grpc_testing_LoadBalancerAccumulatedStatsRequest, + __Marshaller_grpc_testing_LoadBalancerAccumulatedStatsResponse); + /// Service descriptor public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor { @@ -976,6 +985,17 @@ namespace Grpc.Testing { throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); } + /// + /// Gets the accumulated stats for RPCs sent by a test client. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task GetClientAccumulatedStats(global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + } /// Client for LoadBalancerStatsService @@ -1045,6 +1065,50 @@ namespace Grpc.Testing { { return CallInvoker.AsyncUnaryCall(__Method_GetClientStats, null, options, request); } + /// + /// Gets the accumulated stats for RPCs sent by a test client. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Grpc.Testing.LoadBalancerAccumulatedStatsResponse GetClientAccumulatedStats(global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetClientAccumulatedStats(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Gets the accumulated stats for RPCs sent by a test client. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Grpc.Testing.LoadBalancerAccumulatedStatsResponse GetClientAccumulatedStats(global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_GetClientAccumulatedStats, null, options, request); + } + /// + /// Gets the accumulated stats for RPCs sent by a test client. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall GetClientAccumulatedStatsAsync(global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return GetClientAccumulatedStatsAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Gets the accumulated stats for RPCs sent by a test client. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall GetClientAccumulatedStatsAsync(global::Grpc.Testing.LoadBalancerAccumulatedStatsRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_GetClientAccumulatedStats, null, options, request); + } /// Creates a new instance of client from given ClientBaseConfiguration. protected override LoadBalancerStatsServiceClient NewInstance(ClientBaseConfiguration configuration) { @@ -1057,7 +1121,8 @@ namespace Grpc.Testing { public static grpc::ServerServiceDefinition BindService(LoadBalancerStatsServiceBase serviceImpl) { return grpc::ServerServiceDefinition.CreateBuilder() - .AddMethod(__Method_GetClientStats, serviceImpl.GetClientStats).Build(); + .AddMethod(__Method_GetClientStats, serviceImpl.GetClientStats) + .AddMethod(__Method_GetClientAccumulatedStats, serviceImpl.GetClientAccumulatedStats).Build(); } /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. @@ -1067,6 +1132,7 @@ namespace Grpc.Testing { public static void BindService(grpc::ServiceBinderBase serviceBinder, LoadBalancerStatsServiceBase serviceImpl) { serviceBinder.AddMethod(__Method_GetClientStats, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetClientStats)); + serviceBinder.AddMethod(__Method_GetClientAccumulatedStats, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.GetClientAccumulatedStats)); } } @@ -1227,5 +1293,167 @@ namespace Grpc.Testing { } } + /// + /// A service to dynamically update the configuration of an xDS test client. + /// + public static partial class XdsUpdateClientConfigureService + { + static readonly string __ServiceName = "grpc.testing.XdsUpdateClientConfigureService"; + + static void __Helper_SerializeMessage(global::Google.Protobuf.IMessage message, grpc::SerializationContext context) + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (message is global::Google.Protobuf.IBufferMessage) + { + context.SetPayloadLength(message.CalculateSize()); + global::Google.Protobuf.MessageExtensions.WriteTo(message, context.GetBufferWriter()); + context.Complete(); + return; + } + #endif + context.Complete(global::Google.Protobuf.MessageExtensions.ToByteArray(message)); + } + + static class __Helper_MessageCache + { + public static readonly bool IsBufferMessage = global::System.Reflection.IntrospectionExtensions.GetTypeInfo(typeof(global::Google.Protobuf.IBufferMessage)).IsAssignableFrom(typeof(T)); + } + + static T __Helper_DeserializeMessage(grpc::DeserializationContext context, global::Google.Protobuf.MessageParser parser) where T : global::Google.Protobuf.IMessage + { + #if !GRPC_DISABLE_PROTOBUF_BUFFER_SERIALIZATION + if (__Helper_MessageCache.IsBufferMessage) + { + return parser.ParseFrom(context.PayloadAsReadOnlySequence()); + } + #endif + return parser.ParseFrom(context.PayloadAsNewBuffer()); + } + + static readonly grpc::Marshaller __Marshaller_grpc_testing_ClientConfigureRequest = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Grpc.Testing.ClientConfigureRequest.Parser)); + static readonly grpc::Marshaller __Marshaller_grpc_testing_ClientConfigureResponse = grpc::Marshallers.Create(__Helper_SerializeMessage, context => __Helper_DeserializeMessage(context, global::Grpc.Testing.ClientConfigureResponse.Parser)); + + static readonly grpc::Method __Method_Configure = new grpc::Method( + grpc::MethodType.Unary, + __ServiceName, + "Configure", + __Marshaller_grpc_testing_ClientConfigureRequest, + __Marshaller_grpc_testing_ClientConfigureResponse); + + /// Service descriptor + public static global::Google.Protobuf.Reflection.ServiceDescriptor Descriptor + { + get { return global::Grpc.Testing.TestReflection.Descriptor.Services[5]; } + } + + /// Base class for server-side implementations of XdsUpdateClientConfigureService + [grpc::BindServiceMethod(typeof(XdsUpdateClientConfigureService), "BindService")] + public abstract partial class XdsUpdateClientConfigureServiceBase + { + /// + /// Update the tes client's configuration. + /// + /// The request received from the client. + /// The context of the server-side call handler being invoked. + /// The response to send back to the client (wrapped by a task). + public virtual global::System.Threading.Tasks.Task Configure(global::Grpc.Testing.ClientConfigureRequest request, grpc::ServerCallContext context) + { + throw new grpc::RpcException(new grpc::Status(grpc::StatusCode.Unimplemented, "")); + } + + } + + /// Client for XdsUpdateClientConfigureService + public partial class XdsUpdateClientConfigureServiceClient : grpc::ClientBase + { + /// Creates a new client for XdsUpdateClientConfigureService + /// The channel to use to make remote calls. + public XdsUpdateClientConfigureServiceClient(grpc::ChannelBase channel) : base(channel) + { + } + /// Creates a new client for XdsUpdateClientConfigureService that uses a custom CallInvoker. + /// The callInvoker to use to make remote calls. + public XdsUpdateClientConfigureServiceClient(grpc::CallInvoker callInvoker) : base(callInvoker) + { + } + /// Protected parameterless constructor to allow creation of test doubles. + protected XdsUpdateClientConfigureServiceClient() : base() + { + } + /// Protected constructor to allow creation of configured clients. + /// The client configuration. + protected XdsUpdateClientConfigureServiceClient(ClientBaseConfiguration configuration) : base(configuration) + { + } + + /// + /// Update the tes client's configuration. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The response received from the server. + public virtual global::Grpc.Testing.ClientConfigureResponse Configure(global::Grpc.Testing.ClientConfigureRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return Configure(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Update the tes client's configuration. + /// + /// The request to send to the server. + /// The options for the call. + /// The response received from the server. + public virtual global::Grpc.Testing.ClientConfigureResponse Configure(global::Grpc.Testing.ClientConfigureRequest request, grpc::CallOptions options) + { + return CallInvoker.BlockingUnaryCall(__Method_Configure, null, options, request); + } + /// + /// Update the tes client's configuration. + /// + /// The request to send to the server. + /// The initial metadata to send with the call. This parameter is optional. + /// An optional deadline for the call. The call will be cancelled if deadline is hit. + /// An optional token for canceling the call. + /// The call object. + public virtual grpc::AsyncUnaryCall ConfigureAsync(global::Grpc.Testing.ClientConfigureRequest request, grpc::Metadata headers = null, global::System.DateTime? deadline = null, global::System.Threading.CancellationToken cancellationToken = default(global::System.Threading.CancellationToken)) + { + return ConfigureAsync(request, new grpc::CallOptions(headers, deadline, cancellationToken)); + } + /// + /// Update the tes client's configuration. + /// + /// The request to send to the server. + /// The options for the call. + /// The call object. + public virtual grpc::AsyncUnaryCall ConfigureAsync(global::Grpc.Testing.ClientConfigureRequest request, grpc::CallOptions options) + { + return CallInvoker.AsyncUnaryCall(__Method_Configure, null, options, request); + } + /// Creates a new instance of client from given ClientBaseConfiguration. + protected override XdsUpdateClientConfigureServiceClient NewInstance(ClientBaseConfiguration configuration) + { + return new XdsUpdateClientConfigureServiceClient(configuration); + } + } + + /// Creates service definition that can be registered with a server + /// An object implementing the server-side handling logic. + public static grpc::ServerServiceDefinition BindService(XdsUpdateClientConfigureServiceBase serviceImpl) + { + return grpc::ServerServiceDefinition.CreateBuilder() + .AddMethod(__Method_Configure, serviceImpl.Configure).Build(); + } + + /// Register service method with a service binder with or without implementation. Useful when customizing the service binding logic. + /// Note: this method is part of an experimental API that can change or be removed without any prior notice. + /// Service methods will be bound by calling AddMethod on this object. + /// An object implementing the server-side handling logic. + public static void BindService(grpc::ServiceBinderBase serviceBinder, XdsUpdateClientConfigureServiceBase serviceImpl) + { + serviceBinder.AddMethod(__Method_Configure, serviceImpl == null ? null : new grpc::UnaryServerMethod(serviceImpl.Configure)); + } + + } } #endregion diff --git a/src/php/tests/generated_code/GPBMetadata/Math.php b/src/php/tests/generated_code/GPBMetadata/Math.php index 10f043607acb8e3ec0ae12f9293cc232b3128931..c96131a02e656d38d7f1dce540245d9e41f95818 100644 GIT binary patch delta 403 zcmX@cd68|yB*uC!1tg%(^^%E;D>tzuL$9DHza(FX1;kd;;bM2mEORVMFBTHu;z-FX z%S=hlOOaqyVANn1;^$%qi4^A-Nicx~l=QhcfU1L13vwz!$_q>LOEOdQN}$RGxj2hb za}zW3Qc^)0>OndrxY*q?lfdTlaVf?NWP%Kr;)8R+x|JA&^y;M1& literal 1222 zcmbtTO^=%}5WVv&rrSLvQoFJZ*pO{nwc0k?!!|kWF;eB2VPlB^0!QkH^4~j#gnV^R zjTB+VZ{B{jQ9cHll1#XQ{H$TQ z1Fh4J9=EprVN2_*F6?jeGKE|hEmGq(Hs6-U*{THJFfR>`#?W(m>}_3<_bDuARrONf za^c6JQI?OT!=}{5@&Q}Z*xFUif}oSh3%Vf$Um1<}vYyW7FzP){CRZk>;F>L-ssl9W zwoQ58`St|6VbwW%|IzM!e9p2#_8SE}TH{Z#vgK%K@a;EDW6A{6Ov_Ai70E=PVoJ!I z);Sj}8tOtA!l@{dsge;Vj8Y*NoKZEAT~(&^j3v@`!l;@42_p>4edhtALSh$$5C?=1 z!XuKNI~FolOd6FQ*cDfC=P32;>Vlnf>P^W{?7fl)(kF%s1=92GCGCr&dzMi(mWHYs z&2`2s1Uc6%jF8kbTCe;Y>HD{n`3RTNPSSIqy5F<=d9QqjLPyLykD`6@TnO3eby<>L zCU8g}FLKumuXm5yeY66J?{H#18}ym}FE5=b59w^lZ`k?mGQHwGPnu5X%x{;XciA&> ufBs<{?vwrpmcPp2{Yb&&@w*Mfo8dDbzw58j$*p_!#&yX4a_xd$5c~ziSUmgy diff --git a/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/Messages.php b/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/Messages.php index ec3ae2dcdcdcbdc667879ed56e8d3d624eaec69a..6ba468ef5412b15c5732ac6d251725fde3edda57 100644 GIT binary patch literal 3709 zcmbtX(Q?y96vatQ;+w>AL;=SXSVSm+g42f1lp0cMJ0_DMv0cZsWyUiaSzbFDWJz7E zC~k+>zVr+F0sW0W^h5gG&*mCVm zinW`rgB9e%vrD!D zj)lSm$z8&kPowCBFv@*qKaspef_I}|lG($r&5%d2(;2}&$F^*Z7K*UD@OKvOoU0$o zifC3oY?hjXR0*s2PPcrjtU~gQ_>oPJ#MYAf4J_96f#v8OrF9n;_`nU`q<1#*(IokB zRTCE|E3nXZI)m&SrdUxw1*jM&&N24Q_ryEH=>$oV${H+&R*{QS>aX*#dTjPxi#F(w zJ{m|1L>$FV)Coe%zUB*H^;$ka*Y6IgVEQnK?%Y~@0ymS`JU*0pJo?? z5=s^_^0A}){6zB%2bD<5H($V|5ks+K@DGo6vKJ-D)i}sl=+9wo6eaxPd)Y-9k&Q=0 zwA+Do`qrfe*CH@WXTw~9w4{y2yrE1pJK2;ZeFLt@=c0*LTVsyTLw!NKSN}{vdf13S z{iuM#9H$DHfu)gl!U8Gf5-dk$6Y{5&bx4g#35`?AV_2W$BScQ`T#u`=FKIUfYiT*e zJaIfO`z3@=sXxKSF=tfo<2*XBU7weA%Nm+0;)OFynX0&`X?f?g#;UuJn+6<;coVMb zy&j`IF?Y4lkealqV3Jfjpfp0i*L8;e!yzQM&3KK_Qw{~(sc6&C-?+~rwg@bKD#?Em z5tcQdzo*aan{GF<3EUBHq&AOQk$Cf_)E8;UnVWO=U87du+NdAVN@sJm`Uut<)NpJY z_n&Nxrx3{Y^|u-uKGxd0@!IKjwZ13EXA*-}M?nX6*HO}N(Z#b3$Ag@&iUJS`5^5#Y zB4iJ7;Ffet$Fquw!RZZ+i$1sgzJ~4(A%qvW*{8S@G>;mA7u4StU}H*-u;e3H5ec;R zKyxW&NJTX1%XpJc4bL|)wlt_?WX0xepnL=?f>T#FEgwf(Xvc3MJp@4ypEw|h46ghzwT#ki`9&G;SCm7Sjd6k^mtp=j9muYw#)qUB1R$`6dG@-{KMZn16KZ&L zF)_)|OJSP>H&svPI*A|T%~$=t5Clnyl%+vbmpAb77}GZlN;@&sV9?b62kJ0s9M^@7 z5w37}3^Z``(T9URml@9{a1pgkP8z`VHfx3B)s~^ z99$_|CbfClvAbpuC&F-cJ%OaSz=^>%k0<(rxNOsd#MYDt{4-cWf64EL@KAYpu6Xp2 z49c}(Y4}?y#BQ>)5eelJf=32{ywa%mU~$Mdjkn&Tdh?Z5E*>6cF5uvYm(^k;{5zp; zz}1P0gKcpCCM-v9(-~MP*N*Cq%JFfrbXdt;xbMK)`}d#gu(98$mk&!?qxP~{(VDO7 z742p9MYZ;Q713`%Zu0eWWL7GcUt|)>)Nt{xQr*kUwJ*xgxJP$K9~=*Y@0iGE56%Jn RESvJlBUc7rH}Bvbz`ra;h)@6k literal 6886 zcmcgxTW{Mo6n^)w(7HaPz}E0CDP1>g=oa*$Yk>99z(7k>D!{c3SpjxI{`h!IZtMHRppwbSbka6 zbJx61l6N1I-#>mzetq};(>D-ZFYlVdT_x+Lxb#w&x6P`!Y~8x87q^#R+Ifo~&%)lIxpaKDgGFwzbngnqqoGDyP>Fo_^|t-%KXO+^*Njhp@@y-${Z$tGn5} zE|PU?Tm1L3UjJDy>bAD?`X6}kHmU4G zx5@N+xxAgb&LRY0`hL;6W?|>kcWzxY^{QPqH&}Xgb?e$q=;+DCtDu&)tE=Rqv+?Tc zz{s~r+uXUn_9SUsd)F-9c)MwX`^_hB+4n!z!H%EHa-;S)q~+qX`%BE~#l=Q|#9uI5 zI-W5rbShI}q^MGc|EpA)N>nCIMaukBWoU&mxp5}No6`R-4L2!$5^gKU1uHg^4l;d7 z!7Z~aSI~jKg*MosNVUrL;Pec6GAb(O*Jz-%}oJWZWI?V&oY&&G>4rU zoJ1<;dXb@aR=B=I~uYN&#qIoT7)AsaO$M zjk@J*yP9eO63S$dl*kck*~{pyj8u@JO5ckit){q#H_(de%9!bSl8$+Dtez!@H`Spo z-$$`-GN|looT8PD>Nr|=2)5-M{$%8>L8a(wz?-b6>1=N}<=Snd-DL*diu^!h?&Fnj zBh4M`!t$8Q*onw2)*~vEU3AJ${n{vxR&$Kv=MFleSNnq%7*XK-3Zx#(j?`VO`W$sf zojMz=wpjhNl03+dMk>}ZR!OR3;An?bqw$HAOz2jQ)=Gc3ZLA|w2=4tP6!X=%?XOtz zz$7%bKm9`95l z2gdUh@kl9?h!;LneH--SE<$>Aif9^Rq5-CaO~S{rx3iy9qQgJh4^^_6HmIzFeKz$; zS?bpNi3+X2yx!Cy{Py!~04-u2KPr+AlXxJOzVFBD=Q$>w&-IZ>;B&Pf?~VmXFcCyU zu(8fNEq?iBD8HM*5>xT1Lb3U*)#-TWgy;xkB{ zf{9{z2KK;H;suARD{wuI9SG6!2eYj7ebVbpuc#{^z*d~ zr-SE;v<98v>p((SL=zc);dBz>gxqoBCqPD;U^`I&5_|r!?}=ye;FzcuVu;kS(VNlp z##6mfbm9tndmh<5_dLlS^Bg{aTb!B=C7vT259Y{rSa!^xp5KDe?4qvK{*)H$963I6 zj*P58OUsCFasEtN014oBeP0IhIN}ds!rr+!`h#hNdGriD6yt_7FlK;|L)EMZNhP5W zet=xWK)`_FNqG;qgeU|djZjb8ZwG&HoC1f79lq_}aOx7lqJT?#-Aq*!x>>o$#PuZq zd-e*aIxGsf6(SX^BorH}mlWqQzCp4bKWQG)3_|36^pE=*rw(dJk20FCm762J?pZqO zFU@h{v^x_H^Ce*Th^IY_R^z9pfw}wCtg4=kBR*QsNoS9(h$kZ=onXoX?PuiZ$rj)a zjoV!dPK@0Mex5Q9gs^A=Xg4_17T^S)GvG6B*-&9Q&UBt5?DH;3QwVdpyMfy)%jT`~S1j&Xk)Sh_`Ev!T0b&+-e{QF*Iy9@A2jRRVT_t}-U9p&csq(EShHbmX|Y z2KHmWLg7wM3sq@2gk3A|G4r3uLtql#rOI`_`@21RinIbrrkKG(4m~r-bFlD}wMRMR t!6^_SCQx-CRp9IXI|?aZY`)NV^lW!S7c5%I<5F`^o)e@*m^*PM!b& diff --git a/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/PBEmpty.php b/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/PBEmpty.php index f103e2e3ed2..542c18b23e5 100644 --- a/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/PBEmpty.php +++ b/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/PBEmpty.php @@ -14,9 +14,12 @@ class PBEmpty if (static::$is_initialized == true) { return; } - $pool->internalAddGeneratedFile(hex2bin( - "0a4a0a227372632f70726f746f2f677270632f74657374696e672f656d7074792e70726f746f120c677270632e74657374696e67220e0a0c456d7074794d657373616765620670726f746f33" - ), true); + $pool->internalAddGeneratedFile( + ' +J +"src/proto/grpc/testing/empty.proto grpc.testing" + EmptyMessagebproto3' + , true); static::$is_initialized = true; } diff --git a/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/Test.php b/src/php/tests/interop/GPBMetadata/Src/Proto/Grpc/Testing/Test.php index f8a22f6ea549683336b7f2a289da98f6c290a864..00b82e5f664774b1394a4bf9afe847f917b1fbfd 100644 GIT binary patch literal 2324 zcmcgu(M}UV6tzZ77?J2|j8=__nvd^-7|al?V8u|&@)^H0g4!C;>IC19l)NFMpDUf z!*8`fVJf>G?e=5nI#-y2C?&=w3V)6w=89wL!`zQ?pA~WB?xy* zps8Y>k*a1x^Z7QIq-DWMW~oOTz_Aw2L>lw?QzBQfQ9ksuW30gVO00ys1Ayb?pL=$r z+*)Cy>zTuR{-m}OsPh19gVv-CdNe}VoR{xduNCXfW>Wd4bwno78Yo{xzh}_gnO1OS z0*_>S9!W2ZNw97Sg+>0!{hC5I0yoq_eP$G#BAN~>FA~n3bhaNd8*cOpOHbHyHqrFH zAnGs#c{m7CXI+oOE`0JWYx>dXP3=jc!KosrNN5L0gTti&a&)I|6p*exMOEK;z6m8} zhE$vmiS;g>BQg^ID&;WbBy1HClevpyFp`j%Y@DpVz=$goaLsP|oR@st+%NyEs7xv> zYj%t9*8iY-k8baa&@f%FXQg=&SLP_XI{+42{!&SPq|mKhpi&5+$)PHssk$M`IFAP( zeG*tBigfkFGqr}U)s6Hfp2?x3mcUm;OXj{`MfX2Q(ku{8?8{nNMMlRxplG%XrpTFX zbGYF=AC!73GdAh4oks*lCVhIv`IbTt5}I{N{jSf00U0sA9?v)&8`kZ znoic7`N4h+rNmuZI3p@*RO5R1h4E%F8AdOnG21tlb@Zhi*C`DJhTDvI37wk@O2(cclnPrY8O3dh>ccDOt*+CPf2 z=nA_k{sQt7mfKb9VK`o!uS?ezRmsTUymWqY#Co5!_IX`_=?R;kRn>Ckdo&0>RZbKtOOYFnYi^XzMXrqzhKHw0Cs?8MRC{f(YV%q6-TGK?x3%z} zR`eFJ6=eT_2s#T9rH-|syJ4j8A>o!Uk`0bTVvR5w(Qp?FCGqW4B{~B>Wu}V!IPGEq zBw(=NwTDvpfyHO>WBW)up)?^$66h8q>JZ7|5E3w&5_+Ic5&?FxNrEB@SlojwCA{R? zn_iimTha%5NS*2gR}o@-HwZQIF_sCk4f#U&vOb4YZW27>^ndq0MS56^`*_*cS4_W> z&w=ui^EeiIO6uRj4RtkQW*&%Q#$Xk>C_udmR z+Py2VN<-(+{})zjfeeg8Kic*e>b1x}^it6LMx9b(HUOEr8`-GGf45AghR5K-ss7Mq z(R=ZWJEKM%1g1km{UA&Sh53{ntopG>PL|XqjePu+l9&n{=zs$|fG14J!!vD!UeSI+ z>s*Rdb7&E#%0aIfc}Scb{ya@|6M80?Duc=J`K+hBL7mbrfwI?OT7+!gs0xc%2z^M^ zd&C6t;RF^3d-Fa04g09Tco3-yc{3ezQ8cY3`fC*%?R3%`Jo=p1!hx>Ft8DGc?@{1!zAb%PqBjzxQEgGr9eAD|9<$Rq_X+R5&%L!GIE`EfYPevKth m^fkyREx6vDRHS^iJq8{9)SvVQ2g5rLg<)lXXuFASqUay^%h7}Y