public virtual HelloWCFResponse HelloWCF(HelloWCF req) { // Create request header String action; action = "http://localhost/ServiceHelloWCF/IServiceHelloWCF/HelloWCF"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer HelloWCFDataContractSerializer reqDcs; reqDcs = new HelloWCFDataContractSerializer("HelloWCF", "http://localhost/ServiceHelloWCF"); request.Serializer = reqDcs; request.Method = "HelloWCF"; // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response HelloWCFResponseDataContractSerializer respDcs; respDcs = new HelloWCFResponseDataContractSerializer("HelloWCFResponse", "http://localhost/ServiceHelloWCF"); HelloWCFResponse resp; resp = ((HelloWCFResponse)(respDcs.ReadObject(response.Reader))); response.Reader.Dispose(); response.Reader = null; return resp; }
public virtual WsMessage HelloWCF(WsMessage request) { // Build request object HelloWCFDataContractSerializer reqDcs; reqDcs = new HelloWCFDataContractSerializer("HelloWCF", "http://localhost/ServiceHelloWCF"); HelloWCF req; req = ((HelloWCF)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Create response object // Call service operation to process request and return response. HelloWCFResponse resp; resp = m_service.HelloWCF(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://localhost/ServiceHelloWCF/IServiceHelloWCF/HelloWCFResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer HelloWCFResponseDataContractSerializer respDcs; respDcs = new HelloWCFResponseDataContractSerializer("HelloWCFResponse", "http://localhost/ServiceHelloWCF"); response.Serializer = respDcs; return response; }
public virtual WsMessage TwoWayAttachment(WsMessage request) { // Build request object TwoWayAttachmentRequestDataContractSerializer reqDcs; reqDcs = new TwoWayAttachmentRequestDataContractSerializer("TwoWayAttachmentRequest", "http://schemas.example.org/AttachmentService"); reqDcs.BodyParts = request.BodyParts; TwoWayAttachmentRequest req; req = ((TwoWayAttachmentRequest)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Create response object // Call service operation to process request and return response. TwoWayAttachmentResponse resp; resp = m_service.TwoWayAttachment(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://schemas.example.org/AttachmentService/TwoWayAttachmentResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer TwoWayAttachmentResponseDataContractSerializer respDcs; respDcs = new TwoWayAttachmentResponseDataContractSerializer("TwoWayAttachmentResponse", "http://schemas.example.org/AttachmentService"); response.Serializer = respDcs; // Indicate that message is Mtom encoded response.BodyParts = new WsMtomBodyParts(); return response; }
public virtual void OneWayAttachment(OneWayAttachmentRequest req) { // Create request header String action; action = "http://schemas.example.org/AttachmentService/OneWayAttachment"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer OneWayAttachmentRequestDataContractSerializer reqDcs; reqDcs = new OneWayAttachmentRequestDataContractSerializer("OneWayAttachmentRequest", "http://schemas.example.org/AttachmentService"); request.Serializer = reqDcs; request.Method = "OneWayAttachment"; // Indicate that this message will use Mtom encoding request.BodyParts = new WsMtomBodyParts(); // Send service request m_requestChannel.Open(); m_requestChannel.RequestOneWay(request); m_requestChannel.Close(); }
public virtual WsMessage GetData(WsMessage request) { // Build request object GetDataDataContractSerializer reqDcs; reqDcs = new GetDataDataContractSerializer("GetData", "http://tempuri.org/"); reqDcs.BodyParts = request.BodyParts; GetData req; req = ((GetData)(reqDcs.ReadObject(request.Reader))); // Create response object // Call service operation to process request and return response. GetDataResponse resp; resp = m_service.GetData(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://tempuri.org/IDataAccessService/GetDataResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer GetDataResponseDataContractSerializer respDcs; respDcs = new GetDataResponseDataContractSerializer("GetDataResponse", "http://tempuri.org/"); response.Serializer = respDcs; // Indicate that message is Mtom encoded response.BodyParts = new WsMtomBodyParts(); return response; }
// OneWay: Accept an integer value public WsMessage OneWay(WsMessage request) { try { WsWsaHeader header = request.Header; XmlReader reader = request.Reader; // Find beginning of request reader.ReadStartElement("OneWay", SimpleServiceNamespaceUri); // Find the integer value int number = Convert.ToInt32(reader.ReadElementString("Param", SimpleServiceNamespaceUri)); //Log.Comment(""); //Log.Comment("Integer = " + number.ToString()); //Log.Comment(""); return null; // Empty response } catch (Exception e) { // Something went wrong throw new WsFaultException(request.Header, WsFaultType.XmlException, e.ToString()); } }
// TwoWayRequest: Accept two integer values, return their sum public WsMessage TwoWayRequest(WsMessage request) { WsWsaHeader header = request.Header; XmlReader reader = request.Reader; try { // Find beginning of request reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri); // Find the values to be added int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri)); int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri)); //Log.Comment(""); //Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString()); //Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString()); //Log.Comment(""); // Return the response return TwoWayResponse(header, X + Y); } catch (Exception e) { // Something went wrong throw new WsFaultException(header, WsFaultType.XmlException, e.ToString()); } }
public virtual BorrowResponse Borrow(Borrow req) { // Create request header String action; action = "http://tempuri.org/IService/Borrow"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer BorrowDataContractSerializer reqDcs; reqDcs = new BorrowDataContractSerializer("Borrow", "http://tempuri.org/"); request.Serializer = reqDcs; request.Method = "Borrow"; // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response BorrowResponseDataContractSerializer respDcs; respDcs = new BorrowResponseDataContractSerializer("BorrowResponse", "http://tempuri.org/"); BorrowResponse resp; resp = ((BorrowResponse)(respDcs.ReadObject(response.Reader))); response.Reader.Dispose(); response.Reader = null; return resp; }
public virtual SetDataResponse SetData(SetData req) { // Create request header String action; action = "http://tempuri.org/IDataAccessService/SetData"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer SetDataDataContractSerializer reqDcs; reqDcs = new SetDataDataContractSerializer("SetData", "http://tempuri.org/"); request.Serializer = reqDcs; request.Method = "SetData"; // Indicate that this message will use Mtom encoding request.BodyParts = new WsMtomBodyParts(); // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response SetDataResponseDataContractSerializer respDcs; respDcs = new SetDataResponseDataContractSerializer("SetDataResponse", "http://tempuri.org/"); respDcs.BodyParts = response.BodyParts; SetDataResponse resp; resp = ((SetDataResponse)(respDcs.ReadObject(response.Reader))); return resp; }
public virtual TwoWayResponse TwoWay(TwoWayRequest req) { // Create request header String action; action = "http://schemas.example.org/SimpleService/TwoWay"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer TwoWayRequestDataContractSerializer reqDcs; reqDcs = new TwoWayRequestDataContractSerializer("TwoWayRequest", "http://schemas.example.org/SimpleService"); request.Serializer = reqDcs; request.Method = "TwoWay"; // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response TwoWayResponseDataContractSerializer respDcs; respDcs = new TwoWayResponseDataContractSerializer("TwoWayResponse", "http://schemas.example.org/SimpleService"); TwoWayResponse resp; resp = ((TwoWayResponse)(respDcs.ReadObject(response.Reader))); return resp; }
// OneWayAttachment: receive an MTOM binary attachment public WsMessage OneWayAttachment(WsMessage request) { WsWsaHeader header = request.Header; XmlReader reader = request.Reader; // Make sure we have MTOM body parts if (request.BodyParts == null) throw new WsFaultException(header, WsFaultType.XmlException, "MTOM message has no body parts."); // Find paramaters reader.ReadStartElement("OneWayAttachment", AttNamespace); reader.ReadStartElement("Param", AttNamespace); // Look for Include parameter if (reader.IsStartElement("Include", WsWellKnownUri.XopNamespaceUri) == false) throw new WsFaultException(header, WsFaultType.XmlException, "Body/OneWayAttachment/Param/Include is missing."); // Look for attachment body part reader.MoveToFirstAttribute(); string cid = "<" + reader.Value.Substring(4) + ">"; ////Log.Comment(""); ////Log.Comment("OneWayAttachment received. href = " + reader.Value); WsMtomBodyPart bodyPart; if ((bodyPart = request.BodyParts[cid]) == null) throw new WsFaultException(header, WsFaultType.XmlException, "Required body part \"" + reader.Value + "\" in missing."); // Print information about the attachment ////Log.Comment("Attachment size = " + bodyPart.Content.Length); ////Log.Comment("Content-ID = " + bodyPart.ContentID); ////Log.Comment("Content-Type = " + bodyPart.ContentType); ////Log.Comment("Content-Transfer-Encoding = " + bodyPart.ContentTransferEncoding); ////Log.Comment(""); return null; // empty response }
/// <summary> /// Processes an output message for a specific context /// </summary> /// <param name="message">The message to process.</param> /// <param name="ctx">The context to process the message for.</param> /// <returns><c>true</c> if the processing was succesfull, <c>false</c>otherwise.</returns> public bool ProcessOutputMessage(ref WsMessage message, BindingContext ctx) { ChainResult res = this.OnProcessOutputMessage( ref message, ctx ); if( ChainResult.Continue == res && m_Next != null) { return m_Next.ProcessOutputMessage( ref message, ctx ); } return res == ChainResult.Handled; }
private DpwsServiceDescriptions ProcessMatch(DpwsServiceDescription.ServiceDescriptionType type, WsMessage response, string messageID, IPEndPoint remoteEP, WsMessageCheck messageCheck) { Microsoft.SPOT.Debug.Assert(type == DpwsServiceDescription.ServiceDescriptionType.ProbeMatch || type == DpwsServiceDescription.ServiceDescriptionType.ResolveMatch); // Parse and build header WsWsaHeader header = response.Header; XmlReader reader = response.Reader; if(header == null || reader == null) { return null; } try { // Make sure this is a probe matches response String headerAction = (type == DpwsServiceDescription.ServiceDescriptionType.ProbeMatch) ? m_version.DiscoveryNamespace + "/ProbeMatches" : m_version.DiscoveryNamespace + "/ResolveMatches"; if (header.Action != headerAction) return null; // Make sure this is not a duplicate probe response if (messageCheck != null) { if (messageCheck.IsDuplicate(header.MessageID, remoteEP.ToString()) == true) { System.Ext.Console.Write("ProbeMatches / ResolveMatches - Duplicate response - " + header.Action + " received"); return null; } } // Make sure the messageID matches the request ID if (header.RelatesTo != messageID) return null; // Process the probe matches #if DEBUG int depth = reader.Depth; #endif DpwsServiceDescriptions matches = new DpwsServiceDescriptions(reader, type, m_version, remoteEP); #if DEBUG Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader)); #endif return matches; } finally { reader.Close(); } }
/// <summary> /// Use this method to raise an event. /// </summary> /// <param name="hostedService">The hosted service that contains the event source.</param> /// <param name="eventSource">The event source that define the event.</param> /// <param name="eventMessage">The event message buffer.</param> /// <remarks> /// A device developer is responsible for building the event message buffer sent /// to clients that have an active event subscription with an event source. The subscription manager /// uses the hosted service parameter to access various properties of the service. The event source /// parameter is used to access the event sinks collection of the event source. Note: This method /// requires special provisions in order to properly build event message headers for each event sink. /// In order to send an event to a listening client the soap.header.To property must be changed for /// each listening client. In the future custom attribute support will solve this problem. For now /// however a search and replace mechanism is used to modifiy the header.To property. When a device /// developer builds the event message buffer they must use the search string WSDNOTIFYTOADDRESS for /// the To header property. /// </remarks> public void FireEvent(DpwsHostedService hostedService, DpwsWseEventSource eventSource, WsMessage msgEvt) { // Find the specified event source if (eventSource == null) throw new ArgumentNullException(); DpwsWseEventSinks eventSinks = eventSource.EventSinks; // if there are event sources display message int count = eventSinks.Count; if (count > 0) { System.Ext.Console.Write(""); System.Ext.Console.Write("Firing " + eventSource.Name); System.Ext.Console.Write(""); } // Loop through event sinks and send the event message for (int i = count-1; i >= 0; i--) { DpwsWseEventSink eventSink = eventSinks[i]; // Try to send event. If attempt fails delete the subscription/eventSink try { msgEvt.Header = new WsWsaHeader(msgEvt.Header.Action, msgEvt.Header.RelatesTo, eventSink.NotifyTo.Address.AbsoluteUri, null, null, eventSink.NotifyTo.RefParameters); SendEvent(msgEvt, eventSink.NotifyTo.Address); } catch (Exception e) { System.Ext.Console.Write(""); System.Ext.Console.Write("FireEvent failed. Deleting EventSink! NotifyToAddress = " + eventSink.NotifyTo.Address + " Exception: " + e.Message); System.Ext.Console.Write(""); if (!(e is WebException)) { try { // Send oneway subscription end message SendSubscriptionEnd(eventSink, "DeliveryFailure", hostedService.ServiceID); } catch { } } // Remove event sink from event source list eventSinks.RemoveAt(i); } } }
public static WsMessage CreateOneWayResponse() { if (s_OneWayResponse == null) { WsWsaHeader header = new WsWsaHeader(null, null, null, null, null, null); header.IsOneWayResponse = true; s_OneWayResponse = new WsMessage(header, null, WsPrefix.None); } return s_OneWayResponse; }
public static WsMessage CreateOneWayResponse() { if (s_OneWayResponse == null) { WsWsaHeader header = new WsWsaHeader(null, null, null, null, null, null); header.IsOneWayResponse = true; s_OneWayResponse = new WsMessage(header, null, WsPrefix.None); } return(s_OneWayResponse); }
// MetadataExchange GetResponse service stub public WsMessage Get(WsMessage msg) { WsWsaHeader header = msg.Header; // DPWS 1.1 spec: R0031: A SERVICE MUST NOT generate a wsa:InvalidAddressingHeader SOAP Fault // [WS-Addressing SOAP Binding] if the [address] of the [reply endpoint] of an HTTP Request // Message SOAP ENVELOPE is "http://www.w3.org/2005/08/addressing/anonymous". if (header.ReplyTo != null && header.ReplyTo.Address.AbsoluteUri != m_version.AnonymousRoleUri) { throw new WsFaultException(header, WsFaultType.WsaInvalidMessageInformationHeader, "R0031"); } return m_response.GetResponse(msg); }
public virtual WsMessage OneWay(WsMessage request) { // Build request object OneWayRequestDataContractSerializer reqDcs; reqDcs = new OneWayRequestDataContractSerializer("OneWayRequest", "http://schemas.example.org/SimpleService"); OneWayRequest req; req = ((OneWayRequest)(reqDcs.ReadObject(request.Reader))); // Call service operation to process request. m_service.OneWay(req); // Return null response for oneway messages return null; }
public virtual WsMessage IntegerEvent(WsMessage request) { // Build request object IntegerEventRequestDataContractSerializer reqDcs; reqDcs = new IntegerEventRequestDataContractSerializer("IntegerEventRequest", "http://schemas.example.org/EventingService"); IntegerEventRequest req; req = ((IntegerEventRequest)(reqDcs.ReadObject(request.Reader))); // Call service operation to process request. m_eventHandler.IntegerEvent(req); // Return null response for event callback messages return null; }
// This method is called by the timer delegate periodically to send events public void SendEvent(Object stateInfo) { if (rentryFlag == true) // prevent this method from running concurrently with itself return; rentryFlag = true; // Fire SimpleEvent try { DpwsWseEventSource eventSource = m_hostedService.EventSources["SimpleEvent"]; WsWsaHeader header = new WsWsaHeader("http://schemas.example.org/EventingService/SimpleEvent", null, null, null, null, null); WsMessage msg = new WsMessage(header, null, WsPrefix.Wse); msg.Body = System.Text.UTF8Encoding.UTF8.GetBytes(BuildSimpleEventMessage(m_hostedService)); Device.SubscriptionManager.FireEvent(m_hostedService, eventSource, msg ); } catch { //Log.Comment(""); //Log.Comment("SimpleEvent FireEvent failed: " + e.Message); //Log.Comment(""); rentryFlag = false; } // Fire IntegerEvent try { DpwsWseEventSource eventSource = m_hostedService.EventSources["IntegerEvent"]; WsWsaHeader header = new WsWsaHeader("http://schemas.example.org/EventingService/IntegerEvent", null, null, null, null, null); WsMessage msg = new WsMessage(header, null, WsPrefix.Wse); msg.Body = System.Text.UTF8Encoding.UTF8.GetBytes(BuildIntegerEventMessage(m_hostedService)); Device.SubscriptionManager.FireEvent(m_hostedService, eventSource, msg); } catch { //Log.Comment(""); //Log.Comment("IntegerEvent FireEvent failed: " + e.Message); //Log.Comment(""); rentryFlag = false; } rentryFlag = false; }
public virtual WsMessage SimpleEvent(WsMessage request) { // Build request object SimpleEventRequestDataContractSerializer reqDcs; reqDcs = new SimpleEventRequestDataContractSerializer("SimpleEventRequest", "http://schemas.example.org/EventingService"); SimpleEventRequest req; req = ((SimpleEventRequest)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Call service operation to process request. m_eventHandler.SimpleEvent(req); // Return OneWayResponse message for event callback messages return WsMessage.CreateOneWayResponse(); }
public virtual WsMessage OneWayAttachment(WsMessage request) { // Build request object OneWayAttachmentRequestDataContractSerializer reqDcs; reqDcs = new OneWayAttachmentRequestDataContractSerializer("OneWayAttachmentRequest", "http://schemas.example.org/AttachmentService"); reqDcs.BodyParts = request.BodyParts; OneWayAttachmentRequest req; req = ((OneWayAttachmentRequest)(reqDcs.ReadObject(request.Reader))); request.Reader.Dispose(); request.Reader = null; // Call service operation to process request. m_service.OneWayAttachment(req); // Return a OneWayResponse message for oneway messages return WsMessage.CreateOneWayResponse(); }
public virtual void IntegerEvent(IntegerEventRequest eventReq) { // Create temp event source object, set the event action and create the event header DpwsWseEventSource eventSource; eventSource = EventSources["IntegerEvent"]; String action; action = "http://schemas.example.org/EventingService/IntegerEvent"; WsWsaHeader header; header = new WsWsaHeader(action, null, null, null, null, null); WsMessage msg = new WsMessage(header, eventReq, WsPrefix.Wse); // Create event serializer and write the event object IntegerEventRequestDataContractSerializer eventDcs; eventDcs = new IntegerEventRequestDataContractSerializer("IntegerEventRequest", "http://schemas.example.org/EventingService"); msg.Serializer = eventDcs; // Fire event Dpws.Device.Device.SubscriptionManager.FireEvent(this, eventSource, msg); }
/// <summary> /// Send an Http request to an endpoint and waits for a response. /// </summary> /// <param name="soapMessage">A byte array containing the soap message to be sent.</param> /// <param name="remoteEndpoint">A sting containing the name of a remote listening endpoint.</param> /// <returns> /// A WsMessage containing a soap response to the request. This array will be null for OneWay request. /// </returns> public WsMessage SendRequest(WsMessage request, Uri remoteEndpoint) { WsMessage response = new WsMessage(new WsWsaHeader(), null, WsPrefix.None); HttpTransportBindingElement httpClient = new HttpTransportBindingElement(new HttpTransportBindingConfig(remoteEndpoint)); ClientBindingContext ctx = new ClientBindingContext(m_version); ctx.ReceiveTimeout = new TimeSpan(0, 0, 0, 0, ReceiveTimeout); ctx.OpenTimeout = new TimeSpan(0, 0, 0, 0, RequestTimeout); ctx.SendTimeout = new TimeSpan(0, 0, 0, 0, SendTimeout); httpClient.EndpointAddress = remoteEndpoint; Stream stream = null; try { httpClient.Open(ref stream, ctx); httpClient.ProcessOutputMessage(ref request, ctx); ctx.BindingProperties.Clear(); httpClient.ProcessInputMessage(ref response, ctx); ctx.BindingProperties.Clear(); if(response.Body is byte[]) { response.Reader = WsSoapMessageParser.ParseSoapMessage((byte[])response.Body, ref response.Header, m_version); } } finally { httpClient.Close(stream, ctx); } return response; }
public virtual void OneWay(OneWayRequest req) { // Create request header String action; action = "http://schemas.example.org/SimpleService/OneWay"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer OneWayRequestDataContractSerializer reqDcs; reqDcs = new OneWayRequestDataContractSerializer("OneWayRequest", "http://schemas.example.org/SimpleService"); request.Serializer = reqDcs; request.Method = "OneWay"; // Send service request m_requestChannel.Open(); m_requestChannel.RequestOneWay(request); m_requestChannel.Close(); }
public virtual WsMessage TwoWay(WsMessage request) { // Build request object TwoWayRequestDataContractSerializer reqDcs; reqDcs = new TwoWayRequestDataContractSerializer("TwoWayRequest", "http://schemas.example.org/SimpleService"); TwoWayRequest req; req = ((TwoWayRequest)(reqDcs.ReadObject(request.Reader))); // Create response object // Call service operation to process request and return response. TwoWayResponse resp; resp = m_service.TwoWay(req); // Create response header WsWsaHeader respHeader = new WsWsaHeader("http://schemas.example.org/SimpleService/TwoWayResponse", request.Header.MessageID, m_version.AnonymousUri, null, null, null); WsMessage response = new WsMessage(respHeader, resp, WsPrefix.Wsdp); // Create response serializer TwoWayResponseDataContractSerializer respDcs; respDcs = new TwoWayResponseDataContractSerializer("TwoWayResponse", "http://schemas.example.org/SimpleService"); response.Serializer = respDcs; return response; }
/// <summary> /// Create an instance of a SubscriptionEndEvent arguments object. /// </summary> internal SubscriptionEndEventArgs(WsMessage msg, ProtocolVersion version) { // Retrieve the Identifier WsWsaHeader header = msg.Header; XmlReader reader = msg.Reader; this.Identifier = header.Any.GetNodeValue("Identifier", version.EventingNamespace); reader.ReadStartElement("SubscriptionEnd", version.EventingNamespace); if (reader.IsStartElement("SubscriptionManager", version.EventingNamespace)) { this.SubscriptionManager = new WsWsaEndpointRef(reader, version.AddressingNamespace); } this.SubscriptionID = this.SubscriptionManager.RefParameters.GetNodeValue("Identifier", version.EventingNamespace); if (this.SubscriptionID == null || this.Identifier == null) // both need to be there { throw new XmlException(); } }
public virtual TwoWayAttachmentResponse TwoWayAttachment(TwoWayAttachmentRequest req) { // Create request header String action; action = "http://schemas.example.org/AttachmentService/TwoWayAttachment"; WsWsaHeader header; header = new WsWsaHeader(action, null, EndpointAddress, m_version.AnonymousUri, null, null); WsMessage request = new WsMessage(header, req, WsPrefix.None); // Create request serializer TwoWayAttachmentRequestDataContractSerializer reqDcs; reqDcs = new TwoWayAttachmentRequestDataContractSerializer("TwoWayAttachmentRequest", "http://schemas.example.org/AttachmentService"); request.Serializer = reqDcs; request.Method = "TwoWayAttachment"; // Indicate that this message will use Mtom encoding request.BodyParts = new WsMtomBodyParts(); // Send service request m_requestChannel.Open(); WsMessage response = m_requestChannel.Request(request); m_requestChannel.Close(); // Process response TwoWayAttachmentResponseDataContractSerializer respDcs; respDcs = new TwoWayAttachmentResponseDataContractSerializer("TwoWayAttachmentResponse", "http://schemas.example.org/AttachmentService"); respDcs.BodyParts = response.BodyParts; TwoWayAttachmentResponse resp; resp = ((TwoWayAttachmentResponse)(respDcs.ReadObject(response.Reader))); response.Reader.Dispose(); response.Reader = null; return resp; }
private WsMessage GetStatusResponse(WsWsaHeader header, long newDuration) { using(XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create()) { WsWsaHeader responseHeader = new WsWsaHeader( WsWellKnownUri.WseNamespaceUri + "/RenewResponse", // Action header.MessageID, // RelatesTo header.ReplyTo.Address.AbsoluteUri, // To null, null, null); // ReplyTo, From, Any WsMessage msg = new WsMessage(responseHeader, null, WsPrefix.Wse, null, new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version); smw.WriteSoapMessageStart(xmlWriter, msg); // write body xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null); xmlWriter.WriteString(new WsDuration(newDuration).DurationString); xmlWriter.WriteEndElement(); // End Expires smw.WriteSoapMessageEnd(xmlWriter); msg.Body = xmlWriter.ToArray(); return msg; } }
/// <summary> /// Eventing UnSubscribe stub. /// </summary> /// <param name="header">Header object.</param> /// <param name="reader">An XmlReader positioned at the begining of the Unsubscribe request body element.</param> /// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the specified event.</param> /// <returns>Byte array containing an UnSubscribe response.</returns> /// <remarks>This method is used by the stack framework. Do not use this method.</remarks> public WsMessage Unsubscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints) { // Parse Unsubscribe Request /////////////////////////////// // there's no info in Unsubscribe that we actually need, just get the identifier from header String eventSinkID = header.Any.GetNodeValue("Identifier", WsWellKnownUri.WseNamespaceUri); bool eventSourceFound = false; if (eventSinkID != null) { // Parse urn:uuid from the To address string endpointAddress = FixToAddress(header.To); // Iterate the list of hosted services at the specified endpoint and unsubscribe from each event source // that matches the eventSinkID DpwsHostedService serv = (DpwsHostedService)Device.HostedServices[endpointAddress]; if(serv != null) { DpwsWseEventSources eventSources = serv.EventSources; // Delete Subscription // Look for matching event in hosted services event sources DpwsWseEventSource eventSource; DpwsWseEventSinks eventSinks; DpwsWseEventSink eventSink; int eventSourcesCount = eventSources.Count; int eventSinksCount; for (int i = 0; i < eventSourcesCount; i++) { eventSource = eventSources[i]; eventSinks = eventSource.EventSinks; eventSinksCount = eventSinks.Count; eventSink = eventSinks[eventSinkID]; if (eventSink != null) { eventSourceFound = true; eventSource.EventSinks.Remove(eventSink); } } } if (eventSourceFound) { // Generate Response using(XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create()) { WsWsaHeader responseHeader = new WsWsaHeader( WsWellKnownUri.WseNamespaceUri + "/UnsubscribeResponse",// Action header.MessageID, // RelatesTo header.ReplyTo.Address.AbsoluteUri, // To null, null, null); WsMessage msg = new WsMessage( responseHeader, null, WsPrefix.Wse, null, new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version); smw.WriteSoapMessageStart(xmlWriter, msg); smw.WriteSoapMessageEnd(xmlWriter); // Return stream buffer msg.Body = xmlWriter.ToArray(); return msg; } } } // Something went wrong throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess); }
/// <summary> /// Global eventing Subscribe stub. /// </summary> /// <param name="header">Header object.</param> /// <param name="reader">An XmlReader positioned at the begining of the Subscribe request body element.</param> /// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the event source specified in the filter.</param> /// <returns>Byte array containing a Subscribe response.</returns> internal WsMessage Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints) { WsMessage msg = null; // Parse Subscribe Request ///////////////////////////// DpwsWseEventSink eventSink = new DpwsWseEventSink(); try { reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri); if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri)) { eventSink.EndTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace); } reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri); if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri)) { eventSink.NotifyTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace); } else { throw new WsFaultException(header, WsFaultType.WseDeliverModeRequestedUnavailable); } reader.ReadEndElement(); if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri)) { long expires = new WsDuration(reader.ReadElementString()).DurationInSeconds; if (expires > 0) { eventSink.Expires = expires; } else { throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime); } } else { // Never Expires eventSink.Expires = -1; } if (reader.IsStartElement("Filter", WsWellKnownUri.WseNamespaceUri)) { if (reader.MoveToAttribute("Dialect") == false || reader.Value != m_version.WsdpNamespaceUri + "/Action") { throw new WsFaultException(header, WsFaultType.WseFilteringRequestedUnavailable); } reader.MoveToElement(); String filters = reader.ReadElementString(); if (filters != String.Empty) { eventSink.Filters = filters.Split(' '); } } XmlReaderHelper.SkipAllSiblings(reader); reader.ReadEndElement(); // Subscribe } catch (XmlException e) { throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString()); } // Parse urn:uuid from the To address string endpointAddress = FixToAddress(header.To); // Build a temporary collection of device services that match the specified endpoint address. WsServiceEndpoints matchingServices = new WsServiceEndpoints(); for (int i = 0; i < serviceEndpoints.Count; ++i) { if (serviceEndpoints[i].EndpointAddress == endpointAddress) matchingServices.Add(serviceEndpoints[i]); } // For each service with a matching endpoint and event sources add an event sink to the // event source collection for (int i = 0; i < matchingServices.Count; ++i) { DpwsWseEventSources eventSources = ((DpwsHostedService)matchingServices[i]).EventSources; // Set the EventSinkID eventSink.ID = "urn:uuid:" + Guid.NewGuid().ToString(); // If subscribing to all event sources if (eventSink.Filters == null) { int count = eventSources.Count; for (int ii = 0; i < count; i++) { DpwsWseEventSource eventSource = eventSources[ii]; eventSink.StartTime = DateTime.Now.Ticks; eventSource.EventSinks.Add(eventSink); } } else { // If subscribing to a specific event based on an event filter. DpwsWseEventSource eventSource; string[] filterList = eventSink.Filters; int length = filterList.Length; for (int ii = 0; i < length; i++) { if ((eventSource = eventSources[filterList[ii]]) != null) { eventSink.StartTime = DateTime.Now.Ticks; eventSource.EventSinks.Add(eventSink); } else { throw new Exception("Event source " + filterList[ii] + " was not found."); } } } } // Generate Response ////////////////////////// using(XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create()) { WsWsaHeader responseHeader = new WsWsaHeader( WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse", // Action header.MessageID, // RelatesTo header.ReplyTo.Address.AbsoluteUri, // To null, null, null); // ReplyTo, From, Any msg = new WsMessage(responseHeader, null, WsPrefix.Wse, null, new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version); smw.WriteSoapMessageStart(xmlWriter, msg); // write body xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscribeResponse", null); xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscriptionManager", null); xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "Address", null); // Create a uri. Use the path (by default will be a uuid) for the sub manager endpoint Uri subMgrUri = new Uri(((DpwsHostedService)matchingServices[0]).EndpointAddress); xmlWriter.WriteString("http://" + Device.IPV4Address + ":" + Device.Port + "/" + subMgrUri.AbsolutePath); xmlWriter.WriteEndElement(); // End Address xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "ReferenceParameters", null); xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Identifier", null); xmlWriter.WriteString(eventSink.ID); xmlWriter.WriteEndElement(); // End Identifier xmlWriter.WriteEndElement(); // End ReferenceParameters xmlWriter.WriteEndElement(); // End SubscriptionManager xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null); xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString); xmlWriter.WriteEndElement(); // End Expires xmlWriter.WriteEndElement(); // End SubscribeResponse smw.WriteSoapMessageEnd(xmlWriter); // Return stream buffer msg.Body = xmlWriter.ToArray(); } return msg; }