private void RemoveService(ServiceHost serviceHost, EndpointDiscoveryMetadata endpoint)
{
if (IsSelfDiscovery(serviceHost, endpoint) == false)
{
serviceCatalog.RemoveService(endpoint);
}
}
public override void RemoveEndpointMetadata(EndpointDiscoveryMetadata metadata)
{
var uri = metadata.Address.Uri.AbsoluteUri;
var addressJson = JsonConvert.SerializeObject(metadata.Address);
var contractTypeNames = metadata.GetContractTypeNames();
var bindingTypeName = metadata.GetBindingTypeName();
using (var conn = _connectionCreator.Invoke(_connectionString))
{
var cmd = conn.CreateCommand();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "UnRegisterServiceEndpointMetadata";
cmd.AddParameter("uri", uri)
.AddParameter("contractType", null)
.AddParameter("address", addressJson)
.AddParameter("bindingType", bindingTypeName);
conn.Open();
cmd.Transaction = conn.BeginTransaction();
foreach (var contractTypeName in contractTypeNames)
{
cmd.GetParameter("contractType").Value = contractTypeName;
cmd.ExecuteNonQuery();
}
cmd.Transaction.Commit();
}
}
protected override IAsyncResult OnBeginOfflineAnnouncement(
DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata,
AsyncCallback callback, object state)
{
implementation.RemoveEndpoint(endpointDiscoveryMetadata);
return new SynchronousResult(callback, state);
}
public virtual bool RegisterEndpoint(EndpointDiscoveryMetadata endpoint)
{
var registered = false;
if (AcceptEndpoint(endpoint))
{
using (var locker = @lock.ForReadingUpgradeable())
{
policies.ForEach(policy => registered = registered | policy.RegisterTarget(endpoint));
locker.Upgrade();
if (registered == false)
{
var newPolicies = policyFactory.CreatePolicies(endpoint);
Array.ForEach(newPolicies, newPolicy =>
{
registered = registered | newPolicy.RegisterTarget(endpoint);
policies.Add(newPolicy);
});
}
if (registered)
endpoints[endpoint.Address] = endpoint;
}
}
return registered;
}
protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
{
try
{
if (endpointDiscoveryMetadata == null)
{
throw new ArgumentNullException("endpointDiscoveryMetadata");
}
// We care only about ISimpleChatService services
FindCriteria criteria = new FindCriteria(typeof(ISimpleChatService));
if (criteria.IsMatch(endpointDiscoveryMetadata))
{
endpointDiscoveryMetadata.WriteLine("Removing");
Cache.Remove(endpointDiscoveryMetadata.Address.Uri);
}
}
catch (KeyNotFoundException)
{
// No problem if it does not exist in the cache
}
return new CompletedAsyncResult(callback, state);
}
public void AnnonceOnlineOfflineNoBinding ()
{
var ac = new AnnouncementClient (new AnnouncementEndpoint () { Address = new EndpointAddress ("http://localhost:37564")});
var edm = new EndpointDiscoveryMetadata ();
ac.AnnounceOnline (edm);
// attempt to close the client causes another CommunicationObjectFaultedException - looks like it fails to allow Close() at faulted state unlike other objects.
}
internal AnnouncementEventArgs(
DiscoveryMessageSequence messageSequence,
EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
this.MessageSequence = messageSequence;
this.EndpointDiscoveryMetadata = endpointDiscoveryMetadata;
}
private void PopulateUserList(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (!this.EndpointIsSelf(endpointDiscoveryMetadata.Address.Uri))
{
this.AddUser(new PeerUser(endpointDiscoveryMetadata.Address));
}
}
private void RegisterService(ServiceHost serviceHost, EndpointDiscoveryMetadata endpoint)
{
if (FilterService(serviceHost, endpoint) == false)
{
serviceCatalog.RegisterService(endpoint);
}
}
internal FindProgressChangedEventArgs(int progressPercentage, object userState,
EndpointDiscoveryMetadata endpointDiscoveryMetadata, DiscoveryMessageSequence messageSequence)
: base(progressPercentage, userState)
{
this.endpointDiscoveryMetadata = endpointDiscoveryMetadata;
this.messageSequence = messageSequence;
}
// OnBeginOnlineAnnouncement method is called when a Hello message is received by the Proxy
protected override IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence,
EndpointDiscoveryMetadata endpointDiscoveryMetadata,
AsyncCallback callback, object state)
{
_logger.Log("OnBeginOnlineAnnouncement()", LogLevel.Debug);
_provider.Add(endpointDiscoveryMetadata);
return new OnOnlineAnnouncementAsyncResult(callback, state);
}
// The following are helper methods required by the Proxy implementation
void AddOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
lock (this.onlineServices)
{
this.onlineServices[endpointDiscoveryMetadata.Address] = endpointDiscoveryMetadata;
}
}
public virtual void RegisterEndpoint(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (AcceptEndpoint(endpointDiscoveryMetadata))
{
endpoints.AddOrUpdate(endpointDiscoveryMetadata.Address, endpointDiscoveryMetadata,
(address, existing) => endpointDiscoveryMetadata);
}
}
//OfflineAnnouncement
protected override IAsyncResult OnBeginOfflineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
{
if (this.Endpoints.ContainsKey(endpointDiscoveryMetadata.Address))
{
this.Endpoints.Remove(endpointDiscoveryMetadata.Address);
}
return new DiscoveryAsyncResult(callback, state);
}
public virtual void RegisterService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (AcceptService(endpointDiscoveryMetadata))
{
services.AddOrUpdate(endpointDiscoveryMetadata.Address, endpointDiscoveryMetadata,
(address, existing) => endpointDiscoveryMetadata);
}
}
public void AddMatchingEndpoint(EndpointDiscoveryMetadata matchingEndpoint)
{
if (matchingEndpoint == null)
{
throw FxTrace.Exception.ArgumentNull("matchingEndpoint");
}
this.OnAddMatchingEndpoint(matchingEndpoint);
}
// The following are helper methods required by the Proxy implementation
public void AddOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
lock (_onlineServices)
{
_onlineServices[endpointDiscoveryMetadata.Address] = endpointDiscoveryMetadata;
}
// Replace with log4net
//PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Adding");
}
public MatchedEndpointDiscoveryMetadata(string addressJson, string bindingTypeName, string bindingJson, DateTime updatedOn)
{
_metadata = null;
_addressJson = addressJson;
_bindingTypeName = bindingTypeName;
_bindingJson = bindingJson;
_updatedOn = updatedOn;
}
public void Remove(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (endpointDiscoveryMetadata != null)
{
OnlineService tmp;
_onlineServices.TryRemove(endpointDiscoveryMetadata.Address, out tmp);
_logger.Log("Removing " + endpointDiscoveryMetadata.Address, LogLevel.Debug);
}
}
public void WillCreatePolicyPerScope()
{
var roundRobinFactory = new ScopeLoadBalancePolicyFactory<RoundRobinPolicy>();
var endpoint = new EndpointDiscoveryMetadata
{
Scopes = { new Uri("urn:scope:foo"), new Uri("urn:scope:bar") }
};
var policies = roundRobinFactory.CreatePolicies(endpoint);
Assert.AreEqual(2, policies.Length);
}
public static EndpointDiscoveryMetadata FromServiceEndpoint (ServiceEndpoint endpoint)
{
var ret = new EndpointDiscoveryMetadata ();
ret.ContractTypeNames.Add (new XmlQualifiedName (endpoint.Contract.Name, endpoint.Contract.Namespace));
ret.Address = endpoint.Address;
if (endpoint.Address != null)
ret.ListenUris.Add (endpoint.Address.Uri);
return ret;
}
public void WillCreatePolicyPerContract()
{
var roundRobinFactory = new ContractLoadBalancePolicyFactory<RoundRobinPolicy>();
var endpoint = new EndpointDiscoveryMetadata
{
ContractTypeNames = { new XmlQualifiedName("foo"), new XmlQualifiedName("bar") }
};
var policies = roundRobinFactory.CreatePolicies(endpoint);
Assert.AreEqual(2, policies.Length);
}
public void AnnonceOnlineOfflineNoEndpointAddress ()
{
var ac = new AnnouncementClient (new AnnouncementEndpoint () { Binding = new BasicHttpBinding () });
var edm = new EndpointDiscoveryMetadata ();
try {
ac.AnnounceOnline (edm);
} finally {
ac.Close ();
}
}
// looks like EndpointAddress is *ignored*
public void AnnonceOnlineOfflineAddressSchemeMismatch ()
{
var ac = new AnnouncementClient (new UdpAnnouncementEndpoint () { Address = new EndpointAddress ("http://localhost:37564")});
var edm = new EndpointDiscoveryMetadata ();
try {
ac.AnnounceOnline (edm);
ac.AnnounceOffline (edm);
} finally {
ac.Close ();
}
}
public void DefaultValues ()
{
var edm = new EndpointDiscoveryMetadata ();
Assert.IsNotNull (edm.Address, "#1");
Assert.AreEqual (EndpointAddress.AnonymousUri, edm.Address.Uri, "#1-2");
Assert.AreEqual (0, edm.Version, "#2");
Assert.IsNotNull (edm.ContractTypeNames, "#3");
Assert.IsNotNull (edm.Scopes, "#4");
Assert.IsNotNull (edm.ListenUris, "#5");
Assert.IsNotNull (edm.Extensions, "#6");
}
protected override IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, AsyncCallback callback, object state)
{
lock (this.onlineServices)
{
this.onlineServices[endpointDiscoveryMetadata.Address] =
endpointDiscoveryMetadata;
PrintTrace(endpointDiscoveryMetadata, "Adding");
}
return response;
}
public void RemoveOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (endpointDiscoveryMetadata != null)
{
lock (_onlineServices)
{
_onlineServices.Remove(endpointDiscoveryMetadata.Address);
}
// Replace with log4net
//PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Removing");
}
}
public void CanCreatePolicyFactory()
{
var roundRobinFactory = new ContractLoadBalancePolicyFactory<RoundRobinPolicy>();
var endpoint = new EndpointDiscoveryMetadata
{
ContractTypeNames = { new XmlQualifiedName("foo") }
};
var policies = roundRobinFactory.CreatePolicies(endpoint);
Assert.AreEqual(1, policies.Length);
Assert.IsInstanceOf<RoundRobinPolicy>(policies[0]);
Assert.IsNull(policies[0].ChooseTarget());
}
public void CanCreatePolicyFactory()
{
var roundRobinFactory = new ScopeLoadBalancePolicyFactory<RoundRobinPolicy>();
var endpoint = new EndpointDiscoveryMetadata
{
Scopes = { new Uri("urn:scope:foo") }
};
var policies = roundRobinFactory.CreatePolicies(endpoint);
Assert.AreEqual(1, policies.Length);
Assert.IsInstanceOf<RoundRobinPolicy>(policies[0]);
Assert.IsNull(policies[0].ChooseTarget());
}
private String[] GetAllowedClients(EndpointDiscoveryMetadata EndPoint)
{
String AllowedClients = null;
foreach (XElement item in EndPoint.Extensions)
try
{
AllowedClients = item.Element(CommuncationInfo.MetaDataIPAddresses).Value;
break;
}
catch { continue; }
return AllowedClients.ToUpper().Split(new String[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
}
static void AddContractTypeScopes(EndpointDiscoveryMetadata endpointDiscoveryMetadata, ServiceDescription serviceDescription)
{
foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints)
{
if (IsMetadataEndpoint(endpoint) || IsDiscoverySystemEndpoint(endpoint))
{
continue;
}
endpointDiscoveryMetadata.Scopes.Add(FindCriteria.GetContractTypeNameScope(
new XmlQualifiedName(endpoint.Contract.Name, endpoint.Contract.Namespace)));
}
}
public void AnnounceOnlineAsync(EndpointDiscoveryMetadata discoveryMetadata, object userState)
{
AsyncCallback cb = delegate(IAsyncResult result) {
try {
EndAnnounceOnline(result);
} catch (Exception ex) {
OnAnnounceOnlineCompleted(new AsyncCompletedEventArgs(ex, false, result.AsyncState));
} finally {
OnAnnounceOnlineCompleted(new AsyncCompletedEventArgs(null, false, result.AsyncState));
}
};
BeginAnnounceOnline(discoveryMetadata, cb, userState);
}
protected virtual IAsyncResult OnBeginOfflineAnnouncement(
DiscoveryMessageSequence messageSequence,
EndpointDiscoveryMetadata endpointDiscoveryMetadata,
AsyncCallback callback,
object state)
{
EventHandler <AnnouncementEventArgs> handler = this.OfflineAnnouncementReceived;
if (handler != null)
{
handler(this, new AnnouncementEventArgs(messageSequence, endpointDiscoveryMetadata));
}
return(new CompletedAsyncResult(callback, state));
}
List <ServiceEndpoint> GetApplicationEndpoints(ServiceDescription serviceDescription)
{
List <ServiceEndpoint> appEndpoints = new List <ServiceEndpoint>(serviceDescription.Endpoints.Count);
foreach (ServiceEndpoint endpoint in serviceDescription.Endpoints)
{
if (!EndpointDiscoveryMetadata.IsDiscoverySystemEndpoint(endpoint))
{
appEndpoints.Add(endpoint);
}
}
return(appEndpoints);
}
protected override void OnAddMatchingEndpoint(EndpointDiscoveryMetadata matchingEndpoint)
{
lock (this.probeDuplexAsyncResult.findCompletedLock)
{
if (this.probeDuplexAsyncResult.isFindCompleted)
{
throw FxTrace.Exception.AsError(
new InvalidOperationException(SR.DiscoveryCannotAddMatchingEndpoint));
}
else
{
this.matchingEndpoints.EnqueueAndDispatch(matchingEndpoint, null, false);
}
}
}
protected override void OnAddMatchingEndpoint(EndpointDiscoveryMetadata matchingEndpoint)
{
lock (this.probeRequestResponseAsyncResult.findCompletedLock)
{
if (this.probeRequestResponseAsyncResult.isFindCompleted)
{
throw FxTrace.Exception.AsError(
new InvalidOperationException(SR.DiscoveryCannotAddMatchingEndpoint));
}
else
{
this.matchingEndpoints.Add(matchingEndpoint);
}
}
}
public DiscoveryMessageSequence GetMessageSequence(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (endpointDiscoveryMetadata == null)
{
throw FxTrace.Exception.ArgumentNull("endpointDiscoveryMetadata");
}
DiscoveryMessageSequence messageSequence = null;
if (!this.messageSequenceTable.TryGetValue(endpointDiscoveryMetadata, out messageSequence))
{
throw FxTrace.Exception.Argument("endpointDiscoveryMetadata", SR2.DiscoveryFindResponseMessageSequenceNotFound);
}
return(messageSequence);
}
static bool MatchScopes(EndpointDiscoveryMetadata endpointDiscoveryMetadata, CompiledScopeCriteria[] compiledScopeMatchCriterias, Uri scopeMatchBy)
{
if (compiledScopeMatchCriterias == null)
{
if (scopeMatchBy != FindCriteria.ScopeMatchByNone)
{
return(true);
}
else
{
// the criteria matches any service with no scopes defined
return(endpointDiscoveryMetadata.Scopes.Count == 0);
}
}
if (scopeMatchBy == FindCriteria.ScopeMatchByNone)
{
// if scopeMatchBy is None, the Probe shouldn't have any Scopes defined
return(false);
}
string[] compiledScopes;
if (endpointDiscoveryMetadata.IsOpen)
{
compiledScopes = endpointDiscoveryMetadata.CompiledScopes;
}
else
{
compiledScopes = ScopeCompiler.Compile(endpointDiscoveryMetadata.Scopes);
}
if (compiledScopes == null)
{
// non-zero scopes in the criteria, but zero scopes in the metadata
return(false);
}
for (int i = 0; i < compiledScopeMatchCriterias.Length; i++)
{
if (!ScopeCompiler.IsMatch(compiledScopeMatchCriterias[i], compiledScopes))
{
return(false);
}
}
return(true);
}
static void SetDiscoveryImplementation(ServiceHostBase host, DiscoveryService discoveryService)
{
foreach (ChannelDispatcherBase channelDispatcherBase in host.ChannelDispatchers)
{
ChannelDispatcher channelDispatcher = channelDispatcherBase as ChannelDispatcher;
if (channelDispatcher != null)
{
foreach (EndpointDispatcher endpointDispatcher in channelDispatcher.Endpoints)
{
if ((endpointDispatcher != null) && EndpointDiscoveryMetadata.IsDiscoverySystemEndpoint(endpointDispatcher))
{
SetDiscoveryImplementation(endpointDispatcher, discoveryService);
}
}
}
}
}
//-----------------------------------------------------
// Online Announcements
//-----------------------------------------------------
#region OnlineAnnouncement
/// <summary>
/// Handles an online announcement message.
/// </summary>
/// <param name="messageSequence">The discovery message sequence.</param>
/// <param name="endpointDiscoveryMetadata">The endpoint discovery metadata.</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 OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence,
EndpointDiscoveryMetadata endpointDiscoveryMetadata,
AsyncCallback callback, object state)
{
var tcs = new TaskCompletionSource <object>(state);
// Start a background task that will process anounncement
Task.Factory.StartNew(() =>
{
// Create and executy all Online announcement tasks
var tasks = _onlineTaskFactories.AsParallel()
.Select((factory) => { return(factory.Create(new DiscoveryMessageSequence[] { messageSequence },
new EndpointDiscoveryMetadata[] { endpointDiscoveryMetadata })); })
.ToArray();
// TODO: Decide if we want to wait for completion of all tasks
// Task.WaitAll(tasks);
tcs.SetResult(null);
callback(tcs.Task);
});
return(tcs.Task);
}
static bool MatchTypes(EndpointDiscoveryMetadata endpointDiscoveryMetadata, Collection <XmlQualifiedName> contractTypeNames)
{
if ((contractTypeNames == null) || (contractTypeNames.Count == 0))
{
return(true);
}
if ((endpointDiscoveryMetadata.InternalContractTypeNames == null) ||
(endpointDiscoveryMetadata.InternalContractTypeNames.Count == 0))
{
return(false);
}
foreach (XmlQualifiedName contractTypeName in contractTypeNames)
{
if (!endpointDiscoveryMetadata.InternalContractTypeNames.Contains(contractTypeName))
{
return(false);
}
}
return(true);
}
void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
{
// It is applied to the ServiceEndpoints in the ServiceHost which has ServiceDiscoveryBehavior as one of its service behaviors.
// That is, this target endpoint is an endpoint in the target service itself, not for "announcement service".
if (endpoint == null)
{
throw new ArgumentNullException("endpoint");
}
if (endpointDispatcher == null)
{
throw new ArgumentNullException("endpointDispatcher");
}
var edb = endpoint.Behaviors.Find <EndpointDiscoveryBehavior> ();
if (edb != null && !edb.Enabled)
{
return;
}
var edm = EndpointDiscoveryMetadata.FromServiceEndpoint(endpoint);
extension.PublishedInternalEndpoints.Add(edm);
}
internal FindProgressChangedEventArgs(EndpointDiscoveryMetadata metadata, DiscoveryMessageSequence sequence, int progressPercentage, object userState)
: base(progressPercentage, userState)
{
EndpointDiscoveryMetadata = metadata;
MessageSequence = sequence;
}
public TChannel BuildChannel(TimeSpan timeout)
{
TimeoutHelper timeoutHelper = new TimeoutHelper(timeout);
this.InitializeAndFindAsync();
TChannel innerChannel = null;
bool completed = false;
EndpointDiscoveryMetadata currentEndpointDiscoveryMetadata = null;
try
{
do
{
try
{
currentEndpointDiscoveryMetadata = this.discoveredEndpoints.Dequeue(timeoutHelper.RemainingTime());
}
catch (TimeoutException te)
{
throw FxTrace.Exception.AsError(new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(timeoutHelper.OriginalTimeout), te));
}
if (currentEndpointDiscoveryMetadata == null)
{
if (this.totalDiscoveredEndpoints < 1)
{
throw FxTrace.Exception.AsError(new EndpointNotFoundException(SR.DiscoveryClientChannelEndpointNotFound, this.exception));
}
else
{
throw FxTrace.Exception.AsError(new EndpointNotFoundException(SR.DiscoveryClientChannelCreationFailed(this.totalDiscoveredEndpoints), this.exception));
}
}
if (timeoutHelper.RemainingTime() == TimeSpan.Zero)
{
throw FxTrace.Exception.AsError(new TimeoutException(SR.DiscoveryClientChannelOpenTimeout(timeoutHelper.OriginalTimeout)));
}
if (currentEndpointDiscoveryMetadata.ListenUris.Count == 0)
{
completed = this.CreateChannel(
ref innerChannel,
currentEndpointDiscoveryMetadata.Address,
currentEndpointDiscoveryMetadata.Address.Uri,
timeoutHelper);
}
else
{
foreach (Uri listenUri in currentEndpointDiscoveryMetadata.ListenUris)
{
completed = this.CreateChannel(
ref innerChannel,
currentEndpointDiscoveryMetadata.Address,
listenUri,
timeoutHelper);
if (completed)
{
break;
}
}
}
}while (!completed);
}
finally
{
if (completed && TD.InnerChannelOpenSucceededIsEnabled())
{
TD.InnerChannelOpenSucceeded(
currentEndpointDiscoveryMetadata.Address.ToString(),
GetVia(innerChannel).ToString());
}
this.Cleanup(timeoutHelper.RemainingTime());
}
return(innerChannel);
}
protected abstract IAsyncResult BeginSendProxyAnnouncement(
TResponseChannel responseChannel,
DiscoveryMessageSequence discoveryMessageSequence,
EndpointDiscoveryMetadata proxyEndpointDiscoveryMetadata,
AsyncCallback callback,
object state);
protected abstract IAsyncResult BeginSendResolveResponse(
TResponseChannel responseChannel,
DiscoveryMessageSequence discoveryMessageSequence,
EndpointDiscoveryMetadata matchingEndpoint,
AsyncCallback callback,
object state);
public DiscoveryMessageSequence GetMessageSequence(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
throw new NotImplementedException();
}
internal bool IsMatch(EndpointDiscoveryMetadata endpointDiscoveryMetadata, CompiledScopeCriteria[] compiledScopeMatchCriterias)
{
return(MatchTypes(endpointDiscoveryMetadata, this.contractTypeNames) &&
MatchScopes(endpointDiscoveryMetadata, compiledScopeMatchCriterias, this.scopeMatchBy));
}
protected abstract IAsyncResult OnBeginOfflineAnnouncement(
DiscoveryMessageSequence messageSequence,
EndpointDiscoveryMetadata endpointDiscoveryMetadata,
AsyncCallback callback,
object state);
public void AnnounceOnline(EndpointDiscoveryMetadata discoveryMetadata)
{
EndAnnounceOnline(BeginAnnounceOnline(discoveryMetadata, null, null));
}
public bool IsMatch(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
var edm = endpointDiscoveryMetadata;
if (edm == null)
{
throw new ArgumentNullException("endpointDiscoveryMetadata");
}
if (ContractTypeNames.Count > 0)
{
bool match = false;
foreach (var qn in ContractTypeNames)
{
if (edm.ContractTypeNames.Contains(qn))
{
match = true;
}
}
if (!match)
{
return(false);
}
}
if (Scopes.Count > 0)
{
bool match = false;
foreach (var scope in Scopes)
{
if (ScopeMatchBy == null || ScopeMatchBy.Equals(ScopeMatchByPrefix))
{
if (edm.Scopes.Contains(scope))
{
match = true;
}
}
else if (ScopeMatchBy.Equals(ScopeMatchByExact))
{
if (edm.Scopes.Any(s => s.AbsoluteUri == scope.AbsoluteUri))
{
match = true;
}
}
else if (ScopeMatchBy.Equals(ScopeMatchByUuid))
{
throw new NotImplementedException();
}
else if (ScopeMatchBy.Equals(ScopeMatchByNone))
{
throw new NotImplementedException();
}
else if (ScopeMatchBy.Equals(ScopeMatchByLdap))
{
throw new NotImplementedException();
}
else
{
throw new InvalidOperationException(String.Format("Unexpected ScopeMatchBy value: {0}", ScopeMatchBy));
}
}
if (!match)
{
return(false);
}
}
if (Extensions.Count > 0)
{
throw new NotImplementedException(String.Format("{0} extensions are found", Extensions.Count));
}
return(true);
}
protected virtual IAsyncResult OnBeginOnlineAnnouncement(DiscoveryMessageSequence messageSequence, EndpointDiscoveryMetadata endpointDiscoveryMetadata, 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 (online == null)
{
online = new Action <object, AnnouncementEventArgs> (OnlineAnnouncementReceived ?? delegate {});
}
return(online.BeginInvoke(this, new AnnouncementEventArgs(endpointDiscoveryMetadata, messageSequence), callback, state));
default:
if (OnlineAnnouncementReceived != null)
{
OnlineAnnouncementReceived(this, new AnnouncementEventArgs(endpointDiscoveryMetadata, messageSequence));
}
var result = new TempAsyncResult(null, state);
if (callback != null)
{
callback(result);
}
return(result);
}
}
internal ResolveResponse(EndpointDiscoveryMetadata metadata, DiscoveryMessageSequence sequence)
{
EndpointDiscoveryMetadata = metadata;
MessageSequence = sequence;
}
public void AnnounceOfflineAsync(EndpointDiscoveryMetadata discoveryMetadata)
{
AnnounceOfflineAsync(discoveryMetadata, null);
}
protected virtual void OnAddMatchingEndpoint(EndpointDiscoveryMetadata matchingEndpoint)
{
}
protected abstract TResponseMessage GetResolveResponse(
DiscoveryMessageSequence discoveryMessageSequence,
EndpointDiscoveryMetadata matchingEndpoints);
internal void AddDiscoveredEndpoint(EndpointDiscoveryMetadata endpointDiscoveryMetadata,
DiscoveryMessageSequence messageSequence)
{
this.messageSequenceTable.Add(endpointDiscoveryMetadata, messageSequence);
this.endpoints.Add(endpointDiscoveryMetadata);
}
/// <summary>
/// Handles Offline announcements.
/// </summary>
/// <param name="messageSequence">The array discovery message sequence.</param>
/// <param name="endpointDiscoveryMetadata">The array of endpoint discovery metadata.</param>
protected abstract void OnOfflineAnnouncement(DiscoveryMessageSequence messageSequence,
EndpointDiscoveryMetadata endpointDiscoveryMetadata);
public Task AnnounceOfflineTaskAsync(EndpointDiscoveryMetadata discoveryMetadata)
{
return(Task.Factory.FromAsync <EndpointDiscoveryMetadata>(this.BeginAnnounceOffline, this.EndAnnounceOffline, discoveryMetadata, /* state */ null));
}
internal AnnouncementEventArgs(EndpointDiscoveryMetadata metadata, DiscoveryMessageSequence queue)
{
EndpointDiscoveryMetadata = metadata;
MessageSequence = queue;
}
