protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return new CompletedAsyncResult<EndpointDiscoveryMetadata>( this.Match(resolveCriteria), callback, state); }
internal static ResolveCriteria ReadXml (XmlReader reader, DiscoveryVersion version) { if (reader == null) throw new ArgumentNullException ("reader"); var ret = new ResolveCriteria (); reader.MoveToContent (); if (!reader.IsStartElement ("ResolveType", version.Namespace) || reader.IsEmptyElement) throw new XmlException ("Non-empty ResolveType element is expected"); reader.ReadStartElement ("ResolveType", version.Namespace); // standard members reader.MoveToContent (); ret.Address = EndpointAddress.ReadFrom (version.MessageVersion.Addressing, reader); // non-standard members for (reader.MoveToContent (); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent ()) { if (reader.NamespaceURI == SerializationNS) { switch (reader.LocalName) { case "Duration": ret.Duration = (TimeSpan) reader.ReadElementContentAs (typeof (TimeSpan), null); break; } } else ret.Extensions.Add (XElement.Load (reader)); } reader.ReadEndElement (); return ret; }
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return(new CompletedAsyncResult <EndpointDiscoveryMetadata>( this.Match(resolveCriteria), callback, state)); }
protected ResolveRequestResponseAsyncResult( TResolveMessage resolveMessage, IDiscoveryServiceImplementation discoveryServiceImpl, AsyncCallback callback, object state) : base(callback, state) { Fx.Assert(resolveMessage != null, "The resolveMessage must be non null."); Fx.Assert(discoveryServiceImpl != null, "The discoveryServiceImpl must be non null."); this.discoveryServiceImpl = discoveryServiceImpl; if (!this.Validate(resolveMessage)) { this.Complete(true); return; } else { this.context = new DiscoveryOperationContext(OperationContext.Current); this.resolveCriteria = this.GetResolveCriteria(resolveMessage); if (this.ProcessResolveRequest()) { this.Complete(true); return; } } }
protected ResolveDuplexAsyncResult(TResolveMessage resolveMessage, IDiscoveryServiceImplementation discoveryServiceImpl, IMulticastSuppressionImplementation multicastSuppressionImpl, AsyncCallback callback, object state) : base(callback, state) { Fx.Assert(resolveMessage != null, "The resolveMessage must be non null."); Fx.Assert(discoveryServiceImpl != null, "The discoveryServiceImpl must be non null."); this.discoveryServiceImpl = discoveryServiceImpl; this.multicastSuppressionImpl = multicastSuppressionImpl; if (!this.Validate(resolveMessage)) { this.Complete(true); return; } else { this.context = new DiscoveryOperationContext(OperationContext.Current); this.resolveCriteria = this.GetResolveCriteria(resolveMessage); this.timeoutHelper = new TimeoutHelper(this.resolveCriteria.Duration); this.timeoutHelper.RemainingTime(); this.Process(); } }
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { Console.WriteLine("Received a Resolve request message. Forwarding the Resolve message."); // ResolveAsyncResult will forward the Resolve request return new ResolveAsyncResult(resolveCriteria, this.forwardingDiscoveryEndpoint, callback, state); }
//Resolve protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { EndpointDiscoveryMetadata endpoint = null; if (this.Endpoints.ContainsKey(resolveCriteria.Address)) { endpoint = this.Endpoints[resolveCriteria.Address]; } return new DiscoveryAsyncResult(callback, endpoint); }
public virtual EndpointDiscoveryMetadata ResolveEndpoint(ResolveCriteria resolveCriteria) { foreach (var metadata in endpoints.Values) { if (resolveCriteria.Address == metadata.Address) { return metadata; } } return null; }
public virtual EndpointDiscoveryMetadata ResolveService(ResolveCriteria resolveCriteria) { foreach (EndpointDiscoveryMetadata metadata in services.Values) { if (resolveCriteria.Address == metadata.Address) { return metadata; } } return null; }
public EndpointDiscoveryMetadata Match(ResolveCriteria criteria) { EndpointDiscoveryMetadata matchingEndpoint = null; _logger.Log("Matching " + criteria, LogLevel.Debug); foreach (var onlineService in _onlineServices.Values.Where(x => criteria.Address == x.Metadata.Address)) { _logger.Log("...found " + criteria.Address, LogLevel.Debug); matchingEndpoint = onlineService.Metadata; } return matchingEndpoint; }
public ResolveAsyncResult(ResolveCriteria resolveCriteria, DiscoveryEndpoint forwardingDiscoveryEndpoint, AsyncCallback callback, object state) : base(callback, state) { this.resolveCriteria = resolveCriteria; this.discoveryClient = new DiscoveryClient(forwardingDiscoveryEndpoint); this.discoveryClient.ResolveCompleted += new EventHandler<ResolveCompletedEventArgs>(ResolveCompleted); // Forwards the Resolve request message this.discoveryClient.ResolveAsync(resolveCriteria); }
EndpointDiscoveryMetadata Match(ResolveCriteria criteria) { for (int i = 0; i < this.publishedEndpoints.Count; i++) { if (this.publishedEndpoints[i].Address.Equals(criteria.Address)) { return(this.publishedEndpoints[i]); } } return(null); }
EndpointDiscoveryMetadata Match(ResolveCriteria criteria) { for (int i = 0; i < this.publishedEndpoints.Count; i++) { if (this.publishedEndpoints[i].Address.Equals(criteria.Address)) { return this.publishedEndpoints[i]; } } return null; }
public EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria) { EndpointDiscoveryMetadata matchingEndpoint = null; lock (_onlineServices) { foreach (var endpointDiscoveryMetadata in _onlineServices.Values) { if (criteria.Address == endpointDiscoveryMetadata.Address) { matchingEndpoint = endpointDiscoveryMetadata; } } } return matchingEndpoint; }
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { EndpointDiscoveryMetadata matchingEndpoint = null; foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.publishedEndpoints) { if (resolveCriteria.Address == endpointDiscoveryMetadata.Address) { matchingEndpoint = endpointDiscoveryMetadata; break; } } return new ResolveAsyncResult(matchingEndpoint, callback, state); }
public void ResolveAsync(ResolveCriteria criteria, object userState) { AsyncCallback cb = delegate(IAsyncResult result) { ResolveResponse ret = null; Exception error = null; try { ret = EndResolve(result); } catch (Exception ex) { error = ex; } OnResolveCompleted(new ResolveCompletedEventArgs(ret, error, cancelled, result.AsyncState)); }; cancelled = false; BeginResolve(criteria, cb, userState); }
internal static ResolveCriteria ReadXml(XmlReader reader, DiscoveryVersion version) { if (reader == null) { throw new ArgumentNullException("reader"); } var ret = new ResolveCriteria(); reader.MoveToContent(); if (!reader.IsStartElement("ResolveType", version.Namespace) || reader.IsEmptyElement) { throw new XmlException("Non-empty ResolveType element is expected"); } reader.ReadStartElement("ResolveType", version.Namespace); // standard members reader.MoveToContent(); ret.Address = EndpointAddress.ReadFrom(version.MessageVersion.Addressing, reader); // non-standard members for (reader.MoveToContent(); !reader.EOF && reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NamespaceURI == SerializationNS) { switch (reader.LocalName) { case "Duration": ret.Duration = (TimeSpan)reader.ReadElementContentAs(typeof(TimeSpan), null); break; } } else { ret.Extensions.Add(XElement.Load(reader)); } } reader.ReadEndElement(); return(ret); }
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { // FIXME: this is a workaround for (similar to) bug #633945. switch (Environment.OSVersion.Platform) { case PlatformID.Unix: case PlatformID.MacOSX: if (resolve_delegate == null) { resolve_delegate = new Func <ResolveCriteria, EndpointDiscoveryMetadata> (Resolve); } return(resolve_delegate.BeginInvoke(resolveCriteria, callback, state)); default: var ret = Resolve(resolveCriteria); var result = new TempAsyncResult(ret, state); if (callback != null) { callback(result); } return(result); } }
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return response; }
protected abstract IAsyncResult OnBeginResolve (ResolveCriteria resolveCriteria, AsyncCallback callback, Object state);
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, Object state) { Console.Error.WriteLine("OnBeginResolve"); throw new Exception("2"); }
//----------------------------------------------------- // Redirect Adhoc to Managed Resolve //----------------------------------------------------- #region ShouldRedirectResolve // // Summary: // Override this method to allow the discovery proxy to send out multicast suppression // messages when it receives a multicast resolve request. // // Parameters: // findCriteria: // The find criteria that describes the service to find. // // callback: // The callback delegate to call when the operation is completed. // // state: // The user-defined state data. // // Returns: // A reference to the pending asynchronous operation. protected override IAsyncResult BeginShouldRedirectResolve(ResolveCriteria findCriteria, AsyncCallback callback, object state) { return(_resolveTaskFactory.Create(findCriteria).ToApm(callback, state)); }
EndpointDiscoveryMetadata Resolve (ResolveCriteria criteria) { throw new NotImplementedException (); }
// resolve public ResolveResponse Resolve(ResolveCriteria criteria) { return(EndResolve(BeginResolve(criteria, null, null))); }
IAsyncResult IMulticastSuppressionImplementation.BeginShouldRedirectResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return this.BeginShouldRedirectResolve(resolveCriteria, callback, state); }
protected virtual IAsyncResult BeginShouldRedirectResolve(ResolveCriteria findCriteria, AsyncCallback callback, object state) { return new CompletedAsyncResult<bool>(false, callback, state); }
IAsyncResult IDiscoveryServiceImplementation.BeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return this.OnBeginResolve(resolveCriteria, callback, state); }
protected virtual IAsyncResult BeginShouldRedirectResolve(ResolveCriteria findCriteria, AsyncCallback callback, Object state) { throw new NotImplementedException(); }
/// <summary> /// Begins an asynchronous resolve operation with the specified criteria. /// </summary> /// <param name="discoveryClient">The discovery client.</param> /// <param name="criteria">The criteria for matching a service endpoint.</param> /// <returns>A Task that represents the asynchronous operation.</returns> public static Task<ResolveResponse> ResolveTaskAsync( this DiscoveryClient discoveryClient, ResolveCriteria criteria) { // Validate arguments if (discoveryClient == null) throw new ArgumentNullException("discoveryClient"); // Create a TaskCompletionSource to represent the operation var tcs = new TaskCompletionSource<ResolveResponse>(discoveryClient); // Register a handler that will transfer completion results to the TCS Task EventHandler<ResolveCompletedEventArgs> completedHandler = null; completedHandler = (sender, e) => TaskServices.HandleEapCompletion(tcs, true, e, () => e.Result, () => discoveryClient.ResolveCompleted -= completedHandler); discoveryClient.ResolveCompleted += completedHandler; // Start the async operation. try { discoveryClient.ResolveAsync(criteria, tcs); } catch { discoveryClient.ResolveCompleted -= completedHandler; throw; } // Return the task to represent the asynchronous operation return tcs.Task; }
protected virtual IAsyncResult BeginShouldRedirectResolve(ResolveCriteria findCriteria, AsyncCallback callback, object state) { return(new CompletedAsyncResult <bool>(false, callback, state)); }
IAsyncResult IMulticastSuppressionImplementation.BeginShouldRedirectResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return(this.BeginShouldRedirectResolve(resolveCriteria, callback, state)); }
protected virtual IAsyncResult BeginShouldRedirectResolve (ResolveCriteria findCriteria, AsyncCallback callback, Object state) { throw new NotImplementedException (); }
IAsyncResult BeginResolve(ResolveCriteria criteria, AsyncCallback callback, object state) { return(((IDiscoveryCommon)client).BeginResolve(criteria, callback, state)); }
// OnBeginFind method is called when a Resolve request message is received by the Proxy protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { _logger.Log("OnBeginResolve()", LogLevel.Debug); return new OnResolveAsyncResult(_provider.Match(resolveCriteria), callback, state); }
public void ResolveAsync (ResolveCriteria criteria) { throw new NotImplementedException (); }
protected override IAsyncResult OnBeginResolve (ResolveCriteria resolveCriteria, AsyncCallback callback, Object state) { if (resolve_delegate == null) resolve_delegate = new Func<ResolveCriteria,EndpointDiscoveryMetadata> (Resolve); return resolve_delegate.BeginInvoke (resolveCriteria, callback, state); }
protected override IAsyncResult OnBeginResolve (ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { // FIXME: this is a workaround for (similar to) bug #633945. switch (Environment.OSVersion.Platform) { case PlatformID.Unix: case PlatformID.MacOSX: if (resolve_delegate == null) resolve_delegate = new Func<ResolveCriteria,EndpointDiscoveryMetadata> (Resolve); return resolve_delegate.BeginInvoke (resolveCriteria, callback, state); default: var ret = Resolve (resolveCriteria); var result = new TempAsyncResult (ret, state); if (callback != null) callback (result); return result; } }
//----------------------------------------------------- // Resolve //----------------------------------------------------- #region Resolve /// <summary> /// Handles a resolve operation. /// </summary> /// <param name="resolveCriteria">The resolve criteria that describes the service to discover.</param> /// <param name="callback">The callback delegate to call when the operation is completed.</param> /// <param name="state">The user-defined state data.</param> /// <returns>A reference to the pending asynchronous operation.</returns> protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return(_resolveTaskFactory.Create(resolveCriteria).ToApm(callback, state)); }
/// <summary> /// Return a random EndpointDiscoveryMetadata out of the endpoints that match a criteria. /// The endpoint is chosen in random for load balancing /// </summary> /// <param name="criteria"></param> /// <returns></returns> EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria) { EndpointDiscoveryMetadata matchingEndpoint = null; Random rnd = new Random(); lock (this.onlineServices) { List<EndpointDiscoveryMetadata> eplist = new List<EndpointDiscoveryMetadata>(); foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values) { if (criteria.Address == endpointDiscoveryMetadata.Address) { eplist.Add(endpointDiscoveryMetadata); } } //make sure the endpoints distribute randomaly int index = rnd.Next(eplist.Count); matchingEndpoint = eplist.ToArray()[index]; } return matchingEndpoint; }
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return new SynchronousResult(callback, state, implementation.ResolveEndpoint(resolveCriteria)); }
public void ResolveAsync(ResolveCriteria criteria) { ResolveAsync(criteria, null); }
public virtual EndpointDiscoveryMetadata ResolveEndpoint(ResolveCriteria resolveCriteria) { using (@lock.ForReading()) { EndpointDiscoveryMetadata endpoint; return endpoints.TryGetValue(resolveCriteria.Address, out endpoint) ? endpoint : null; } }
EndpointDiscoveryMetadata Resolve(ResolveCriteria criteria) { throw new NotImplementedException(); }
protected override IAsyncResult OnBeginResolve (ResolveCriteria resolveCriteria, AsyncCallback callback, Object state) { Console.Error.WriteLine ("OnBeginResolve"); throw new Exception ("2"); }
protected abstract IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, Object state);
public void ResolveAsync (ResolveCriteria criteria, object userState) { throw new NotImplementedException (); }
IAsyncResult IDiscoveryServiceImplementation.BeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return(this.OnBeginResolve(resolveCriteria, callback, state)); }
// OnBeginFind method is called when a Resolve request message is received by the Proxy protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state) { return new OnResolveAsyncResult(this.MatchFromOnlineService(resolveCriteria), callback, state); }
public ResolveResponse Resolve (ResolveCriteria criteria) { throw new NotImplementedException (); }