internal ConsumedMessage ToConsumedMessage(ISerializer serializer, MessageBinding messageBinding)
{
return new ConsumedMessage(serializer.Deserialize(_args.Body,
messageBinding.RuntimeType,
_args.BasicProperties.CreateEncoding()),
_args);
}
public static MessageBinding CreateInputOutputBinding(string myBindName,
bool isInputBinding)
{
// <Snippet2>
// Value isInputBinding = true ---> return type = InputBinding.
// Value isInputBinding = false --> return type = OutputBinding.
// <Snippet3>
// <Snippet4>
MessageBinding myMessageBinding = null;
switch (isInputBinding)
{
case true:
myMessageBinding = new InputBinding();
Console.WriteLine("Added an InputBinding");
break;
case false:
myMessageBinding = new OutputBinding();
Console.WriteLine("Added an OutputBinding");
break;
}
// </Snippet2>
myMessageBinding.Name = myBindName;
SoapBodyBinding mySoapBodyBinding = new SoapBodyBinding();
mySoapBodyBinding.Use = SoapBindingUse.Literal;
myMessageBinding.Extensions.Add(mySoapBodyBinding);
Console.WriteLine("Added extensibility element of type : " +
mySoapBodyBinding.GetType());
// </Snippet3>
// </Snippet4>
return(myMessageBinding);
}
public void ShouldMatchSubscription()
{
var allowed = new DatabaseStatus()
{
DatacenterName = "Paris",
FailureType = "Oh no!"
};
var notAllowed = new DatabaseStatus()
{
DatacenterName = "London",
FailureType = "Oh no!"
};
var key = BindingKey.Create(allowed);
var subscription = Subscription.Matching <DatabaseStatus>(x => x.DatacenterName == "Paris");
var allowedMessageBinding = MessageBinding.FromMessage(allowed);
var notAllowedMessageBinding = MessageBinding.FromMessage(notAllowed);
Assert.IsTrue(subscription.Matches(allowedMessageBinding));
Assert.IsFalse(subscription.Matches(notAllowedMessageBinding));
}
private void AddOperationMessageBindingContent(BinaryMode binaryMode, MessageBinding messageBinding)
{
if (binaryMode != BinaryMode.Attachment)
{
AddOperationContentBinding(messageBinding.Extensions, x => x);
return;
}
var soapPart = new MimePart();
addGlobalNamespace(NamespaceConstants.MIME);
#if NETSTANDARD1_6_1
AddOperationContentBinding(soapPart.Extensions, x => x);
#else
AddOperationContentBinding(soapPart.Extensions, protocol.Style.CreateSoapHeader);
#endif
var filePart = new MimePart {
Extensions = { new MimeContentBinding {
Part = "file", Type = "application/binary"
} }
};
messageBinding.Extensions.Add(new MimeMultipartRelatedBinding {
Parts = { soapPart, filePart }
});
}
public async Task Setup()
{
MessageBinding bindingModel = new MessageBinding();
bindingModel.Payload = "ZG9jdG9yV2hv"; //doctorWho
await DifferencesClient.LeftTask(basePath, 1, 5, bindingModel);
}
internal ConsumedMessage ToConsumedMessage(ISerializer serializer, MessageBinding messageBinding)
{
return(new ConsumedMessage(serializer.Deserialize(_args.Body,
messageBinding.RuntimeType,
_args.BasicProperties.CreateEncoding()),
_args));
}
public void Setup()
{
InnerTransport = new TestTransport(Self.EndPoint);
var configuration = new Mock <IBusConfiguration>();
configuration.Setup(x => x.IsPersistent).Returns(IsPersistent);
configuration.Setup(x => x.StartReplayTimeout).Returns(TimeSpan.FromMinutes(60));
PeerDirectory = new Mock <IPeerDirectory>();
PeerDirectory.Setup(dir => dir.GetPeersHandlingMessage(MessageBinding.Default <PersistMessageCommand>())).Returns(new[] { PersistencePeer });
PeerDirectory.Setup(dir => dir.GetPeersHandlingMessage(It.IsAny <StartMessageReplayCommand>())).Returns(new[] { PersistencePeer });
PeerDirectory.Setup(dir => dir.GetPeersHandlingMessage(It.IsAny <PersistMessageCommand>())).Returns(new[] { PersistencePeer });
PeerDirectory.Setup(dir => dir.GetPeersHandlingMessage(It.IsAny <MessageHandled>())).Returns(new[] { PersistencePeer });
PeerDirectory.Setup(dir => dir.IsPersistent(AnotherPersistentPeer.Id)).Returns(true);
PeerDirectory.Setup(dir => dir.IsPersistent(AnotherNonPersistentPeer.Id)).Returns(false);
Transport = new PersistentTransport(configuration.Object, InnerTransport, PeerDirectory.Object, new DefaultMessageSendingStrategy());
Transport.Configure(Self.Id, "test");
MessagesForwardedToBus = new ConcurrentQueue <TransportMessage>();
Transport.MessageReceived += MessagesForwardedToBus.Enqueue;
Transport.OnRegistered();
var startMessageReplayMessage = InnerTransport.Messages.FirstOrDefault(x => x.TransportMessage.MessageTypeId == MessageUtil.TypeId <StartMessageReplayCommand>());
if (startMessageReplayMessage != null)
{
StartMessageReplayCommand = (StartMessageReplayCommand)startMessageReplayMessage.TransportMessage.ToMessage();
StartMessageReplayCommandTargets = startMessageReplayMessage.Targets;
}
InnerTransport.Messages.Clear();
}
public void DifferencesRight_AreNotEqual_ReturnComparisonResult()
{
MessageBinding bindingModel = new MessageBinding();
bindingModel.Payload = "ZG9jdG9yU3RyYW5nZQ=="; //doctorStrange
ComparisonResult result = DifferencesClient.RightTask(basePath, 1, 57, bindingModel).Result;
Assert.AreEqual(result.AreEqual, ComparisonResultEnum.NotEqual);
}
public void DifferencesRight_AreEqualWithDifferentPayload_ReturnComparisonResult()
{
MessageBinding bindingModel = new MessageBinding();
bindingModel.Payload = "ZG9jdG9yV2hp"; //doctorWhi
ComparisonResult result = DifferencesClient.RightTask(basePath, 1, 57, bindingModel).Result;
Assert.AreEqual(result.AreEqual, ComparisonResultEnum.Equal);
Assert.AreEqual(result.Offsets, new int[] { 8 });
Assert.AreEqual(result.OffsetsLength, 1);
}
private static void ExportMessageHeaderBinding(MessageBinding messageBinding, WsdlEndpointConversionContext context, XmlQualifiedName header, bool isEncoded)
{
// For brevity, assume Soap12HeaderBinding for Soap 1.2
SoapHeaderBinding binding = new Soap12HeaderBinding();
binding.Part = "Header";
binding.Message = header;
binding.Use = isEncoded ? SoapBindingUse.Encoded : SoapBindingUse.Literal;
messageBinding.Extensions.Add(binding);
}
public void AddMessageFromBind(MessageBinding binding)
{
Message message = new Message()
{
Email = binding.Email,
MessageText = binding.Message,
Subject = binding.Subject
};
this.context.Messages.Add(message);
this.context.SaveChanges();
}
public void AddMessageFromBind(MessageBinding msgBinding)
{
var message = new Message()
{
MessageText = msgBinding.Message,
Sender = msgBinding.Sender,
Subject = msgBinding.Subject
};
context.Messages.Add(message);
context.SaveChanges();
}
private void ReplayMessagesWaitingForPersistence()
{
var persistencePeers = _peerDirectory.GetPeersHandlingMessage(MessageBinding.Default <PersistMessageCommand>());
_logger.InfoFormat("Sending {0} enqueued messages to the persistence", _messagesWaitingForPersistence.Count);
IMessage messageToSend;
while (_messagesWaitingForPersistence.TryTake(out messageToSend))
{
SendToPersistenceService(messageToSend, persistencePeers);
}
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
#pragma warning suppress 56506 // Microsoft, these properties cannot be null in this context
if (context.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context.Endpoint.Binding");
}
BindingElementCollection bindingElements = GetBindingElements(context);
MessageEncodingBindingElement messageEncodingBindingElement = bindingElements.Find <MessageEncodingBindingElement>();
TextMessageEncodingBindingElement textEncodingBindingElement = messageEncodingBindingElement as TextMessageEncodingBindingElement;
if (messageEncodingBindingElement != null)
{
Type elementType = messageEncodingBindingElement.GetType();
if (elementType != typeof(TextMessageEncodingBindingElement) &&
elementType != typeof(BinaryMessageEncodingBindingElement) &&
elementType != typeof(MtomMessageEncodingBindingElement))
{
return;
}
}
EnsureMessageEncoding(context, messageEncodingBindingElement);
foreach (OperationBinding wsdlOperationBinding in context.WsdlBinding.Operations)
{
OperationDescription operation = context.GetOperationDescription(wsdlOperationBinding);
for (int i = 0; i < operation.Messages.Count; i++)
{
MessageDescription message = operation.Messages[i];
MessageBinding wsdlMessageBinding = context.GetMessageBinding(message);
ImportMessageSoapAction(context.ContractConversionContext, message, wsdlMessageBinding, i != 0 /*isResponse*/);
}
foreach (FaultDescription fault in operation.Faults)
{
FaultBinding wsdlFaultBinding = context.GetFaultBinding(fault);
if (wsdlFaultBinding != null)
{
ImportFaultSoapAction(context.ContractConversionContext, fault, wsdlFaultBinding);
}
}
}
}
public IActionResult Contacts(HttpResponse response, MessageBinding messageBindingModel)
{
if (string.IsNullOrEmpty(messageBindingModel.Email) || string.IsNullOrEmpty(messageBindingModel.Subject))
{
this.Redirect(response, "/home/contacts");
return(null);
}
MessagesService service = new MessagesService(Data.Data.Context);
service.AddMessageFromBind(messageBindingModel);
this.Redirect(response, "/home/index");
return(this.View());
}
public IActionResult Contacts(MessageBinding messageBinding)
{
if (string.IsNullOrEmpty(messageBinding.Email) || string.IsNullOrEmpty(messageBinding.Subject))
{
this.Redirect(new HttpResponse()
{
}, "/home/contacts");
}
MessageServices service = new MessageServices(Data.Data.Context);
service.MessageFromBind(messageBinding);
return(this.View("Home", "Index"));
}
public IActionResult Contacts(HttpResponse responce, MessageBinding msgBinding)
{
if (string.IsNullOrEmpty(msgBinding.Sender) || string.IsNullOrEmpty(msgBinding.Subject))
{
this.Redirect(responce, "/home/contacts");
return(null);
}
var msgService = new MessagesService(Data.Data.Context);
msgService.AddMessageFromBind(msgBinding);
this.Redirect(responce, "/home/index");
return(this.View());
}
internal static bool Check(SoapHeaderBinding soapHeaderBinding, MessageBinding messageBinding, WsdlWarningHandler warningHandler)
{
if ((soapHeaderBinding.Message == null) || soapHeaderBinding.Message.IsEmpty)
{
string str = System.ServiceModel.SR.GetString("XsdMissingRequiredAttribute1", new object[] { "message" });
string warning = System.ServiceModel.SR.GetString("IgnoreSoapHeaderBinding3", new object[] { messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.ServiceDescription.TargetNamespace, str });
warningHandler(warning);
return(false);
}
if (string.IsNullOrEmpty(soapHeaderBinding.Part))
{
string str3 = System.ServiceModel.SR.GetString("XsdMissingRequiredAttribute1", new object[] { "part" });
string str4 = System.ServiceModel.SR.GetString("IgnoreSoapHeaderBinding3", new object[] { messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.ServiceDescription.TargetNamespace, str3 });
warningHandler(str4);
return(false);
}
return(true);
}
/// <summary>
/// Exports the message header binding.
/// </summary>
/// <param name="info">The info.</param>
/// <param name="messageBinding">The message binding.</param>
/// <param name="qsName">Name of the qs.</param>
/// <param name="isEncoded">if set to <c>true</c> [is encoded].</param>
private void ExportMessageHeaderBinding(CustomHeaderExportInfo info,
MessageBinding messageBinding, XmlQualifiedName qsName)
{
ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "ExportMessageHeaderBinding");
try
{
SoapHeaderBinding binding = new SoapHeaderBinding();
binding.Part = info.PartName;
binding.Message = qsName;
binding.Use = (info.IsEncoded ? SoapBindingUse.Encoded : SoapBindingUse.Literal);
messageBinding.Extensions.Add(binding);
}
catch (Exception ex)
{
Log.Exception(PROC, ex);
}
}
internal void ExportMessageBinding(OperationDescription operation, Type messageContractExporterType)
{
bool flag;
bool flag2;
OperationBinding operationBinding = this.endpointContext.GetOperationBinding(operation);
if (GetStyleAndUse(operation, messageContractExporterType, out flag, out flag2))
{
SoapOperationBinding binding2 = SoapHelper.GetOrCreateSoapOperationBinding(this.endpointContext, operation, this.exporter);
if (binding2 != null)
{
binding2.Style = flag ? SoapBindingStyle.Rpc : SoapBindingStyle.Document;
if (flag)
{
SoapBinding binding3 = (SoapBinding)this.endpointContext.WsdlBinding.Extensions.Find(typeof(SoapBinding));
binding3.Style = binding2.Style;
}
binding2.SoapAction = operation.Messages[0].Action;
foreach (MessageDescription description in operation.Messages)
{
Message message;
MessageBinding messageBinding = this.endpointContext.GetMessageBinding(description);
if (this.exportedMessages.WsdlHeaderMessages.TryGetValue(new MessageContractExporter.MessageDescriptionDictionaryKey(this.endpointContext.Endpoint.Contract, description), out message))
{
XmlQualifiedName messageName = new XmlQualifiedName(message.Name, message.ServiceDescription.TargetNamespace);
foreach (MessageHeaderDescription description2 in description.Headers)
{
if (!description2.IsUnknownHeaderCollection)
{
this.ExportMessageHeaderBinding(description2, messageName, flag2, messageBinding);
}
}
}
this.ExportMessageBodyBinding(description, flag, flag2, messageBinding);
}
foreach (FaultDescription description3 in operation.Faults)
{
this.ExportFaultBinding(description3, flag2, operationBinding);
}
}
}
}
void IWsdlImportExtension.ImportEndpoint(WsdlImporter importer, WsdlEndpointConversionContext context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
if (context.Endpoint.Binding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context.Endpoint.Binding");
}
MessageEncodingBindingElement encodingBindingElement = GetBindingElements(context).Find <MessageEncodingBindingElement>();
if (encodingBindingElement != null)
{
System.Type type = encodingBindingElement.GetType();
if (((type != typeof(TextMessageEncodingBindingElement)) && (type != typeof(BinaryMessageEncodingBindingElement))) && (type != typeof(MtomMessageEncodingBindingElement)))
{
return;
}
}
EnsureMessageEncoding(context, encodingBindingElement);
foreach (OperationBinding binding in context.WsdlBinding.Operations)
{
OperationDescription operationDescription = context.GetOperationDescription(binding);
for (int i = 0; i < operationDescription.Messages.Count; i++)
{
MessageDescription message = operationDescription.Messages[i];
MessageBinding messageBinding = context.GetMessageBinding(message);
ImportMessageSoapAction(context.ContractConversionContext, message, messageBinding, i != 0);
}
foreach (FaultDescription description3 in operationDescription.Faults)
{
FaultBinding faultBinding = context.GetFaultBinding(description3);
if (faultBinding != null)
{
ImportFaultSoapAction(context.ContractConversionContext, description3, faultBinding);
}
}
}
}
public MessageDescription GetMessageDescription(MessageBinding messageBinding)
{
return(this.messageDescriptionBindings[messageBinding]);
}
private static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse)
{
string str = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding);
if (((contractContext != null) && (WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(contractContext.GetOperationMessage(message)) == null)) && (str != null))
{
if (isResponse)
{
message.Action = "*";
}
else
{
message.Action = str;
}
}
}
internal void AddMessageBinding(MessageDescription messageDescription, MessageBinding wsdlMessageBinding)
{
this.wsdlMessageBindings.Add(messageDescription, wsdlMessageBinding);
this.messageDescriptionBindings.Add(wsdlMessageBinding, messageDescription);
}
static void ImportMessageSoapAction(WsdlContractConversionContext contractContext, MessageDescription message, MessageBinding wsdlMessageBinding, bool isResponse)
{
string soapAction = SoapHelper.ReadSoapAction(wsdlMessageBinding.OperationBinding);
if (contractContext != null)
{
OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(message);
string wsaAction = WsdlImporter.WSAddressingHelper.FindWsaActionAttribute(wsdlOperationMessage);
if (wsaAction == null && soapAction != null)
{
if (isResponse)
{
message.Action = "*";
}
else
{
message.Action = soapAction;
}
}
//
}
else
{
//
}
}
public static async Task <ComparisonResult> LeftTask(string basePath, int version, int id, MessageBinding model)
{
string apiPath = "{0}/v{1}/diff/{2}/left";
string methodUrl = string.Format(apiPath, basePath, version, id);
using (HttpClient client = new HttpClient())
{
return(await client.MethodPost <ComparisonResult, MessageBinding>(basePath, methodUrl, model));
}
}
internal static SoapBodyBinding GetOrCreateSoapBodyBinding(WsdlEndpointConversionContext endpointContext, MessageBinding wsdlMessageBinding, WsdlExporter exporter)
{
if (GetSoapVersionState(endpointContext.WsdlBinding, exporter) == EnvelopeVersion.None)
{
return(null);
}
SoapBodyBinding soapBodyBinding = GetSoapBodyBinding(endpointContext, wsdlMessageBinding);
EnvelopeVersion soapVersion = GetSoapVersion(endpointContext.WsdlBinding);
if (soapBodyBinding != null)
{
return(soapBodyBinding);
}
return(CreateSoapBodyBinding(soapVersion, wsdlMessageBinding));
}
private static SoapBodyBinding GetSoapBodyBinding(WsdlEndpointConversionContext endpointContext, MessageBinding wsdlMessageBinding)
{
foreach (object obj2 in wsdlMessageBinding.Extensions)
{
if (obj2 is SoapBodyBinding)
{
return((SoapBodyBinding)obj2);
}
}
return(null);
}
public bool Matches(MessageBinding messageBinding)
{
return(messageBinding.MessageTypeId == MessageTypeId && Matches(messageBinding.RoutingKey));
}
internal static SoapHeaderBinding CreateSoapHeaderBinding(WsdlEndpointConversionContext endpointContext, MessageBinding wsdlMessageBinding)
{
return(CreateSoapHeaderBinding(GetSoapVersion(endpointContext.WsdlBinding), wsdlMessageBinding));
}
private static SoapBodyBinding CreateSoapBodyBinding(EnvelopeVersion version, MessageBinding wsdlMessageBinding)
{
SoapBodyBinding extension = null;
if (version == EnvelopeVersion.Soap12)
{
extension = new Soap12BodyBinding();
}
else if (version == EnvelopeVersion.Soap11)
{
extension = new SoapBodyBinding();
}
wsdlMessageBinding.Extensions.Add(extension);
return(extension);
}
