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; }