public static bool ExtractActivityAndCorrelationId(MessageHeaders headers, out Guid activityId, out Guid correlationId) { if (headers == null) throw new ArgumentNullException(nameof(headers)); activityId = Guid.Empty; correlationId = Guid.Empty; try { var index = headers.FindHeader("ActivityId", "http://schemas.microsoft.com/2004/09/ServiceModel/Diagnostics"); if (index >= 0) { using (var reader = headers.GetReaderAtHeader(index)) { correlationId = new Guid(reader.GetAttribute("CorrelationId", null)); activityId = reader.ReadElementContentAsGuid(); return true; } } } catch { if (Debugger.IsAttached) { throw; } } return false; }
public static RequestTotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders) { int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return null; } MessageHeaderInfo headerInfo = messageHeaders[index]; return new RequestTotalItemsCountEstimate(); }
/// <summary> /// Gets the data signature in the given message header collection /// </summary> /// <param name="headers">Message headers</param> /// <returns>Data signature or Guid.Empty</returns> public static Guid GetDataSignature(MessageHeaders headers) { Guid dataSignature = Guid.Empty; int headerIndex = headers.FindHeader(Header.Name, Header.Namespace); if (headerIndex != -1) { dataSignature = headers.GetHeader<Guid>(headerIndex); } return dataSignature; }
public static bool Remove(MessageHeaders messageHeaders) { if (messageHeaders != null) { int num = messageHeaders.FindHeader("SystemTracker", "http://schemas.microsoft.com/servicebus/2010/08/protocol/"); if (num >= 0) { messageHeaders.RemoveAt(num); return(true); } } return(false); }
public static UniqueId GetHeaderUniqueId(MessageHeaders headers, string name, string ns) { UniqueId id = null; int headerIndex = headers.FindHeader(name, ns); if (headerIndex >= 0) { using (XmlDictionaryReader reader = headers.GetReaderAtHeader(headerIndex)) { id = reader.ReadElementContentAsUniqueId(); } headers.UnderstoodHeaders.Add(headers[headerIndex]); } return id; }
public static TotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders) { TotalItemsCountEstimate result; int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return null; } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } return result; }
public static string GetHeaderString(MessageHeaders headers, string name, string ns) { string str = null; int headerIndex = headers.FindHeader(name, ns); if (headerIndex >= 0) { using (XmlDictionaryReader reader = headers.GetReaderAtHeader(headerIndex)) { str = reader.ReadElementString(); } headers.UnderstoodHeaders.Add(headers[headerIndex]); } return str; }
string GetHeaderValue(MessageHeaders headers, string name, string ns) { //var headers = OperationContext.Current.IncomingMessageHeaders; var index = headers.FindHeader(name, ns); if (index >= 0) { return(headers.GetHeader <string>(index)); } else { return(null); } }
public static ResourceUriHeader ReadFrom(MessageHeaders messageHeaders) { ResourceUriHeader result; int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return null; } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } return result; }
public static ResourceUriHeader ReadFrom(MessageHeaders messageHeaders) { ResourceUriHeader result; int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return(null); } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } return(result); }
public static FragmentTransferHeader ReadFrom(MessageHeaders messageHeaders) { FragmentTransferHeader result; int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return null; } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } MessageHeaderInfo headerInfo = messageHeaders[index]; return result; }
internal static void Replace(ServiceRemotingMessageHeaders value, MessageHeaders headers) { Debug.Assert(value != default(T)); Debug.Assert(headers != null); int index = headers.FindHeader(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName); if (index >= 0) { headers.RemoveAt(index); } MessageHeader <ServiceRemotingMessageHeaders> genericHeader = new MessageHeader <ServiceRemotingMessageHeaders>(value); headers.Add(genericHeader.GetUntypedHeader(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName)); }
public CertificateDto RegisterClient(string address) { CertificateDto certDto = null; if (!String.IsNullOrEmpty(address)) { MessageHeaders headers = OperationContext.Current.RequestContext.RequestMessage.Headers; string subject = null; if (headers.FindHeader("UserName", "") > -1) { subject = headers.GetHeader <string>(headers.FindHeader("UserName", "")); } if (subject == null) { throw new Exception("Invalid user name"); } //string subject = ServiceSecurityContext.Current.PrimaryIdentity.Name.Replace('\\','_').Trim(); //string port = address.Split(':')[2].Split('/')[0]; //subject = subject.Replace('-', '_') + port; certDto = CAProxy.GenerateCertificate(subject, address); } return(certDto); }
public void DoWork() { //check for CustomHeaderValue custom header MessageHeaders headers = OperationContext.Current.IncomingMessageHeaders; if (headers.FindHeader("CustomHeaderValue", "ns") != -1) { var customheader = headers.GetHeader <string>("CustomHeaderValue", "ns"); if (customheader != null) { Helper.Log("ServiceDemo.DoWork() was called with custom header CustomHeaderValue: {0}", customheader); } } //check for InspectorHeader custom header if (headers.FindHeader("InspectorHeader", "ns") != -1) { var customheader = headers.GetHeader <string>("InspectorHeader", "ns"); if (customheader != null) { Helper.Log("ServiceDemo.DoWork() was called with header from Inspector InspectorHeader: {0}", customheader); } } }
public static IdentifierHeader ReadFrom(MessageHeaders messageHeaders) { IdentifierHeader result; int index = messageHeaders.FindHeader(ElementName, EventingActions.Namespace); if (index < 0) { return null; } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } MessageHeaderInfo headerInfo = messageHeaders[index]; return result; }
public static TotalItemsCountEstimate ReadFrom(MessageHeaders messageHeaders) { TotalItemsCountEstimate result; int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return(null); } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } return(result); }
public void TestFindHeader() { // <a:Action mU="true">test</a:Action> Message m = Message.CreateMessage(MessageVersion.Default, "test", 1); Assert.AreEqual(1, m.Headers.Count, "#0"); // <MyHeader xmlns="bar">1</MyHeader> m.Headers.Add(MessageHeader.CreateHeader("MyHeader", "bar", 1)); // <MyHeader xmlns="baz" role="john">1</MyHeader> m.Headers.Add(MessageHeader.CreateHeader("MyHeader", "baz", 1, false, "john")); MessageHeaders headers = m.Headers; // The first header is at 0 Assert.AreEqual(0, headers.FindHeader("Action", wsa1), "#1"); // The return value of FindHeader maps to its places in the headers Assert.AreEqual(1, headers.FindHeader("MyHeader", "bar"), "#2"); // If a header has actor (role) specified, then it must be provided Assert.AreEqual(-1, headers.FindHeader("MyHeader", "baz"), "#3"); Assert.AreEqual(2, headers.FindHeader("MyHeader", "baz", "john"), "#4"); }
public static void MessageHeader_MustUnderstand_False() { MessageContractHelpers.IMessageContract clientProxy; MessageContractTypes.RequestBankingData requestData; MyInspector inspector = MessageContractHelpers.SetupMessageContractTests(out clientProxy, out requestData); clientProxy.MessageContractRequestReplyWithMessageHeaderNotNecessaryUnderstood(requestData); MessageHeaders headers = MessageContractHelpers.GetHeaders(inspector); int index = headers.FindHeader(MessageContractConstants.extraValuesName, MessageContractConstants.extraValuesNamespace); var header = headers[index]; Assert.True(header != null, "There's no header in the message."); Assert.False(header.MustUnderstand, "Expected MustUnderstand to be false, but it was true."); }
public static string ReadHeader(Message message) { string str; MessageHeaders headers = message.Headers; int num = headers.FindHeader("BodyFormat", "http://schemas.microsoft.com/netservices/2009/05/servicebus/body"); if (num == -1) { return(RelayedHttpUtility.FormatStringDefault); } using (XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(num)) { str = readerAtHeader.ReadString(); } return(str); }
public static string ReadHeader(Message message, string headerName, string defaultValue) { string str; MessageHeaders headers = message.Headers; int num = headers.FindHeader(headerName, "http://schemas.microsoft.com/netservices/2009/05/servicebus/web"); if (num == -1) { return(defaultValue); } using (XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(num)) { str = readerAtHeader.ReadString(); } return(str); }
internal static PollingDuplexSession FindHeader(MessageHeaders headers) { PollingDuplexSession info = null; try { int headerIndex = headers.FindHeader("Duplex", "http://schemas.microsoft.com/2008/04/netduplex"); if (headerIndex != -1) { info = ReadHeaderValue(headers.GetReaderAtHeader(headerIndex)); } } catch (XmlException) { } return info; }
public static SelectorSetHeader ReadFrom(MessageHeaders messageHeaders) { SelectorSetHeader result; int index = messageHeaders.FindHeader(ElementName, ManagementNamespaces.Namespace); if (index < 0) { return(null); } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } MessageHeaderInfo headerInfo = messageHeaders[index]; return(result); }
public static IdentifierHeader ReadFrom(MessageHeaders messageHeaders) { IdentifierHeader result; int index = messageHeaders.FindHeader(ElementName, EventingActions.Namespace); if (index < 0) { return(null); } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } MessageHeaderInfo headerInfo = messageHeaders[index]; return(result); }
public static void MarkHeaderAsUnderstood(MessageHeaders headers, string localName, string ns) { int num = headers.FindHeader(localName, ns); if (-1 != num) { if (!headers.UnderstoodHeaders.Contains(headers[num])) { headers.UnderstoodHeaders.Add(headers[num]); } return; } else { return; } }
internal static PollingDuplexSession FindHeader(MessageHeaders headers) { PollingDuplexSession info = null; try { int headerIndex = headers.FindHeader("Duplex", "http://schemas.microsoft.com/2008/04/netduplex"); if (headerIndex != -1) { info = ReadHeaderValue(headers.GetReaderAtHeader(headerIndex)); } } catch (XmlException) { } return(info); }
public static HttpStatusCode ReadHeader(Message message, HttpStatusCode defaultCode) { object obj; MessageHeaders headers = message.Headers; int num = headers.FindHeader("StatusCode", "http://schemas.microsoft.com/netservices/2009/05/servicebus/statuscode"); if (num != -1) { XmlDictionaryReader readerAtHeader = headers.GetReaderAtHeader(num); return((HttpStatusCode)int.Parse(readerAtHeader.ReadString(), CultureInfo.InvariantCulture)); } if (!message.Properties.TryGetValue(HttpResponseMessageProperty.Name, out obj)) { return(defaultCode); } return(((HttpResponseMessageProperty)obj).StatusCode); }
/// <summary> /// RemoveTIDHeader(): This method will be used to remove TID information /// from the MessageHeaders collection passed in. /// </summary> /// <param name="tid"></param> /// <param name="headers"></param> /// <returns></returns> public static bool RemoveTIDHeader(ITID tid, ref MessageHeaders headers) { bool bRemoved = false; if (tid != null && headers != null) { int iHeaderIndex = headers.FindHeader("TID", "TID"); // If we found the header, remove it. if (iHeaderIndex > -1) { headers.RemoveAt(iHeaderIndex); bRemoved = true; } } return(bRemoved); }
public static MaxEnvelopeSizeHeader ReadFrom(MessageHeaders messageHeaders) { MaxEnvelopeSizeHeader result; int index = messageHeaders.FindHeader(ElementName, Const.ManagementNamespace); if (index < 0) { return null; } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } MessageHeaderInfo headerInfo = messageHeaders[index]; if (!messageHeaders.UnderstoodHeaders.Contains(headerInfo)) { messageHeaders.UnderstoodHeaders.Add(headerInfo); } return result; }
/// <summary> /// Copy message header /// </summary> /// <param name="headerName">indicating the name of the header</param> /// <param name="headerNamespace">indicating the namespace of the header</param> /// <param name="source">indicating the source message header collection</param> /// <param name="destination">indicating the destination message header collection</param> public static void CopyMessageHeader(string headerName, string headerNamespace, MessageHeaders source, MessageHeaders destination) { int udIndex = source.FindHeader(headerName, headerNamespace); if (udIndex >= 0) { if (source.MessageVersion == destination.MessageVersion) { // If the message version of source and destination matches, directly copy it from the source destination.CopyHeaderFrom(source, udIndex); } else { // add request message user data to response message header as an array of XmlNode. XmlNode[] content = source.GetHeader <XmlNode[]>(udIndex); destination.Add(MessageHeader.CreateHeader(headerName, headerNamespace, content)); } } }
public static bool TryRead(MessageHeaders messageHeaders, out TrackingIdHeader trackingIdHeader) { trackingIdHeader = null; if (messageHeaders == null) { return(false); } int num = messageHeaders.FindHeader("TrackingId", "http://schemas.microsoft.com/servicebus/2010/08/protocol/"); if (num >= 0) { using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(num)) { readerAtHeader.ReadStartElement(); trackingIdHeader = new TrackingIdHeader(readerAtHeader.ReadString()); } } return(trackingIdHeader != null); }
/// <summary> /// Will retrieve the custom PARAMETER LIST passed in by the client from /// the ASABaseMessageContract /// </summary> /// <param name="headers"></param> /// <returns></returns> public static Dictionary <string, string> GetParamList(MessageHeaders headers) { Dictionary <string, string> paramList = null; if (headers != null) { int iHeaderIndex = headers.FindHeader("ParamList", ASA.WCFExtensions.ASABaseRequestContract.PARAMLIST_NAMESPACE); // If we found the header, remove it. if (iHeaderIndex > -1) { paramList = headers.GetHeader <Dictionary <string, string> >(iHeaderIndex); //remove paramlist from message headers.. it will get re-added later inside TID. headers.RemoveAt(iHeaderIndex); } } return(paramList); }
public static bool TryAddOrUpdate(MessageHeaders messageHeaders, string trackingId) { if (messageHeaders == null) { return(false); } TrackingIdHeader trackingIdHeader = new TrackingIdHeader(trackingId); int num = messageHeaders.FindHeader("TrackingId", "http://schemas.microsoft.com/servicebus/2010/08/protocol/"); if (num < 0) { messageHeaders.Add(trackingIdHeader); } else { messageHeaders.RemoveAt(num); messageHeaders.Add(trackingIdHeader); } return(true); }
// Token: 0x06000383 RID: 899 RVA: 0x00015E78 File Offset: 0x00014078 internal static bool HasBinarySecretHeader(out string binarySecretHeader) { binarySecretHeader = null; int num = 0; MessageHeaders incomingMessageHeaders = OperationContext.Current.IncomingMessageHeaders; try { num = incomingMessageHeaders.FindHeader("BinarySecret", "http://schemas.microsoft.com/exchange/2010/Autodiscover"); } catch (MessageHeaderException) { return(false); } if (num < 0) { return(false); } binarySecretHeader = incomingMessageHeaders.GetHeader <string>(num); return(true); }
internal static ServiceRemotingMessageHeaders Get(MessageHeaders headers) { Debug.Assert(headers != null); try { if (headers.FindHeader(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName) < 0) { return(new ServiceRemotingMessageHeaders()); } else { return(headers.GetHeader <ServiceRemotingMessageHeaders>(typeof(ServiceRemotingMessageHeaders).Name, typeof(ServiceRemotingMessageHeaders).FullName)); } } catch (Exception exception) { Debug.Assert(IsHeaderNotExistsException(exception)); return(null); } }
public static SelectorSetHeader ReadFrom(MessageHeaders messageHeaders) { SelectorSetHeader result; int index = messageHeaders.FindHeader(ElementName, Const.ManagementNamespace); if (index < 0) { return(null); } using (XmlDictionaryReader readerAtHeader = messageHeaders.GetReaderAtHeader(index)) { result = ReadFrom(readerAtHeader); } MessageHeaderInfo headerInfo = messageHeaders[index]; if (!messageHeaders.UnderstoodHeaders.Contains(headerInfo)) { messageHeaders.UnderstoodHeaders.Add(headerInfo); } return(result); }
protected T GetMessageHeaderData <T>(ref System.ServiceModel.Channels.Message message, OperationContext context, string headerNamespace, string headerName) where T : class { ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "GetMessageHeaderData"); T result = default(T); try { if (message != null) { if (!headerNamespace.IsEmpty() && !headerName.IsEmpty()) { if (context != null && context.IncomingMessageHeaders != null) { MessageHeaders headers = context.IncomingMessageHeaders; int index = headers.FindHeader(headerName, headerNamespace); if (index != -1) { result = DeserializeDC <T>(headers.GetReaderAtHeader(index)); headers.RemoveAt(index); } } } } } catch (Exception ex) { Log.Exception(PROC, ex); } return(result); }
/// <summary> /// Adds the message header. /// </summary> /// <param name="request">The request.</param> /// <param name="name">The name.</param> /// <param name="ns">The ns.</param> /// <param name="createHeader">The create header.</param> protected virtual MessageHeader AddMessageHeader(ref System.ServiceModel.Channels.Message request, string name, string ns, Func <MessageHeader> createHeader) { ModuleProc PROC = new ModuleProc(this.DYN_MODULE_NAME, "AddMessageHeader"); MessageHeader result = null; try { MessageHeaders headers = request.Headers; if (headers != null) { if (headers.FindHeader(name, ns) == -1) { headers.Add((result = createHeader())); } } } catch (Exception ex) { Log.Exception(PROC, ex); } return(result); }
//This method will try to retrieve a header whose value matches the GUID passed by the client. //The return value will notify the client whether the service was able to retrieve the header or not. public bool RetrieveHeader(string guid) { MessageHeaders messageHeaderCollection = OperationContext.Current.IncomingMessageHeaders; String guidHeader = null; Console.WriteLine("Trying to check if IncomingMessageHeader collection contains header with value {0}", guid); if (messageHeaderCollection.FindHeader(CustomHeader.HeaderName, CustomHeader.HeaderNamespace) != -1) { guidHeader = messageHeaderCollection.GetHeader <String>(CustomHeader.HeaderName, CustomHeader.HeaderNamespace); } else { Console.WriteLine("No header was found"); } if (guidHeader != null) { Console.WriteLine("Found header with value {0}. Does it match with GUID sent as parameter: {1}", guidHeader, guidHeader.Equals(guid)); } Console.WriteLine(); //Return true if header is present and equals the guid sent by client as argument return(guidHeader != null && guidHeader.Equals(guid)); }
/// <summary> /// 删除消息头 /// </summary> /// <param name="headers"></param> /// <param name="index"></param> internal static void RemoveHeader(MessageHeaders headers) { if (headers.FindHeader("HeaderContext", "session") >= 0) headers.RemoveAt(headers.FindHeader("HeaderContext", "session")); }
/// <summary> /// 删除消息头 /// </summary> /// <param name="headers"></param> /// <param name="index"></param> internal static void RemoveAppNameHeader(MessageHeaders headers) { if (headers.FindHeader("AppNameHeaderContext", "appnamesession") >= 0) headers.RemoveAt(headers.FindHeader("AppNameHeaderContext", "appnamesession")); }
public static bool Exists(MessageHeaders headers) { return(headers.FindHeader(GenericContext <InitializingContext> .TypeName, GenericContext <InitializingContext> .TypeNamespace) >= 0); }
public void BeforeSendRequestTest() { // Arrange. const string HeaderName1 = "Header1"; const string HeaderName2 = "Header2"; const string HeaderNamespace = "TestNamespace"; const string Actor = "TestActor"; var oldHeader1 = MessageHeader.CreateHeader(HeaderName1, HeaderNamespace, "Test Value 1"); var oldHeader2 = MessageHeader.CreateHeader(HeaderName2, HeaderNamespace, "Test Value 2"); var operationContext = Mock.Create<OperationContext>(); Mock.Arrange(() => OperationContext.Current).Returns(operationContext); var headerAttributes = new SoapHeaderAttributes { HeaderName = HeaderName2, HeaderNamespace = HeaderNamespace, MustUnderstand = true, Actor = Actor, Relay = true }; var integrationExtension = new IntegrationServiceOperationContextExtension(); integrationExtension.HeaderAttributes.Add(headerAttributes); var extensions = new ExtensionCollection<OperationContext>(operationContext) { integrationExtension }; Mock.Arrange(() => operationContext.Extensions).Returns(extensions); var message = Mock.Create<Message>(); var messageHeaders = new MessageHeaders(MessageVersion.Soap11) { oldHeader1, oldHeader2 }; Mock.Arrange(() => message.Headers).Returns(messageHeaders); var inspector = new IntegrationServiceMessageInspector(); // Act. var newMessage = message; inspector.BeforeSendRequest(ref newMessage, Mock.Create<IClientChannel>()); // Assert. Assert.AreSame(message, newMessage); Assert.AreEqual(2, messageHeaders.Count); Assert.IsTrue(messageHeaders.Contains(oldHeader1)); Assert.IsFalse(messageHeaders.Contains(oldHeader2)); var index = messageHeaders.FindHeader(HeaderName2, HeaderNamespace, Actor); var newHeader2 = (XmlElementMessageHeader)messageHeaders[index]; Assert.IsTrue(newHeader2.MustUnderstand); Assert.AreEqual(Actor, newHeader2.Actor); Assert.IsTrue(newHeader2.Relay); // Exceptions. Message nullMessage = null; TestsHelper.VerifyThrow<ArgumentNullException>(() => inspector.BeforeSendRequest(ref nullMessage, Mock.Create<IClientChannel>())); var message2 = Mock.Create<Message>(); TestsHelper.VerifyThrow<ArgumentNullException>(() => inspector.BeforeSendRequest(ref message2, null)); }