protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
Console.WriteLine("Received a Probe request message. Forwarding the Probe message.");
// FindAsyncResult will forward the Probe request
return(new FindAsyncResult(findRequestContext, this.forwardingDiscoveryEndpoint, callback, state));
}
/// <summary>
/// Override this method to handle a find operation.
/// </summary>
/// <param name="findRequestContext">The find request context 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 OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
if (findRequestContext == null)
{
throw new ArgumentNullException("findRequestContext");
}
Console.WriteLine("Find request for contract {0}", findRequestContext.Criteria.ContractTypeNames.FirstOrDefault());
// query to find the matching endpoints
var query = from service in cache
where findRequestContext.Criteria.IsMatch(service)
select service;
// collection to contain the results of the query
var matchingEndpoints = new Collection <EndpointDiscoveryMetadata>();
// execute the query and add the matching endpoints
foreach (EndpointDiscoveryMetadata metadata in query)
{
matchingEndpoints.Add(metadata);
findRequestContext.AddMatchingEndpoint(metadata);
}
return(new FindAsyncResult(matchingEndpoints, callback, state));
}
//-----------------------------------------------------
// Interface Implementations
//-----------------------------------------------------
#region IProbeTaskFactory Members
/// <summary>
/// Creates Task to handle Probe request
/// </summary>
/// <param name="findRequestContext">Criteria for finding correct endpoints</param>
/// <returns>Returns <see cref="Task"/> object which encapsulates request handler</returns>
Task IProbeTaskFactory.Create(FindRequestContext findRequestContext)
{
// Create Task containing Rx LINQ query
return(findRequestContext.Criteria
.ContractTypeNames // Each requested contract name
.ToObservable() // As Observable
.ObserveOn(Scheduler.NewThread) // Asynchronously
.TakeUntil(Observable.Return(XmlQualifiedName.Empty) // Take until...
.Delay(findRequestContext.Criteria.Duration)) // ...until timeout
.Where(name => { return _dictionary.ContainsKey(name); }) // Select only contract names present in the dictionary
.SelectMany(name => { return _dictionary[name].ToObservable(); }) // Endpoints implementing requested Contract name
.Where(endpoint =>
{
return _scopesPredicate(endpoint.Scopes, // With matching scopes
findRequestContext.Criteria.Scopes,
findRequestContext.Criteria.ScopeMatchBy)
&& _extensionsPredicate(endpoint.Extensions, // and matching extensions
findRequestContext.Criteria.Extensions);
})
.Take(findRequestContext.Criteria.MaxResults) // Take requested number of results
.Aggregate(findRequestContext,
(context, endpoint) =>
{
context.AddMatchingEndpoint(endpoint); // Add matching endpoints
return context;
})
.ToTask());
}
/// <summary>
/// Matches from online service.
/// </summary>
/// <param name="findRequestContext">The find request context.</param>
public void MatchFromOnlineService(FindRequestContext findRequestContext)
{
foreach (var metadata in _onlineServices.Values
.Where(data => findRequestContext.Criteria.IsMatch(data)))
{
findRequestContext.AddMatchingEndpoint(metadata);
}
}
public virtual void FindEndpoints(FindRequestContext findRequestContext)
{
using (@lock.ForReading())
{
foreach (var endpoint in MatchTargets(findRequestContext.Criteria))
{
findRequestContext.AddMatchingEndpoint(endpoint);
}
}
}
public virtual void FindService(FindRequestContext findRequestContext)
{
foreach (var metadata in services.Values)
{
if (findRequestContext.Criteria.IsMatch(metadata))
{
findRequestContext.AddMatchingEndpoint(metadata);
}
}
}
void Find(FindRequestContext context)
{
TextWriter.Null.WriteLine("Find operation: " + context);
foreach (var edm in endpoints)
{
if (context.Criteria.IsMatch(edm))
{
context.AddMatchingEndpoint(edm);
}
}
}
//Find(Probe)
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
var endpoints = from item in this.Endpoints
where findRequestContext.Criteria.IsMatch(item.Value)
select item.Value;
foreach (var item in endpoints)
{
findRequestContext.AddMatchingEndpoint(item);
}
return(new DiscoveryAsyncResult(callback, state));
}
void MatchFromOnlineService(FindRequestContext findRequestContext)
{
lock (this.onlineServices)
{
foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
{
if (findRequestContext.Criteria.IsMatch(endpointDiscoveryMetadata))
{
findRequestContext.AddMatchingEndpoint(endpointDiscoveryMetadata);
}
}
}
}
public FindAsyncResult(FindRequestContext findRequestContext, DiscoveryEndpoint forwardingDiscoveryEndpoint, AsyncCallback callback, object state)
: base(callback, state)
{
// Store the context. Responses will be added to this context
this.findRequestContext = findRequestContext;
// Attach delegates which will handle the find responses
this.discoveryClient = new DiscoveryClient(forwardingDiscoveryEndpoint);
this.discoveryClient.FindProgressChanged += new EventHandler <FindProgressChangedEventArgs>(FindProgressChanged);
this.discoveryClient.FindCompleted += new EventHandler <FindCompletedEventArgs>(FindCompleted);
// Forward the Probe request message
this.discoveryClient.FindAsync(findRequestContext.Criteria);
}
void MatchFromOnlineService(FindRequestContext findRequestContext)
{
lock (this._onlineServices)
{
string foundId = findRequestContext.Criteria.Extensions.FirstOrDefault(x =>
x.Name.LocalName == "Id")?.Value;
if (foundId != null)
{
EndpointDiscoveryMetadata endpointMetadata = this._onlineServices[foundId];
if (!findRequestContext.Criteria.IsMatch(endpointMetadata))
{
return;
}
findRequestContext.AddMatchingEndpoint(endpointMetadata);
}
else
{
foreach (EndpointDiscoveryMetadata endpointMetadata in this._onlineServices.Values)
{
if (!findRequestContext.Criteria.IsMatch(endpointMetadata))
{
continue;
}
int countdown = findRequestContext.Criteria.Extensions.Count;
foreach (XElement elem in findRequestContext.Criteria.Extensions)
{
if (endpointMetadata.Extensions.All(x =>
x.Name.LocalName == elem.Name.LocalName && x.Value != elem.Value))
{
break;
}
countdown--;
}
if (countdown == 0)
{
findRequestContext.AddMatchingEndpoint(endpointMetadata);
}
}
}
}
}
/// <summary>
/// Encontra os serviços que conferem os requisitos inseridos
/// </summary>
/// <param name="findRequestContext"></param>
public void MatchFromOnlineService(FindRequestContext findRequestContext)
{
lock (this.onlineServices)
{
foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
{
if (findRequestContext.Criteria.IsMatch(endpointDiscoveryMetadata))
{
if (PrintDiscoveryMetadata != null)
{
PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Assigned", this.onlineServices.Count);
}
findRequestContext.AddMatchingEndpoint(endpointDiscoveryMetadata);
}
}
}
}
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
// Implements an OR matching that adds an endpoint if any of its scopes match any of the scopes in FindCriteria
if (findRequestContext.Criteria.ScopeMatchBy.Equals(customScopeMatchBy))
{
foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.publishedEndpoints)
{
bool endpointAdded = false;
foreach (Uri findCriteriaScope in findRequestContext.Criteria.Scopes)
{
if (endpointAdded)
{
break;
}
foreach (Uri serviceEndpointScope in endpointDiscoveryMetadata.Scopes)
{
if (serviceEndpointScope.Equals(findCriteriaScope))
{
findRequestContext.AddMatchingEndpoint(endpointDiscoveryMetadata);
endpointAdded = true;
break;
}
}
}
}
}
else
{
foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.publishedEndpoints)
{
if (findRequestContext.Criteria.IsMatch(endpointDiscoveryMetadata))
{
findRequestContext.AddMatchingEndpoint(endpointDiscoveryMetadata);
}
}
}
return(new FindAsyncResult(callback, state));
}
void Find(FindRequestContext context)
{
/*
* var oc = OperationContext.Current;
* var ch = oc.GetCallbackChannel<IClientChannel> ();
* Console.Error.WriteLine ("!!! {0} {1} {2} {3}", ch.Extensions.Count, ch.InputSession, ch.RemoteAddress, ch.GetType ());
*/
Console.Error.WriteLine("Find operation: " + context);
foreach (var edm in endpoints)
{
if (context.Criteria.IsMatch(edm))
{
Console.Error.WriteLine("Match: " + edm);
context.AddMatchingEndpoint(edm);
}
else
{
Console.Error.WriteLine("Mismatch.");
}
}
}
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, 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 (find_delegate == null)
{
find_delegate = new Action <FindRequestContext> (Find);
}
return(find_delegate.BeginInvoke(findRequestContext, callback, state));
default:
Find(findRequestContext);
var result = new TempAsyncResult(null, state);
if (callback != null)
{
callback(result);
}
return(result);
}
}
/// <summary>
/// Attempt to match a service with a service in the dictionary
/// </summary>
/// <param name="findRequestContext">The find request context.</param>
void MatchFromOnlineService(FindRequestContext findRequestContext)
{
EngineCache.Instance.MatchFromOnlineService(findRequestContext);
}
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
this.MatchFromOnlineService(findRequestContext);
return(new OnFindAsyncResult(callback, state));
}
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
return(response);
}
protected override IAsyncResult OnBeginFind(FindRequestContext findRequestContext, AsyncCallback callback, object state)
{
implementation.FindEndpoints(findRequestContext);
return(new SynchronousResult(callback, state));
}
