public void InvocationShouldAlwaysTriggerLaunchWhenMethodLaunchModeSetToAlways()
        {
            Task <GreetingResponse> HandleAsync(GreetingRequest greetingRequest, MethodCallContext context)
            {
                return(Task.FromResult(new GreetingResponse {
                    Greeting = greetingRequest.Name
                }));
            }

            RunWith10SecTimeout(async() =>
            {
                var serverCreatedCount = 0;
                var echoServerFactory  = new TestClientFactory(
                    (broker, id) =>
                {
                    var optionsBuilder = new ClientOptionsBuilder()
                                         .WithBrokerWorkingDir(_testBrokerFixture.SharedInstance.WorkingDir)
                                         .WithAppInstanceId(id)
                                         .WithApplicationId(EchoServerClient.Id)
                                         .WithDefaultConfiguration()
                                         .WithProvidedService(
                        GreetingService.Id,
                        "AlwaysLaunchGreetingService",
                        x => x.WithUnaryMethod <GreetingRequest, GreetingResponse>("Hello", HandleAsync));

                    serverCreatedCount++;

                    return(Task.FromResult(ClientFactory.Instance.Create(optionsBuilder.Build())));
                });

                var appLauncher = RegisterDisposable(
                    new TestAppLauncher(
                        _testBrokerFixture.SharedInstance,
                        new Dictionary <string, TestClientFactory>
                {
                    { EchoServerClient.Id, echoServerFactory }
                }
                        )
                    );
                await appLauncher.StartAsync();
                ConnectEchoServer();
                var client = new EchoClient(s => s.WithBrokerWorkingDir(_testBrokerFixture.SharedInstance.WorkingDir));
                client.ConnectAsync().ShouldCompleteIn(Timeout5Sec);
                var callDescriptor = new MethodCallDescriptor(
                    ProvidedMethodReference.Create(GreetingService.Id, "AlwaysLaunchGreetingService", "Hello", EchoServerClient.Id));
                await client.CallInvoker.CallUnary(callDescriptor, new GreetingRequest {
                    Name = "Test"
                });
                await client.CallInvoker.CallUnary(callDescriptor, new GreetingRequest {
                    Name = "Test"
                });
                serverCreatedCount.ShouldBe(2);
            });
        }
        public void InvokeTargetUsingConnectionIdWithoutAppId()
        {
            RunWith10SecTimeout(async() =>
            {
                var server1RequestCount = 0;
                var server1             = ConnectEchoServer((request, context) =>
                {
                    server1RequestCount++;
                    return(Task.FromResult(new GreetingResponse {
                        Greeting = "FromServer1"
                    }));
                });

                var server2RequestCount = 0;
                var server2             = ConnectEchoServer((request, context) =>
                {
                    server2RequestCount++;
                    return(Task.FromResult(new GreetingResponse {
                        Greeting = "FromServer2"
                    }));
                });

                var client = CreateClient <EchoClient>();
                await client.ConnectAsync();

                server1RequestCount.ShouldBe(0);
                server2RequestCount.ShouldBe(0);

                var providedMethodReference = ProvidedMethodReference.CreateWithConnectionId(GreetingService.Id,
                                                                                             GreetingService.HelloMethodId, server1.ConnectionId);
                var methodCallDescriptor = new MethodCallDescriptor(providedMethodReference);
                var greetingRequest      = new GreetingRequest {
                    Name = "Client"
                };
                var response =
                    await client.CallInvoker.CallUnary <GreetingRequest, GreetingResponse>(methodCallDescriptor,
                                                                                           greetingRequest);

                response.Greeting.ShouldBe("FromServer1");
                server1RequestCount.ShouldBe(1);
                server2RequestCount.ShouldBe(0);

                providedMethodReference = ProvidedMethodReference.CreateWithConnectionId(GreetingService.Id,
                                                                                         GreetingService.HelloMethodId, server2.ConnectionId);
                methodCallDescriptor = new MethodCallDescriptor(providedMethodReference);
                response             = await client.CallInvoker.CallUnary <GreetingRequest, GreetingResponse>(methodCallDescriptor,
                                                                                                              greetingRequest);

                response.Greeting.ShouldBe("FromServer2");
                server1RequestCount.ShouldBe(1);
                server2RequestCount.ShouldBe(1);
            });
        }
예제 #3
0
 internal DiscoveredMethod(
     ProvidedMethodReference providedMethod,
     Maybe <string> title,
     string inputMessageId,
     string outputMessageId,
     MethodType type,
     MethodCallDescriptor callDescriptor,
     IReadOnlyCollection <Option> options)
 {
     ProvidedMethod  = providedMethod;
     Title           = title;
     InputMessageId  = inputMessageId;
     OutputMessageId = outputMessageId;
     Type            = type;
     CallDescriptor  = callDescriptor;
     Options         = options;
 }
예제 #4
0
 internal DiscoveredMethod(
     ProvidedMethodReference providedMethod,
     Maybe <string> title,
     string inputMessageId,
     string outputMessageId,
     MethodType type,
     IReadOnlyCollection <Option> options)
     : this(
         providedMethod,
         title,
         inputMessageId,
         outputMessageId,
         type,
         new MethodCallDescriptor(providedMethod),
         options)
 {
 }
예제 #5
0
 internal DiscoveredOnlineMethod(
     ProvidedMethodReference providedMethod,
     Maybe <string> title,
     string inputMessageId,
     string outputMessageId,
     MethodType type,
     IReadOnlyCollection <Option> options)
     : base(
         providedMethod,
         title,
         inputMessageId,
         outputMessageId,
         type,
         options)
 {
     ProviderConnectionId = providedMethod.ProvidedService.ConnectionId.Value;
 }
        public void InvokeApplicationBeforeItsConnection()
        {
            RunWith10SecTimeout(async() =>
            {
                Task <GreetingResponse> HandleAsync(GreetingRequest request, MethodCallContext context)
                {
                    return(Task.FromResult(new GreetingResponse {
                        Greeting = request.Name + "1"
                    }));
                }

                var brokerInstance      = _testBrokerFixture.SharedInstance;
                var createdServersCount = 0;
                var createdServerClient = new TaskCompletionSource <IClient>();
                var echoServerFactory   = new TestClientFactory(
                    (broker, id) =>
                {
                    var optionsBuilder = new ClientOptionsBuilder()
                                         .WithBrokerWorkingDir(brokerInstance.WorkingDir)
                                         .WithAppInstanceId(id)
                                         .WithApplicationId(EchoServerClient.Id)
                                         .WithDefaultConfiguration()
                                         .WithProvidedService(
                        GreetingService.Id,
                        x => x.WithUnaryMethod <GreetingRequest, GreetingResponse>(GreetingService.HelloMethodId,
                                                                                   HandleAsync));
                    var serverClient = ClientFactory.Instance.Create(optionsBuilder.Build());
                    createdServerClient.SetResult(serverClient);
                    createdServersCount++;
                    return(Task.FromResult(serverClient));
                });

                var appLauncher = RegisterDisposable(
                    new TestAppLauncher(
                        brokerInstance,
                        new Dictionary <string, TestClientFactory>
                {
                    { EchoServerClient.Id, echoServerFactory }
                },
                        false
                        )
                    );
                await appLauncher.StartAsync();

                var client1 = CreateClient <EchoClient>();
                await client1.ConnectAsync();

                var client2 = CreateClient <EchoClient>();
                await client2.ConnectAsync();

                var helloTask = client1.GreetingService.Hello(new GreetingRequest {
                    Name = "Test1"
                }).ResponseAsync;
                var callUnconnectedServerTask = createdServerClient.Task.ContinueWith(async task =>
                {
                    var serverClient = task.Result;
                    await Task.Delay(TimeSpan.FromSeconds(1));
                    var providedMethodReference = ProvidedMethodReference.CreateWithAppInstanceId(GreetingService.Id,
                                                                                                  GreetingService.HelloMethodId, EchoServerClient.Id, serverClient.ApplicationInstanceId);
                    var methodCallDescriptor = new MethodCallDescriptor(providedMethodReference);
                    await client2.CallInvoker.CallUnary <GreetingRequest, GreetingResponse>(methodCallDescriptor,
                                                                                            new GreetingRequest()
                    {
                        Name = "Test2"
                    });
                }).Unwrap();

                var connectedServerAfterDelayTask = createdServerClient.Task.ContinueWith(async task =>
                {
                    var serverClient = task.Result;

                    await Task.Delay(TimeSpan.FromSeconds(3));

                    serverClient.ConnectionId.ShouldBe(UniqueId.Empty);
                    var onlineConnectionsResponse =
                        await client1.AppLifecycleService.GetConnections(new GetConnectionsRequest
                    {
                        AppInstanceId = serverClient.ApplicationInstanceId
                    });
                    onlineConnectionsResponse.Connections.Count.ShouldBe(0);

                    await serverClient.ConnectAsync();
                }).Unwrap();

                await Task.WhenAll(helloTask, callUnconnectedServerTask, connectedServerAfterDelayTask);

                createdServersCount.ShouldBe(1);
            });
        }
        public void InvocationShouldTriggerLaunchWithSingleInstanceModeByDefault()
        {
            var serverInvokedCount = 0;

            Task <GreetingResponse> HandleAsync(GreetingRequest greetingRequest, MethodCallContext context)
            {
                Interlocked.Increment(ref serverInvokedCount);
                return(Task.FromResult(new GreetingResponse {
                    Greeting = greetingRequest.Name
                }));
            }

            RunWith10SecTimeout(async() =>
            {
                var serverCreatedCount = 0;
                var echoServerFactory  = new TestClientFactory(
                    (broker, id) =>
                {
                    WriteLog("Launching server on demand");

                    var optionsBuilder = new ClientOptionsBuilder()
                                         .WithBrokerWorkingDir(_testBrokerFixture.SharedInstance.WorkingDir)
                                         .WithAppInstanceId(id)
                                         .WithApplicationId(EchoServerClient.Id)
                                         .WithDefaultConfiguration()
                                         .WithProvidedService(
                        GreetingService.Id,
                        x => x.WithUnaryMethod <GreetingRequest, GreetingResponse>("Hello", HandleAsync));

                    serverCreatedCount++;

                    return(ClientFactory.Instance.Create(optionsBuilder.Build()));
                });

                var appLauncher = RegisterDisposable(
                    new TestAppLauncher(
                        _testBrokerFixture.SharedInstance,
                        new Dictionary <string, TestClientFactory>
                {
                    { EchoServerClient.Id, echoServerFactory }
                }
                        )
                    );
                await appLauncher.StartAsync();
                var client = new EchoClient(s => s.WithBrokerWorkingDir(_testBrokerFixture.SharedInstance.WorkingDir));
                client.ConnectAsync().ShouldCompleteIn(Timeout5Sec);
                var callDescriptor = new MethodCallDescriptor(
                    ProvidedMethodReference.Create(GreetingService.Id, "Hello", EchoServerClient.Id));
                var call1 = client.CallInvoker.CallUnary(callDescriptor, new GreetingRequest {
                    Name = "Test"
                });
                var call2 = client.CallInvoker.CallUnary(callDescriptor, new GreetingRequest {
                    Name = "Test"
                });
                await Task.WhenAny(call1.AsTask(), call2.AsTask());
                WriteLog("Call 1 completed");
                await Task.WhenAll(call1.AsTask(), call2.AsTask());
                WriteLog("Call 2 completed");
                serverCreatedCount.ShouldBe(1);
                serverInvokedCount.ShouldBe(2);
            });
        }