public void ResolveOperation(ResolveCriteria resolveCriteria)
{
ResolveMessageCD1 request = new ResolveMessageCD1();
request.Resolve = ResolveCriteriaCD1.FromResolveCriteria(resolveCriteria);
this.duplexInnerClient.ResolveOperation(request);
}
public void ResolveOperation(ResolveCriteria resolveCriteria)
{
ResolveMessageApril2005 request = new ResolveMessageApril2005();
request.Resolve = ResolveCriteriaApril2005.FromResolveCriteria(resolveCriteria);
this.duplexInnerClient.ResolveOperation(request);
}
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));
}
public IAsyncResult BeginResolveOperation(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
{
ResolveMessageCD1 request = new ResolveMessageCD1();
request.Resolve = ResolveCriteriaCD1.FromResolveCriteria(resolveCriteria);
return(this.duplexInnerClient.BeginResolveOperation(request, callback, state));
}
public ResolveResponse Resolve(ResolveCriteria criteria)
{
var req = new MessageContractsCD1.ResolveRequest()
{
Body = new ResolveCriteriaCD1(criteria)
};
Channel.BeginResolve(req, delegate(IAsyncResult result) {
Channel.EndResolve(result);
}, null);
var timeout = InnerChannel.OperationTimeout < criteria.Duration ? InnerChannel.OperationTimeout : criteria.Duration;
if (!reply_find_handle.WaitOne(timeout))
{
throw new TimeoutException();
}
try {
var ir = resolve_completed();
var metadata = ir.Body.ToEndpointDiscoveryMetadata();
var sequence = ir.MessageSequence.ToDiscoveryMessageSequence();
return(new ResolveResponse(metadata, sequence));
} finally {
resolve_completed = null;
}
}
EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria)
{
EndpointDiscoveryMetadata matchingEndpoint = null;
lock (this._onlineServices)
{
foreach (EndpointDiscoveryMetadata endpointMetadata in this._onlineServices.Values)
{
EndpointAddress address;
// Check to see if the endpoint has a listenUri and if it differs from the Address URI
if (endpointMetadata.ListenUris.Count == 0 ||
endpointMetadata.Address.Uri == endpointMetadata.ListenUris[0])
{
address = endpointMetadata.Address;
}
else
{
address = new EndpointAddress(endpointMetadata.ListenUris[0]);
}
if (criteria.Address != address)
{
continue;
}
matchingEndpoint = endpointMetadata;
break;
}
}
return(matchingEndpoint);
}
//-----------------------------------------------------
// Interface Implementations
//-----------------------------------------------------
#region IResolveTaskFactory Members
/// <summary>
/// Creates a Task that processes Resolve request
/// </summary>
/// <param name="findRequestContext">Criteria for finding correct endpoints</param>
/// <returns>Returns <see cref="Task<EndpointDiscoveryMetadata>"/> object which encapsulates request handler</returns>
Task <Collection <EndpointDiscoveryMetadata> > IResolveTaskFactory.Create(ResolveCriteria resolveCriteria)
{
if (!_dictionary.ContainsKey(resolveCriteria.Address))
{
var source = new TaskCompletionSource <Collection <EndpointDiscoveryMetadata> >();
source.SetResult(new Collection <EndpointDiscoveryMetadata>());
return(source.Task);
}
// Create Task containing Rx LINQ query
return(_dictionary[resolveCriteria.Address].ToObservable() // As Observable
.ObserveOn(Scheduler.NewThread) // Asynchronously
.TakeUntil(Observable.Return((EndpointDiscoveryMetadata)null) // Take until...
.Delay(resolveCriteria.Duration)) // ...until timeout
.Where(endpoint =>
{
return _extensionsPredicate(endpoint.Extensions, // Match extensions
resolveCriteria.Extensions);
})
.Take(1) // TODO: Findout if more than one required
.Aggregate(new Collection <EndpointDiscoveryMetadata>(),
(context, endpoint) =>
{
context.Add(endpoint); // Add matching endpoints
return context;
})
.ToTask());
}
public static ResolveCriteriaCD1 FromResolveCriteria(ResolveCriteria resolveCriteria)
{
if (resolveCriteria == null)
{
throw FxTrace.Exception.ArgumentNull("resolveCriteria");
}
return(new ResolveCriteriaCD1(resolveCriteria));
}
public IAsyncResult BeginResolve(ResolveCriteria criteria, AsyncCallback callback, object state)
{
if (resolve_delegate == null)
{
resolve_delegate = new Func <ResolveCriteria, ResolveResponse> (Resolve);
}
return(resolve_delegate.BeginInvoke(criteria, callback, state));
}
public static ResolveCriteriaApril2005 FromResolveCriteria(ResolveCriteria resolveCriteria)
{
if (resolveCriteria == null)
{
throw FxTrace.Exception.ArgumentNull("resolveCriteria");
}
return new ResolveCriteriaApril2005(resolveCriteria);
}
public IAsyncResult BeginResolveOperation(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
{
ResolveMessage11 request = new ResolveMessage11();
request.Resolve = ResolveCriteria11.FromResolveCriteria(resolveCriteria);
return(base.Channel.BeginResolveOperation(request, callback, state));
}
public IAsyncResult BeginResolve(ResolveCriteria criteria, AsyncCallback callback, object state)
{
var req = new MessageContractsApril2005.ResolveRequest()
{
Body = new ResolveCriteriaApril2005(criteria)
};
return(Channel.BeginResolve(req, callback, state));
}
public virtual EndpointDiscoveryMetadata ResolveEndpoint(ResolveCriteria resolveCriteria)
{
using (@lock.ForReading())
{
EndpointDiscoveryMetadata endpoint;
return(endpoints.TryGetValue(resolveCriteria.Address, out endpoint)
? endpoint
: null);
}
}
//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 ResolveService(ResolveCriteria resolveCriteria)
{
foreach (var metadata in services.Values)
{
if (resolveCriteria.Address == metadata.Address)
{
return(metadata);
}
}
return(null);
}
/// <summary>
/// Matches from online service.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns>EndpointDiscoveryMetadata.</returns>
internal EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria)
{
EndpointDiscoveryMetadata matchingEndpoint = null;
foreach (EndpointDiscoveryMetadata metadata in
_onlineServices.Values.Where(x => criteria.Address == x.Address))
{
matchingEndpoint = 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);
}
/// <summary>
/// Queries the proxy for a service
/// </summary>
/// <exception cref="NullReferenceException"></exception>
/// <exception cref="System.Reflection.TargetInvocationException"></exception>
/// <param name="serviceUri"></param>
/// <returns></returns>
public static EndpointDiscoveryMetadata Probe(Uri serviceUri)
{
var svcSearch = new ResolveCriteria(new EndpointAddress(serviceUri));
ResolveResponse searchResponse;
lock (ProbeClient)
{
searchResponse = ProbeClient.Resolve(svcSearch);
}
return(searchResponse.EndpointDiscoveryMetadata);
}
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));
}
EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria)
{
EndpointDiscoveryMetadata matchingEndpoint = null;
lock (this.onlineServices)
{
foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
{
if (criteria.Address == endpointDiscoveryMetadata.Address)
{
matchingEndpoint = endpointDiscoveryMetadata;
}
}
}
return(matchingEndpoint);
}
public void ResolveOperation(ResolveCriteria resolveCriteria)
{
ResolveMessageCD1 request = new ResolveMessageCD1();
request.Resolve = ResolveCriteriaCD1.FromResolveCriteria(resolveCriteria);
ResolveMatchesMessageCD1 response = base.Channel.ResolveOperation(request);
if ((response != null) && (response.ResolveMatches != null) && (response.ResolveMatches.ResolveMatch != null))
{
this.responseReceiver.ResolveMatchOperation(
OperationContext.Current.IncomingMessageHeaders.RelatesTo,
DiscoveryUtility.ToDiscoveryMessageSequenceOrNull(response.MessageSequence),
response.ResolveMatches.ResolveMatch.ToEndpointDiscoveryMetadata());
}
else
{
this.responseReceiver.PostResolveCompletedAndRemove(OperationContext.Current.IncomingMessageHeaders.RelatesTo, false, null);
}
}
/// <summary>
/// Encontra os serviços que conferem os requisitos inseridos
/// </summary>
/// <param name="criteria"></param>
/// <returns></returns>
public EndpointDiscoveryMetadata MatchFromOnlineService(ResolveCriteria criteria)
{
lock (this.onlineServices)
{
foreach (EndpointDiscoveryMetadata endpointDiscoveryMetadata in this.onlineServices.Values)
{
if (criteria.Address == endpointDiscoveryMetadata.Address)
{
if (PrintDiscoveryMetadata != null)
{
PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Assigned", this.onlineServices.Count);
}
return(endpointDiscoveryMetadata);
}
}
}
return(null);
}
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(new OnResolveAsyncResult(this.MatchFromOnlineService(resolveCriteria), callback, state));
}
ResolveCriteria11(ResolveCriteria resolveCriteria)
{
this.resolveCriteria = resolveCriteria;
}
internal ResolveCriteriaCD1(ResolveCriteria source)
{
this.source = source;
}
public static ResolveCriteriaCD1 FromResolveCriteria (ResolveCriteria resolveCriteria)
{
return new ResolveCriteriaCD1 (resolveCriteria);
}
ResolveCriteria11()
{
this.resolveCriteria = new ResolveCriteria();
}
public static ResolveCriteriaCD1 FromResolveCriteria(ResolveCriteria resolveCriteria)
{
return(new ResolveCriteriaCD1(resolveCriteria));
}
ResolveCriteriaCD1()
{
this.resolveCriteria = new ResolveCriteria();
}
protected override IAsyncResult OnBeginResolve(ResolveCriteria resolveCriteria, AsyncCallback callback, object state)
{
return(response);
}
ResolveCriteriaApril2005()
{
this.resolveCriteria = new ResolveCriteria();
}
public void ReadXml (XmlReader reader)
{
source = ResolveCriteria.ReadXml (reader, version);
}
internal ResolveCriteriaApril2005 (ResolveCriteria source)
{
this.source = source;
}
/// <summary>
/// Override this method to handle 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(new CompletedAsyncResult(callback, state));
}
internal ResolveCriteriaCD1 (ResolveCriteria source)
{
this.source = source;
}
public static ResolveCriteria11 FromResolveCriteria (ResolveCriteria resolveCriteria)
{
throw new NotImplementedException ();
}
ResolveCriteriaApril2005(ResolveCriteria resolveCriteria)
{
this.resolveCriteria = resolveCriteria;
}
public void ReadXml(XmlReader reader)
{
source = ResolveCriteria.ReadXml(reader, version);
}
public static ResolveCriteriaApril2005 FromResolveCriteria (ResolveCriteria resolveCriteria)
{
return new ResolveCriteriaApril2005 (resolveCriteria);
}
ResolveCriteriaCD1(ResolveCriteria resolveCriteria)
{
this.resolveCriteria = resolveCriteria;
}
