/// <summary> /// Creates a http service host. /// </summary> /// <param name="port">An integer containing the port number this host will listen on.</param> /// <param name="serviceEndpoints">A collection of service endpoints this transport service can dispatch to.</param> public WsHttpServiceHost(_Bind.Binding binding, WsServiceEndpoints serviceEndpoints) { m_threadManager = new WsThreadManager(5, "Http"); m_binding = binding; m_serviceEndpoints = serviceEndpoints; m_isStarted = false; }
/// <summary> /// Creates an instance of a DpwsClient class with a specified eventing callback port number. /// </summary> public DpwsClient(Binding localBinding, ProtocolVersion v) { m_threadLock = new object(); m_eventClient = new DpwsEventingClient(v); m_mexClient = new DpwsMexClient(v); m_eventCallbacks = new WsServiceOperations(); m_callbackServiceEndpoints = new WsServiceEndpoints(); m_blockingCall = true; m_ignoreRequestFromThisIP = true; m_localBinding = localBinding; m_version = v; m_discoClient = new DpwsDiscoveryClient(this, v); // Add the Hello and Bye discovery disco services ClientDiscoveryService = new DpwsDiscoClientService(this, v); // Start a Udp discovery service host WsUdpServiceHost.Instance.AddServiceEndpoint(ClientDiscoveryService); WsUdpServiceHost.Instance.IgnoreRequestFromThisIP = m_ignoreRequestFromThisIP; WsUdpServiceHost.Instance.MaxThreadCount = 5; WsUdpServiceHost.Instance.Start(new ServerBindingContext(v)); }
/// <summary> /// Creates an instance of a DpwsClient class with a specified eventing callback port number. /// </summary> public DpwsClient(Binding localBinding, ProtocolVersion v) { m_threadLock = new object(); m_eventClient = new DpwsEventingClient(v); m_mexClient = new DpwsMexClient(v); m_eventCallbacks = new WsServiceOperations(); m_callbackServiceEndpoints = new WsServiceEndpoints(); m_blockingCall = true; m_ignoreRequestFromThisIP = true; m_localBinding = localBinding; m_version = v; m_discoClient = new DpwsDiscoveryClient(this, v); // Add the Hello and Bye discovery disco services ClientDiscoveryService = new DpwsDiscoClientService(this, v); // Start a Udp discovery service host WsUdpServiceHost.Instance.AddServiceEndpoint(ClientDiscoveryService); WsUdpServiceHost.Instance.IgnoreRequestFromThisIP = m_ignoreRequestFromThisIP; WsUdpServiceHost.Instance.MaxThreadCount = 5; WsUdpServiceHost.Instance.Start(new ServerBindingContext(v)); // Add eventing SubscriptionEnd ServiceOperations. By default Subscription End call back // to this client ServiceOperations.Add(new WsServiceOperation(WsWellKnownUri.WseNamespaceUri, "SubscriptionEnd")); // Add callbacks implemented by this client m_callbackServiceEndpoints.Add(this); // Start the Http service host m_httpServiceHost = new WsHttpServiceHost(m_localBinding, m_callbackServiceEndpoints); m_httpServiceHost.MaxThreadCount = m_callbackServiceEndpoints.Count; m_httpServiceHost.Start(new ServerBindingContext(v)); System.Ext.Console.Write("Http service host started..."); }
/// <summary> /// Event GetStatus stub. /// </summary> /// <param name="header">Header object.</param> /// <param name="reader">An XmlReader positioned at the begining of the GetStatus 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 GetStatus response.</returns> /// <remarks>This method is used by the stack framework. Do not use this method.</remarks> public WsMessage GetStatus(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints) { // Parse GetStatus Request /////////////////////////////// // there's no info in GetStatus that we actually need, just get the identifier from header String eventSinkID = header.Any.GetNodeValue("Identifier", WsWellKnownUri.WseNamespaceUri); // Iterate the list of hosted services at the specified endpoint and get the status of the first // subscription matching the eventSink. Not pretty but eventing and shared service endpoints don't // fit together if (eventSinkID != null) { // Parse urn:uuid from the To address string endpointAddress = FixToAddress(header.To); DpwsHostedService endpoint = (DpwsHostedService)serviceEndpoints[endpointAddress]; if (endpoint != null) { DpwsWseEventSink eventSink; if ((eventSink = GetEventSink(endpoint.EventSources, eventSinkID)) != null) { long timeRemaining = DateTime.Now.Ticks - (eventSink.StartTime + eventSink.Expires); timeRemaining = timeRemaining < 0 ? 0 : timeRemaining; return GetStatusResponse(header, timeRemaining); } } } // Something went wrong throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess); }
/// <summary> /// Event renew stub. /// </summary> /// <param name="header">Header object.</param> /// <param name="reader">An XmlReader positioned at the begining of the Renew 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 Renew response.</returns> /// <remarks>This method is used by the stack framework. Do not use this method.</remarks> public WsMessage Renew(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints) { long newExpiration = 0; String eventSinkId = String.Empty; // Parse Renew request //////////////////////////// try { reader.ReadStartElement("Renew", WsWellKnownUri.WseNamespaceUri); if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri)) { newExpiration = new WsDuration(reader.ReadElementString()).DurationInSeconds; if (newExpiration <= 0) { throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime); } } else { // Never Expires newExpiration = -1; } eventSinkId = header.Any.GetNodeValue("Identifier", WsWellKnownUri.WseNamespaceUri); if (eventSinkId == null) { throw new XmlException(); } } catch (XmlException e) { throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString()); } // Parse urn:uuid from the To address string endpointAddress = FixToAddress(header.To); // Iterate the list of hosted services at the specified endpoint and renew each subscription // with and event source that matches the eventSinkID DpwsWseEventSink eventSink; bool eventSinkFound = false; DpwsHostedService endpoint = (DpwsHostedService)serviceEndpoints[endpointAddress]; if(endpoint != null) { if ((eventSink = GetEventSink(endpoint.EventSources, eventSinkId)) != null) { eventSinkFound = true; // Update event sink expires time eventSink.Expires = newExpiration; } } // Generate Response if (eventSinkFound) return GetStatusResponse(header, newExpiration); // It's just like the GetStatus Response throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess, "Subscription was not found. ID=" + eventSinkId); }
/// <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; }
/// <summary> /// HttpProcess() /// Summary: /// Main Http processor class. /// </summary> /// <param name="serviceEndpoints">A collection of service endpoints.</param> /// <param name="s"> /// Socket s /// </param> public WsHttpMessageProcessor(WsServiceEndpoints serviceEndpoints) { m_serviceEndpoints = serviceEndpoints; }
static Device() { m_MetadataVersion = 1; m_AppSequence = 1; m_MessageID = 0; m_hostedServices = new WsServiceEndpoints(); m_appMaxDelay = 500; }
/// <summary> /// Stop tranport services and releases the managed resources used by this class. /// </summary> /// <param name="disposing">True to release managed resources</param> internal void Dispose(bool disposing) { if (disposing) { // Stop the transport services m_httpServiceHost.Stop(); m_udpSeviceHost.Stop(); m_threadLock = null; m_discoClient = null; m_endpointAddress = null; m_eventClient = null; m_mexClient = null; m_eventCallbacks = null; m_transportAddress = null; m_bodyParts = null; m_discoServiceEndpoints = null; m_callbackServiceEndpoints = null; m_udpSeviceHost = null; m_httpServiceHost = null; } }
//private const int ReadPayload = 0x800; /// <summary> /// HttpProcess() /// Summary: /// Main Http processor class. /// </summary> /// <param name="serviceEndpoints">A collection of service endpoints.</param> /// <param name="s"> /// Socket s /// </param> public WsHttpMessageProcessor(WsServiceEndpoints serviceEndpoints, _Bind.RequestContext context) { m_context = context; m_serviceEndpoints = serviceEndpoints; }
/// <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 byte[] 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 for (int i = 0; i < Device.HostedServices.Count; ++i) { if (serviceEndpoints[i].EndpointAddress == endpointAddress) { // Delete Subscription DpwsWseEventSources eventSources = ((DpwsHostedService)Device.HostedServices[i]).EventSources; // Look for matching event in hosted services event sources DpwsWseEventSource eventSource; DpwsWseEventSinks eventSinks; DpwsWseEventSink eventSink; int eventSourcesCount = eventSources.Count; int eventSinksCount; for (int ii = 0; ii < eventSourcesCount; ii++) { eventSource = eventSources[ii]; eventSinks = eventSource.EventSinks; eventSinksCount = eventSinks.Count; for (int j = 0; j < eventSinksCount; j++) { eventSink = eventSinks[j]; if (eventSink.ID == eventSinkID) { eventSourceFound = true; eventSource.EventSinks.Remove(eventSink); } } } } } if (eventSourceFound) { // Generate Response MemoryStream soapStream = new MemoryStream(); XmlWriter xmlWriter = XmlWriter.Create(soapStream); WsWsaHeader responseHeader = new WsWsaHeader( WsWellKnownUri.WseNamespaceUri + "/UnsubscribeResponse",// Action header.MessageID, // RelatesTo header.ReplyTo.Address.AbsoluteUri, // To null, null, null); WsSoapMessageWriter.WriteSoapMessageStart(xmlWriter, WsSoapMessageWriter.Prefixes.Wse, // Prefix null, // Additional Prefix responseHeader, // Header new WsSoapMessageWriter.AppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); // AppSequence WsSoapMessageWriter.WriteSoapMessageEnd(xmlWriter); // Flush and close writer. Return stream buffer xmlWriter.Flush(); xmlWriter.Close(); return soapStream.ToArray(); } } // Something went wrong throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess); }