public void DiscoveryVersions() { var versionedEndpoints = new List <Tuple <Version, Uri> > { new Tuple <Version, Uri>( new Version(2, 0, 0, 0), new Uri("http://localhost/v2")), new Tuple <Version, Uri>( new Version(1, 0, 0, 0), new Uri("http://localhost/v1")), new Tuple <Version, Uri>( new Version(3, 0, 0, 0), new Uri("http://localhost/v3")), }; var endpoint = new BootstrapEndpoint(versionedEndpoints); var versions = endpoint.DiscoveryVersions(); Assert.That( versions, Is.EquivalentTo( versionedEndpoints .Select(t => t.Item1) .OrderBy(v => v))); }
/// <summary> /// Opens the channel. /// </summary> /// <param name="allowAutomaticChannelDiscovery"> /// A flag that indicates whether or not the channel should provide automatic channel discovery. /// </param> public void OpenChannel(bool allowAutomaticChannelDiscovery) { var discoveryChannelsByVersion = new Dictionary <Version, Uri>(); foreach (var version in DiscoveryVersions.SupportedVersions()) { var host = m_HostBuilder(); var endpoint = m_VersionedEndpointBuilder(version, m_Template.ChannelTemplate); var localVersion = version; var type = endpoint.Item1; Func <ServiceHost, ServiceEndpoint> endpointBuilder = h => m_Template.AttachVersionedDiscoveryEndpoint(h, type, localVersion); var uri = host.OpenChannel(endpoint.Item2, endpointBuilder); m_HostsByVersion.Add(version, host); discoveryChannelsByVersion.Add(version, uri); } // Open the channel that provides the discovery of the discovery channels m_BootstrapHost = m_HostBuilder(); var bootstrapEndpoint = new BootstrapEndpoint(discoveryChannelsByVersion.Select(p => new Tuple <Version, Uri>(p.Key, p.Value))); Func <ServiceHost, ServiceEndpoint> bootstrapEndpointBuilder = h => { var endpoint = m_Template.AttachDiscoveryEntryEndpoint(h, typeof(IBootstrapEndpoint), m_Id, allowAutomaticChannelDiscovery); m_EntryChannelStorage(endpoint.Address.Uri); return(endpoint); }; m_BootstrapHost.OpenChannel(bootstrapEndpoint, bootstrapEndpointBuilder); }
public void OpenChannel() { var id = EndpointIdExtensions.CreateEndpointIdForCurrentProcess(); var baseUri = new Uri("http://localhost/invalid"); var versionedEndpointUri = new Uri("http://localhost/invalid/v1"); var template = new Mock <IDiscoveryChannelTemplate>(); { template.Setup( t => t.AttachDiscoveryEntryEndpoint(It.IsAny <ServiceHost>(), It.IsAny <Type>(), It.IsAny <EndpointId>(), It.IsAny <bool>())) .Returns(new ServiceEndpoint(new ContractDescription("a"), new NetNamedPipeBinding(), new EndpointAddress(baseUri))); } var versionedEndpointCounter = 0; var versionedEndpoint = new Mock <IVersionedDiscoveryEndpoint>(); Func <Version, ChannelTemplate, Tuple <Type, IVersionedDiscoveryEndpoint> > endpointBuilder = (v, t) => { versionedEndpointCounter++; return(new Tuple <Type, IVersionedDiscoveryEndpoint>(versionedEndpoint.Object.GetType(), versionedEndpoint.Object)); }; BootstrapEndpoint baseEndpoint = null; var host = new Mock <IHoldServiceConnections>(); { host.Setup(h => h.OpenChannel(It.IsAny <IReceiveInformationFromRemoteEndpoints>(), It.IsAny <Func <ServiceHost, ServiceEndpoint> >())) .Callback <IReceiveInformationFromRemoteEndpoints, Func <ServiceHost, ServiceEndpoint> >( (h, e) => { e(null); baseEndpoint = h as BootstrapEndpoint; }) .Returns <IReceiveInformationFromRemoteEndpoints, Func <ServiceHost, ServiceEndpoint> >( (h, e) => (h is IVersionedDiscoveryEndpoint) ? versionedEndpointUri : baseUri) .Verifiable(); } Func <IHoldServiceConnections> hostBuilder = () => host.Object; Uri entryAddress = null; Action <Uri> storage = u => entryAddress = u; var channel = new BootstrapChannel( id, template.Object, endpointBuilder, hostBuilder, storage); channel.OpenChannel(true); host.Verify( h => h.OpenChannel(It.IsAny <IReceiveInformationFromRemoteEndpoints>(), It.IsAny <Func <ServiceHost, ServiceEndpoint> >()), Times.Exactly(2)); Assert.AreEqual(1, versionedEndpointCounter); Assert.AreEqual(baseUri, entryAddress); Assert.IsNotNull(baseEndpoint); Assert.AreEqual(1, baseEndpoint.DiscoveryVersions().Length); Assert.AreEqual(versionedEndpointUri, baseEndpoint.UriForVersion(baseEndpoint.DiscoveryVersions()[0])); }
public void RecentlyConnectedEndpointWithoutSuitableDiscoveryVersion() { var translator = new Mock <ITranslateVersionedChannelInformation>(); var translators = new[] { new Tuple <Version, ITranslateVersionedChannelInformation>(new Version(1, 0), translator.Object), }; var configuration = new Mock <IConfiguration>(); { configuration.Setup(c => c.HasValueFor(It.IsAny <ConfigurationKey>())) .Returns(false); } var template = new NamedPipeDiscoveryChannelTemplate(configuration.Object); Func <ChannelTemplate, IDiscoveryChannelTemplate> templateBuilder = t => template; var diagnostics = new SystemDiagnostics((l, s) => { }, null); var discovery = new ManualDiscoverySource( translators, templateBuilder, diagnostics); discovery.OnEndpointBecomingAvailable += (s, e) => Assert.Fail(); discovery.StartDiscovery(); var uri = new Uri("net.pipe://localhost/pipe/discovery"); var channels = new[] { new Tuple <Version, Uri>(new Version(2, 0), new Uri(uri, new Uri("/2.0", UriKind.Relative))), }; var receiver = new BootstrapEndpoint(channels); var host = new ServiceHost(receiver, uri); var binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None) { TransferMode = TransferMode.Buffered, }; var address = string.Format("{0}_{1}", "ThroughNamedPipe", Process.GetCurrentProcess().Id); var endpoint = host.AddServiceEndpoint(typeof(IBootstrapEndpoint), binding, address); host.Open(); try { discovery.RecentlyConnectedEndpoint( EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), endpoint.ListenUri); } finally { host.Close(); } }
public void UriForVersionWithNullVersion() { var versionedEndpoints = new List <Tuple <Version, Uri> > { new Tuple <Version, Uri>( new Version(2, 0, 0, 0), new Uri("http://localhost/v2")), new Tuple <Version, Uri>( new Version(1, 0, 0, 0), new Uri("http://localhost/v1")), new Tuple <Version, Uri>( new Version(3, 0, 0, 0), new Uri("http://localhost/v3")), }; var endpoint = new BootstrapEndpoint(versionedEndpoints); Assert.IsNull(endpoint.UriForVersion(null)); }
public void UriForVersion() { var versionedEndpoints = new List <Tuple <Version, Uri> > { new Tuple <Version, Uri>( new Version(2, 0, 0, 0), new Uri("http://localhost/v2")), new Tuple <Version, Uri>( new Version(1, 0, 0, 0), new Uri("http://localhost/v1")), new Tuple <Version, Uri>( new Version(3, 0, 0, 0), new Uri("http://localhost/v3")), }; var endpoint = new BootstrapEndpoint(versionedEndpoints); var address = endpoint.UriForVersion(new Version(2, 0, 0, 0)); Assert.AreEqual(versionedEndpoints[0].Item2, address); }