public void TryUpdateWithContactedEndpoint() { var endpoint = new EndpointId("a"); var connection = new EndpointInformation( new EndpointId("a"), new DiscoveryInformation(new Uri("http://localhost/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://localhost/protocol/invalid"))); var storage = new EndpointInformationStorage(); Assert.IsTrue(storage.TryAdd(endpoint, connection)); var newConnection = new EndpointInformation( endpoint, new DiscoveryInformation(new Uri("http://other/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://other/protocol/invalid"))); Assert.IsTrue(storage.TryUpdate(newConnection)); EndpointInformation storedConnection; storage.TryGetConnectionFor(endpoint, out storedConnection); Assert.AreSame(newConnection, storedConnection); }
public bool TryCompleteApproval(EndpointId endpoint) { if (endpoint != null) { EndpointInformation info = null; lock (m_Lock) { if (!m_ContactedEndpoints.ContainsKey(endpoint) && m_EndpointsWaitingForApproval.ContainsKey(endpoint) && !m_ApprovedEndpoints.ContainsKey(endpoint)) { var pair = m_EndpointsWaitingForApproval[endpoint]; m_EndpointsWaitingForApproval.Remove(endpoint); m_ApprovedEndpoints.Add(endpoint, pair.Item1); info = pair.Item1; } } if (info != null) { RaiseOnEndpointConnected(info); return(true); } } return(false); }
public void TryAddWithExistingEndpoint() { var storage = new EndpointInformationStorage(); var endpoint = new EndpointId("a"); var connection = new EndpointInformation( new EndpointId("a"), new DiscoveryInformation(new Uri("http://localhost/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://localhost/protocol/invalid"))); Assert.IsTrue(storage.TryAdd(endpoint, connection)); Assert.IsFalse(storage.CanCommunicateWithEndpoint(endpoint)); Assert.IsTrue(storage.HasBeenContacted(endpoint)); Assert.IsFalse(storage.IsWaitingForApproval(endpoint)); var newConnection = new EndpointInformation( endpoint, new DiscoveryInformation(new Uri("http://other/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://other/protocol/invalid"))); Assert.IsFalse(storage.TryAdd(endpoint, newConnection)); EndpointInformation otherConnection; var result = storage.TryGetConnectionFor(endpoint, out otherConnection); Assert.IsTrue(result); Assert.AreSame(connection, otherConnection); }
public void TryApprove() { var endpoint = new EndpointId("a"); var connection = new EndpointInformation( new EndpointId("a"), new DiscoveryInformation(new Uri("http://localhost/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://localhost/protocol/invalid"))); var description = new ProtocolDescription(new List <CommunicationSubject>()); var storage = new EndpointInformationStorage(); var wasApproved = false; storage.OnEndpointConnected += (s, e) => { wasApproved = true; Assert.AreSame(connection.Id, e.Endpoint); }; Assert.IsTrue(storage.TryAdd(endpoint, connection)); Assert.IsFalse(storage.CanCommunicateWithEndpoint(endpoint)); Assert.IsTrue(storage.HasBeenContacted(endpoint)); Assert.IsFalse(storage.IsWaitingForApproval(endpoint)); Assert.IsTrue(storage.TryStartApproval(endpoint, description)); Assert.IsTrue(storage.TryCompleteApproval(endpoint)); Assert.IsTrue(storage.CanCommunicateWithEndpoint(endpoint)); Assert.IsFalse(storage.HasBeenContacted(endpoint)); Assert.IsFalse(storage.IsWaitingForApproval(endpoint)); Assert.IsTrue(wasApproved); }
public bool TryUpdate(EndpointInformation connectionInformation) { if (connectionInformation != null) { lock (m_Lock) { if (m_ContactedEndpoints.ContainsKey(connectionInformation.Id)) { m_ContactedEndpoints[connectionInformation.Id] = connectionInformation; return(true); } if (m_EndpointsWaitingForApproval.ContainsKey(connectionInformation.Id)) { var tuple = m_EndpointsWaitingForApproval[connectionInformation.Id]; m_EndpointsWaitingForApproval.Remove(connectionInformation.Id); m_EndpointsWaitingForApproval.Add( connectionInformation.Id, new Tuple <EndpointInformation, ProtocolDescription>(connectionInformation, tuple.Item2)); return(true); } } } return(false); }
public virtual IActionResult PostCreateEndpointForClient( [FromRoute] Guid clientUid, [FromBody] EndpointInformation endpoint) { if (clientUid == Guid.Empty) { return(StatusCode((int)HttpStatusCode.BadRequest)); } if (!EndpointManager.IsUrlPartAvailable(endpoint.UrlPart)) { return(StatusCode((int)HttpStatusCode.BadRequest, "{\"error\":\"URL Part already in use\"}")); } if (endpoint.Uid == Guid.Empty) { endpoint.Uid = Guid.NewGuid(); } // create this endpoint and register to this client EndpointManager.AddOrUpdate( endpoint.Uid, endpoint.ChannelType, endpoint.UrlPart, clientUid); return(StatusCode((int)HttpStatusCode.Created, endpoint)); }
/// <summary> /// Returns the connection information for the given endpoint. /// </summary> /// <param name="endpoint">The ID of the endpoint.</param> /// <param name="information">The connection information for the endpoint.</param> /// <returns> /// <see langword="true" /> if the information for the endpoint was retrieved successfully; otherwise, <see langword="false" />. /// </returns> public bool TryGetConnectionFor(EndpointId endpoint, out EndpointInformation information) { information = null; if (endpoint != null) { lock (m_Lock) { if (m_ApprovedEndpoints.ContainsKey(endpoint)) { information = m_ApprovedEndpoints[endpoint]; return(true); } if (m_EndpointsWaitingForApproval.ContainsKey(endpoint)) { information = m_EndpointsWaitingForApproval[endpoint].Item1; return(true); } if (m_ContactedEndpoints.ContainsKey(endpoint)) { information = m_ContactedEndpoints[endpoint]; return(true); } } } return(false); }
private void OnServerDiscovered(MulticastClient sender, EndpointInformation args) { _ = CoreApplication.MainView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { MessagesListBox.Items.Add($"Discovered {args.Name} at {args.Address}"); }); }
private Dictionary <Type, ServiceHostInfo> FindAllHosts() { var hosts = new Dictionary <Type, ServiceHostInfo>(); foreach (Type type in TypeLocator.FindTypes(_dllSearchPattern, typeof(IServiceHost))) { ServiceHostInfo info = new ServiceHostInfo(); Type interfaceType = (Type)type.GetMethod("GetInterfaceType", BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy).Invoke(null, null); info.InterfaceType = interfaceType; info.Logger = _logger; info.Host = new ServiceHost(type); info.Host.Description.Behaviors.Add(new HostErrorHandlerBehavior(info)); info.Host.Authorization.ServiceAuthorizationManager = new RoleBasedAuthorizationManager(); ContractDescription contract = ContractDescription.GetContract(interfaceType); EndpointAddress endpoint = EndpointInformation.BuildEndpoint(new EndpointInformation(), ServerConnectionInformation.Instance, interfaceType); Binding binding = BindingInformation.BuildBinding(new BindingInformation(), ServerConnectionInformation.Instance); ServiceEndpoint service = new ServiceEndpoint(contract, binding, endpoint); info.Host.AddServiceEndpoint(service); hosts.Add(interfaceType, info); } return(hosts); }
/// <summary> /// Initiates the handshake process between the current endpoint and the specified endpoint. /// </summary> /// <param name="information">The connection information for the endpoint.</param> private void InitiateHandshakeWith(EndpointInformation information) { var template = information.ProtocolInformation.MessageAddress.ToChannelTemplate(); var connectionInfo = m_Layer.LocalConnectionFor(information.ProtocolInformation.Version, template); if (connectionInfo != null) { lock (m_Lock) { Debug.Assert(m_EndpointApprovalState.ContainsKey(information.Id), "The endpoint tick list is not stored."); var tickList = m_EndpointApprovalState[information.Id]; if (!tickList.HaveSendConnect && !m_PotentialEndpoints.CanCommunicateWithEndpoint(information.Id)) { tickList.HaveSendConnect = true; var message = new EndpointConnectMessage( m_Layer.Id, new DiscoveryInformation(m_DiscoveryChannel.EntryChannel(template)), new ProtocolInformation( information.ProtocolInformation.Version, connectionInfo.Item2, connectionInfo.Item3), m_Descriptions.ToStorage()); var task = m_Layer.SendMessageToUnregisteredEndpointAndWaitForResponse( information, message, CommunicationConstants.DefaultMaximuNumberOfRetriesForMessageSending, m_SendTimeout); task.ContinueWith(HandleResponseToConnectMessage, TaskContinuationOptions.ExecuteSynchronously); } } } }
/// <summary> /// Sends the given message to the specified endpoint and returns a task that /// will eventually contain the return message. /// </summary> /// <param name="connection">The connection information for the endpoint to which the message has to be send.</param> /// <param name="message">The message that has to be send.</param> /// <param name="maximumNumberOfRetries"> /// The maximum number of times the endpoint will try to send the message if delivery fails. /// </param> /// <param name="timeout">The maximum amount of time the response operation is allowed to take.</param> /// <returns>A task object that will eventually contain the response message.</returns> public Task <ICommunicationMessage> SendMessageToUnregisteredEndpointAndWaitForResponse( EndpointInformation connection, ICommunicationMessage message, int maximumNumberOfRetries, TimeSpan timeout) { { Lokad.Enforce.Argument(() => connection); Lokad.Enforce.Argument(() => message); } using (m_Diagnostics.Profiler.Measure(CommunicationConstants.TimingGroup, "ProtocolLayer: sending message and waiting for response")) { var pair = ChannelPairFor(connection); var result = pair.Item2.ForwardResponse(connection.Id, message.Id, timeout); m_Diagnostics.Log( LevelToLog.Trace, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Sending msg of type {0} to endpoint ({1}) while waiting for the response.", message.GetType(), connection)); pair.Item1.Send(connection.ProtocolInformation, message, maximumNumberOfRetries); RaiseOnConfirmChannelIntegrity(connection.Id); return(result); } }
/// <summary> /// Sends the given message to the specified endpoint. /// </summary> /// <param name="connection">The connection information for the endpoint to which the message has to be send.</param> /// <param name="message">The message that has to be send.</param> /// <param name="maximumNumberOfRetries">The maximum number of times the endpoint will try to send the message if delivery fails.</param> /// <exception cref="FailedToSendMessageException"> /// Thrown when the channel fails to deliver the message to the remote endpoint. /// </exception> public void SendMessageToUnregisteredEndpoint(EndpointInformation connection, ICommunicationMessage message, int maximumNumberOfRetries) { { Lokad.Enforce.Argument(() => connection); Lokad.Enforce.Argument(() => message); } using (m_Diagnostics.Profiler.Measure( CommunicationConstants.TimingGroup, "ProtocolLayer: sending message without waiting for response")) { var channel = ChannelFor(connection); m_Diagnostics.Log( LevelToLog.Trace, CommunicationConstants.DefaultLogTextPrefix, string.Format( CultureInfo.InvariantCulture, "Sending msg of type {0} to endpoint ({1}) without waiting for the response.", message.GetType(), connection.Id)); channel.Send(connection.ProtocolInformation, message, maximumNumberOfRetries); RaiseOnConfirmChannelIntegrity(connection.Id); } }
public void TryRemoveWithApprovedEndpoint() { var storage = new EndpointInformationStorage(); var endpoint = new EndpointId("a"); var connection = new EndpointInformation( new EndpointId("a"), new DiscoveryInformation(new Uri("http://localhost/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://localhost/protocol/invalid"))); Assert.IsTrue(storage.TryAdd(endpoint, connection)); Assert.IsFalse(storage.CanCommunicateWithEndpoint(endpoint)); Assert.IsTrue(storage.HasBeenContacted(endpoint)); Assert.IsFalse(storage.IsWaitingForApproval(endpoint)); var description = new ProtocolDescription(new List <CommunicationSubject>()); Assert.IsTrue(storage.TryStartApproval(endpoint, description)); Assert.IsTrue(storage.TryCompleteApproval(endpoint)); Assert.IsTrue(storage.CanCommunicateWithEndpoint(endpoint)); Assert.IsFalse(storage.IsWaitingForApproval(endpoint)); Assert.IsTrue(storage.TryRemoveEndpoint(endpoint)); Assert.IsFalse(storage.CanCommunicateWithEndpoint(endpoint)); Assert.IsFalse(storage.IsWaitingForApproval(endpoint)); Assert.IsFalse(storage.HasBeenContacted(endpoint)); }
public void TryUpdateWithApprovalUnderWay() { var endpoint = new EndpointId("a"); var connection = new EndpointInformation( new EndpointId("a"), new DiscoveryInformation(new Uri("http://localhost/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://localhost/protocol/invalid"))); var description = new ProtocolDescription(new List <CommunicationSubject>()); var storage = new EndpointInformationStorage(); Assert.IsTrue(storage.TryAdd(endpoint, connection)); Assert.IsTrue(storage.TryStartApproval(endpoint, description)); var newConnection = new EndpointInformation( endpoint, new DiscoveryInformation(new Uri("http://other/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://other/protocol/invalid"))); Assert.IsTrue(storage.TryUpdate(newConnection)); EndpointInformation storedConnection; storage.TryGetConnectionFor(endpoint, out storedConnection); Assert.AreSame(newConnection, storedConnection); }
/// <summary> /// Initializes a new instance of the <see cref="EndpointDiscoveredEventArgs"/> class. /// </summary> /// <param name="endpointInformation">The connection information for the new endpoint.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="endpointInformation"/> is <see langword="null" />. /// </exception> public EndpointDiscoveredEventArgs(EndpointInformation endpointInformation) { { Lokad.Enforce.Argument(() => endpointInformation); } ConnectionInformation = endpointInformation; }
private static bool IsComplete(EndpointInformation storedInformation) { return((storedInformation != null) && (storedInformation.DiscoveryInformation.Address != null) && (storedInformation.ProtocolInformation.Version != null) && (storedInformation.ProtocolInformation.MessageAddress != null) && (storedInformation.ProtocolInformation.DataAddress != null)); }
/// <summary> /// Removes the endpoint from the storage. /// </summary> /// <param name="endpoint">The ID of the endpoint.</param> /// <returns> /// <see langword="true" /> if the endpoint was removed successfully; otherwise, <see langword="false" />. /// </returns> public bool TryRemoveEndpoint(EndpointId endpoint) { if (endpoint == null) { return(false); } bool hasEndpoint; lock (m_Lock) { hasEndpoint = m_ApprovedEndpoints.ContainsKey(endpoint) || m_EndpointsWaitingForApproval.ContainsKey(endpoint) || m_ContactedEndpoints.ContainsKey(endpoint); } if (!hasEndpoint) { return(false); } RaiseOnEndpointDisconnecting(endpoint); EndpointInformation info = null; lock (m_Lock) { if (m_ApprovedEndpoints.ContainsKey(endpoint)) { info = m_ApprovedEndpoints[endpoint]; m_ApprovedEndpoints.Remove(endpoint); } if (m_EndpointsWaitingForApproval.ContainsKey(endpoint)) { // Always notify because we can send messages to an endpoint // while we're establishing if an endpoint is worth connecting to info = m_EndpointsWaitingForApproval[endpoint].Item1; m_EndpointsWaitingForApproval.Remove(endpoint); } if (m_ContactedEndpoints.ContainsKey(endpoint)) { // Always notify because we can send messages to an endpoint // while we're establishing if an endpoint is worth connecting to info = m_ContactedEndpoints[endpoint]; m_ContactedEndpoints.Remove(endpoint); } } if (info != null) { RaiseOnEndpointDisconnected(info); return(true); } return(false); }
private void RaiseOnEndpointDisconnected(EndpointInformation info) { var local = OnEndpointDisconnected; if (local != null) { local(this, new EndpointEventArgs(info.Id)); } }
internal void UpdateEndpointEntryOnAccessStart(EndpointInformation entry) { var now = DateTime.UtcNow; lock (entry.lockObj) { entry.LastUpdatedTimestamp = now; } }
private void RaiseOnEndpointBecomingAvailable(EndpointInformation info) { var local = OnEndpointBecomingAvailable; if (local != null) { local(this, new EndpointDiscoveredEventArgs(info)); } }
// Assumes entry is locked. internal void RefreshFailedEndpointEntry(EndpointInformation entry, DateTime refreshTimestamp) { Contract.Assert(entry.LastFailureTimestamp != default(DateTime)); if (refreshTimestamp.Subtract(entry.LastFailureTimestamp) > _failedEndpointExpiryInterval) { entry.State = EndpointState.Available; } }
public void SendMessageToWithOpenChannel() { var remoteEndpoint = new EndpointId("b"); var endpointInfo = new EndpointInformation( remoteEndpoint, new DiscoveryInformation(new Uri("net.pipe://localhost/discovery")), new ProtocolInformation( ProtocolVersions.V1, new Uri("net.pipe://localhost/messages"), new Uri("net.pipe://localhost/data"))); var endpoints = new Mock <IStoreInformationAboutEndpoints>(); { endpoints.Setup(e => e.CanCommunicateWithEndpoint(It.IsAny <EndpointId>())) .Returns(true); endpoints.Setup(e => e.TryGetConnectionFor(It.IsAny <EndpointId>(), out endpointInfo)) .Returns(true); } var msg = new SuccessMessage(new EndpointId("B"), new MessageId()); var channel = new Mock <IProtocolChannel>(); { channel.Setup(c => c.OpenChannel()) .Verifiable(); channel.Setup(c => c.LocalConnectionPointForVersion(It.IsAny <Version>())) .Returns(endpointInfo.ProtocolInformation); channel.Setup(c => c.Send(It.IsAny <ProtocolInformation>(), It.IsAny <ICommunicationMessage>(), It.IsAny <int>())) .Callback <ProtocolInformation, ICommunicationMessage, int>( (e, m, r) => { Assert.AreSame(endpointInfo.ProtocolInformation, e); Assert.AreSame(msg, m); }) .Verifiable(); } var pipe = new Mock <IDirectIncomingMessages>(); Func <ChannelTemplate, EndpointId, Tuple <IProtocolChannel, IDirectIncomingMessages> > channelBuilder = (template, id) => new Tuple <IProtocolChannel, IDirectIncomingMessages>(channel.Object, pipe.Object); var diagnostics = new SystemDiagnostics((log, s) => { }, null); var layer = new ProtocolLayer( endpoints.Object, channelBuilder, new[] { ChannelTemplate.NamedPipe, }, diagnostics); layer.SignIn(); layer.SendMessageTo(remoteEndpoint, msg, 1); channel.Verify(c => c.OpenChannel(), Times.Once()); channel.Verify(c => c.Send(It.IsAny <ProtocolInformation>(), It.IsAny <ICommunicationMessage>(), It.IsAny <int>()), Times.Once()); }
private static bool CanReachEndpointWithGivenConnection(EndpointInformation info) { var endpointChannelTemplate = info.ProtocolInformation.MessageAddress.ToChannelTemplate(); if (info.Id.IsOnLocalMachine()) { return(endpointChannelTemplate == ChannelTemplate.NamedPipe); } return(endpointChannelTemplate == ChannelTemplate.TcpIP); }
/// <summary> /// Attempts to get endpoint by URL part an EndpointInformation from the given string. /// </summary> /// <param name="urlPart"> The URL part.</param> /// <param name="endpoint">[out] The endpoint.</param> /// <returns>True if it succeeds, false if it fails.</returns> public static bool TryGetEndpointByUrlPart(string urlPart, out EndpointInformation endpoint) { if (!_instance._urlPartEndpointDict.ContainsKey(urlPart)) { endpoint = null; return(false); } endpoint = _instance._urlPartEndpointDict[urlPart]; return(true); }
/// <summary> /// Attempts to get endpoint by UID an EndpointInformation from the given GUID. /// </summary> /// <param name="endpointUid">The endpoint UID.</param> /// <param name="endpoint"> [out] The endpoint.</param> /// <returns>True if it succeeds, false if it fails.</returns> public static bool TryGetEndpointByUid(Guid endpointUid, out EndpointInformation endpoint) { if (!_instance._uidEndpointDict.ContainsKey(endpointUid)) { endpoint = null; return(false); } endpoint = _instance._uidEndpointDict[endpointUid]; return(true); }
/// <summary>Disables the given endpoint UID.</summary> /// <param name="endpointGuid">The endpoint UID.</param> /// <param name="endpoint"> [out] The endpoint.</param> /// <returns>True if it succeeds, false if it fails.</returns> public static bool TryDisable(Guid endpointGuid, out EndpointInformation endpoint) { if (_instance._uidEndpointDict.ContainsKey(endpointGuid)) { _instance._uidEndpointDict[endpointGuid].Enabled = false; endpoint = _instance._uidEndpointDict[endpointGuid]; return(true); } endpoint = null; return(false); }
/// <summary> /// Continues the handshake process between the current endpoint and the specified endpoint. /// </summary> /// <param name="connection">The connection information for endpoint that started the handshake.</param> /// <param name="information">The handshake information for the endpoint.</param> /// <param name="messageId">The ID of the message that carried the handshake information.</param> public void ContinueHandshakeWith( EndpointInformation connection, ProtocolDescription information, MessageId messageId) { bool shouldSendConnect; lock (m_Lock) { // Potentially a new endpoint so store it StorePotentialEndpoint(connection); if (!m_EndpointApprovalState.ContainsKey(connection.Id)) { return; } var tickList = m_EndpointApprovalState[connection.Id]; tickList.HaveReceivedConnect = true; if (!AllowConnection(connection.ProtocolInformation.Version, information)) { var failMsg = new FailureMessage(m_Layer.Id, messageId); m_Layer.SendMessageToUnregisteredEndpoint( connection, failMsg, CommunicationConstants.DefaultMaximuNumberOfRetriesForMessageSending); RemoveEndpoint(connection.Id); return; } var successMessage = new SuccessMessage(m_Layer.Id, messageId); m_Layer.SendMessageToUnregisteredEndpoint( connection, successMessage, CommunicationConstants.DefaultMaximuNumberOfRetriesForMessageSending); tickList.HaveSendConnectResponse = true; m_PotentialEndpoints.TryStartApproval(connection.Id, information); if (tickList.IsComplete()) { ApproveConnection(connection.Id); } shouldSendConnect = !tickList.HaveSendConnect; } if (shouldSendConnect) { InitiateHandshakeWith(connection); } }
public void OnEndpointDisconnectedAfterSigningIn() { var endpoint = new EndpointId("a"); var endpointInfo = new EndpointInformation( endpoint, new DiscoveryInformation(new Uri("net.pipe://localhost/discovery")), new ProtocolInformation( ProtocolVersions.V1, new Uri("net.pipe://localhost/messages"), new Uri("net.pipe://localhost/data"))); var endpoints = new Mock <IStoreInformationAboutEndpoints>(); { endpoints.Setup(e => e.CanCommunicateWithEndpoint(It.IsAny <EndpointId>())) .Returns(true); endpoints.Setup(e => e.TryGetConnectionFor(It.IsAny <EndpointId>(), out endpointInfo)) .Returns(true); } var channel = new Mock <IProtocolChannel>(); { channel.Setup(c => c.LocalConnectionPointForVersion(It.IsAny <Version>())) .Returns(endpointInfo.ProtocolInformation); channel.Setup(c => c.EndpointDisconnected(It.IsAny <ProtocolInformation>())) .Callback <ProtocolInformation>(e => Assert.AreEqual(endpointInfo.ProtocolInformation, e)) .Verifiable(); } var pipe = new Mock <IDirectIncomingMessages>(); { pipe.Setup(p => p.OnEndpointSignedOff(It.IsAny <EndpointId>())) .Callback <EndpointId>(e => Assert.AreEqual(endpoint, e)) .Verifiable(); } Func <ChannelTemplate, EndpointId, Tuple <IProtocolChannel, IDirectIncomingMessages> > channelBuilder = (template, id) => new Tuple <IProtocolChannel, IDirectIncomingMessages>(channel.Object, pipe.Object); var diagnostics = new SystemDiagnostics((log, s) => { }, null); var layer = new ProtocolLayer( endpoints.Object, channelBuilder, new[] { ChannelTemplate.NamedPipe, }, diagnostics); layer.SignIn(); endpoints.Raise(d => d.OnEndpointDisconnecting += null, new EndpointEventArgs(endpoint)); channel.Verify(c => c.EndpointDisconnected(It.IsAny <ProtocolInformation>()), Times.Once()); pipe.Verify(p => p.OnEndpointSignedOff(It.IsAny <EndpointId>()), Times.Once()); }
public void TryAddWithNullEndpoint() { var storage = new EndpointInformationStorage(); var connection = new EndpointInformation( new EndpointId("a"), new DiscoveryInformation(new Uri("http://localhost/discovery/invalid")), new ProtocolInformation( new Version(), new Uri("http://localhost/protocol/invalid"))); Assert.IsFalse(storage.TryAdd(null, connection)); }
/// <summary> /// Getting endpoint information from IIS. /// </summary> public static IEnumerable <EndpointInformation> GetRunningEndpointsInformation(this ServerManager @this, ILogger logger) { var sites = @this.Sites; var hostIp = string.Empty; var machineName = Dns.GetHostName(); var host = Dns.GetHostEntry(machineName); foreach (var ip in host.AddressList) { if (ip.AddressFamily == AddressFamily.InterNetwork) { hostIp = ip.ToString(); } } foreach (var site in sites) { if (!IsValidSiteForNotification(site)) { logger.Warning("Site is not valid for notification(e.g. not configured notification propagation on configuration of site) {@site}", site); continue; } foreach (var siteBinding in site.Bindings) { if (siteBinding.Schema.Name != BindingSchemaName) { logger.Warning("Binding scheme is not valid, must be {@schemaName}, but {@siteSchema}", BindingSchemaName, siteBinding.Schema.Name); continue; } var endpointInfo = new EndpointInformation { HostName = string.IsNullOrWhiteSpace(siteBinding.Host) ? machineName : siteBinding.Host, Address = siteBinding.EndPoint.Address.GetAddressBytes().All(x => x == 0) ? hostIp : siteBinding.EndPoint.Address.ToString(), Port = siteBinding.EndPoint.Port, ApplicationName = site.Name, MachineName = machineName }; logger.Information("Retrieved from IIS endpoint information {@endpoint}", endpointInfo); yield return(endpointInfo); } } }
internal void UpdateEndpointEntryOnAccessCompletion(EndpointInformation entry, EndpointAccessResult accessResult) { var now = DateTime.UtcNow; lock (entry.lockObj) { if (accessResult == EndpointAccessResult.Failure) { entry.State = EndpointState.Failed; entry.LastFailureTimestamp = now; } else if (entry.State == EndpointState.Failed) { RefreshFailedEndpointEntry(entry, now); } entry.LastUpdatedTimestamp = now; } }
internal void PopulateEndpoints(List<Uri> endpoints) { _endpoints = new Dictionary<Uri, EndpointInformation>(); foreach (Uri e in endpoints) { var info = new EndpointInformation() { lockObj = new object(), Name = e.OriginalString, State = EndpointState.Available, LastUpdatedTimestamp = DateTime.UtcNow, LastFailureTimestamp = default(DateTime) }; _endpoints.Add(e, info); } }