Пример #1
0
        public async Task CloseStopsSilo()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(ServiceFabricConstants.SiloEndpointName, 9082),
                CreateEndpoint(ServiceFabricConstants.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);
            var listener = new OrleansCommunicationListener(
                builder =>
            {
                builder.ConfigureServices(
                    services =>
                {
                    // Use our mock silo host.
                    services.Replace(ServiceDescriptor.Singleton <ISiloHost>(sp => Substitute.ForPartsOf <MockSiloHost>(sp)));
                });

                builder.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory());
                builder.Configure <EndpointOptions>(options => options.ConfigureFromServiceContext(this.serviceContext));
                builder.UseLocalhostClustering();
            });

            await listener.OpenAsync(CancellationToken.None);

            var siloHost = listener.Host;

            siloHost.ClearReceivedCalls();
            await listener.CloseAsync(CancellationToken.None);

            await siloHost.ReceivedWithAnyArgs(1).StopAsync(Arg.Is <CancellationToken>(c => !c.IsCancellationRequested));

            await siloHost.DidNotReceiveWithAnyArgs().StartAsync(Arg.Any <CancellationToken>());
        }
        public async Task CloseStopsSilo()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(ServiceFabricConstants.SiloEndpointName, 9082),
                CreateEndpoint(ServiceFabricConstants.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);
            clusterConfig.Defaults.ConfigureServiceFabricSiloEndpoints(this.serviceContext);
            var listener = new OrleansCommunicationListener(
                builder =>
            {
                builder.ConfigureServices(
                    services =>
                {
                    // Use our mock silo host.
                    services.Replace(ServiceDescriptor.Singleton <ISiloHost>(sp => Substitute.ForPartsOf <MockSiloHost>(sp)));
                });

                // Our cluster configuration is what feeds the endpoint info, so add it.
                builder.UseConfiguration(this.clusterConfig);
            });

            await listener.OpenAsync(CancellationToken.None);

            var siloHost = listener.Host;

            siloHost.ClearReceivedCalls();
            await listener.CloseAsync(CancellationToken.None);

            await siloHost.ReceivedWithAnyArgs(1).StopAsync(Arg.Is <CancellationToken>(c => !c.IsCancellationRequested));

            await siloHost.DidNotReceiveWithAnyArgs().StartAsync(Arg.Any <CancellationToken>());
        }
        public async Task SimpleUsageScenarioTest()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(ServiceFabricConstants.SiloEndpointName, 9082),
                CreateEndpoint(ServiceFabricConstants.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);

            var listener = new OrleansCommunicationListener(
                builder =>
            {
                builder.ConfigureServices(
                    services =>
                {
                    // Use our mock silo host.
                    services.Replace(ServiceDescriptor.Singleton <ISiloHost>(sp => Substitute.ForPartsOf <MockSiloHost>(sp)));
                });

                builder.ConfigureApplicationParts(parts => parts.AddFromApplicationBaseDirectory());
                builder.UseLocalhostClustering();
                builder.Configure <EndpointOptions>(options =>
                {
                    options.SiloPort    = 9082;
                    options.GatewayPort = 8888;
                });
            });

            var result = await listener.OpenAsync(CancellationToken.None);

            var siloHost           = listener.Host;
            var publishedEndpoints = JsonConvert.DeserializeObject <FabricSiloInfo>(result);

            var siloAddress = publishedEndpoints.SiloAddress;

            siloAddress.Generation.Should().NotBe(0);
            siloAddress.Endpoint.Port.ShouldBeEquivalentTo(9082);

            var gatewayAddress = publishedEndpoints.GatewayAddress;

            gatewayAddress.Generation.Should().Be(0);
            gatewayAddress.Endpoint.Port.ShouldBeEquivalentTo(8888);

            await siloHost.ReceivedWithAnyArgs(1).StartAsync(Arg.Is <CancellationToken>(c => !c.IsCancellationRequested));

            await siloHost.DidNotReceive().StopAsync(Arg.Any <CancellationToken>());

            siloHost.ClearReceivedCalls();
            await listener.CloseAsync(CancellationToken.None);

            await siloHost.ReceivedWithAnyArgs(1).StopAsync(Arg.Is <CancellationToken>(c => !c.IsCancellationRequested));

            await siloHost.DidNotReceiveWithAnyArgs().StartAsync(Arg.Any <CancellationToken>());
        }
        public async Task SimpleUsageScenarioTest()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(ServiceFabricConstants.SiloEndpointName, 9082),
                CreateEndpoint(ServiceFabricConstants.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);

            clusterConfig.Defaults.ConfigureServiceFabricSiloEndpoints(this.serviceContext);
            var listener = new OrleansCommunicationListener(
                builder =>
            {
                builder.ConfigureServices(
                    services =>
                {
                    // Use our mock silo host.
                    services.Replace(ServiceDescriptor.Singleton <ISiloHost>(sp => Substitute.ForPartsOf <MockSiloHost>(sp)));
                });

                // Our cluster configuration is what feeds the endpoint info, so add it.
                builder.UseConfiguration(this.clusterConfig);
            });

            var result = await listener.OpenAsync(CancellationToken.None);

            var siloHost           = listener.Host;
            var publishedEndpoints = JsonConvert.DeserializeObject <FabricSiloInfo>(result);

            var siloAddress = publishedEndpoints.SiloAddress;

            siloAddress.Generation.ShouldBeEquivalentTo(864);
            siloAddress.Endpoint.Port.ShouldBeEquivalentTo(9082);

            var gatewayAddress = publishedEndpoints.GatewayAddress;

            gatewayAddress.Generation.ShouldBeEquivalentTo(864);
            gatewayAddress.Endpoint.Port.ShouldBeEquivalentTo(8888);

            await siloHost.ReceivedWithAnyArgs(1).StartAsync(Arg.Is <CancellationToken>(c => !c.IsCancellationRequested));

            await siloHost.DidNotReceive().StopAsync(Arg.Any <CancellationToken>());

            siloHost.ClearReceivedCalls();
            await listener.CloseAsync(CancellationToken.None);

            await siloHost.ReceivedWithAnyArgs(1).StopAsync(Arg.Is <CancellationToken>(c => !c.IsCancellationRequested));

            await siloHost.DidNotReceiveWithAnyArgs().StartAsync(Arg.Any <CancellationToken>());
        }
        public async Task SimpleUsageScenarioTest()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(OrleansCommunicationListener.SiloEndpointName, 9082),
                CreateEndpoint(OrleansCommunicationListener.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);
            var siloHost = Substitute.For <ISiloHost>();
            var listener = new OrleansCommunicationListener(this.serviceContext, clusterConfig)
            {
                SiloHost = siloHost
            };

            siloHost.NodeConfig.Returns(_ => clusterConfig.GetOrCreateNodeConfigurationForSilo(listener.SiloName));

            var result = await listener.OpenAsync(CancellationToken.None);

            var publishedEndpoints = JsonConvert.DeserializeObject <FabricSiloInfo>(result);

            var siloAddress = publishedEndpoints.SiloAddress;

            siloAddress.Generation.ShouldBeEquivalentTo(864);
            siloAddress.Endpoint.Port.ShouldBeEquivalentTo(9082);

            var gatewayAddress = publishedEndpoints.GatewayAddress;

            gatewayAddress.Generation.ShouldBeEquivalentTo(864);
            gatewayAddress.Endpoint.Port.ShouldBeEquivalentTo(8888);

            siloHost.ReceivedWithAnyArgs(1).Start(null, null);
            siloHost.DidNotReceive().Stop();

            siloHost.ClearReceivedCalls();
            await listener.CloseAsync(CancellationToken.None);

            siloHost.Received(1).Stop();
            siloHost.DidNotReceiveWithAnyArgs().Start(null, null);
        }
        public void AbortStopAndDisposesSilo()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(OrleansCommunicationListener.SiloEndpointName, 9082),
                CreateEndpoint(OrleansCommunicationListener.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);
            var siloHost = Substitute.For <ISiloHost>();
            var listener = new OrleansCommunicationListener(
                serviceContext,
                new ClusterConfiguration())
            {
                SiloHost = siloHost
            };

            listener.Abort();
            siloHost.ReceivedWithAnyArgs(1).Stop();
            siloHost.ReceivedWithAnyArgs(1).Dispose();
            siloHost.DidNotReceiveWithAnyArgs().Start(null, null);
        }
        public async Task CloseStopsSilo()
        {
            var endpoints = new EndpointsCollection
            {
                CreateEndpoint(OrleansCommunicationListener.SiloEndpointName, 9082),
                CreateEndpoint(OrleansCommunicationListener.GatewayEndpointName, 8888)
            };

            activationContext.GetEndpoints().Returns(_ => endpoints);
            var siloHost = Substitute.For <ISiloHost>();
            var listener = new OrleansCommunicationListener(
                serviceContext,
                new ClusterConfiguration())
            {
                SiloHost = siloHost
            };

            await listener.CloseAsync(CancellationToken.None);

            siloHost.ReceivedWithAnyArgs(1).Stop();
            siloHost.DidNotReceiveWithAnyArgs().Dispose();
            siloHost.DidNotReceiveWithAnyArgs().Start(null, null);
        }