Exemple #1
0
        public EventStoreOperationsClient(EventStoreClientSettings settings = null)
        {
            settings ??= new EventStoreClientSettings();
            var httpHandler = settings.CreateHttpMessageHandler?.Invoke() ?? new HttpClientHandler();

            _channel = GrpcChannel.ForAddress(settings.ConnectivitySettings.Address ?? new UriBuilder {
                Scheme = Uri.UriSchemeHttps,
                Port   = 2113
            }.Uri, new GrpcChannelOptions {
                HttpClient = new HttpClient(httpHandler)
                {
                    Timeout = Timeout.InfiniteTimeSpan,
                    DefaultRequestVersion = new Version(2, 0),
                },
                LoggerFactory = settings.LoggerFactory
            });
            var connectionName = settings.ConnectionName ?? $"ES-{Guid.NewGuid()}";

            var callInvoker = (settings.Interceptors ?? Array.Empty <Interceptor>()).Aggregate(
                _channel.CreateCallInvoker()
                .Intercept(new TypedExceptionInterceptor())
                .Intercept(new ConnectionNameInterceptor(connectionName)),
                (invoker, interceptor) => invoker.Intercept(interceptor));

            _client = new Operations.OperationsClient(callInvoker);
        }
Exemple #2
0
 public WalletManagerClient(string serverGrpcUrl) : base(serverGrpcUrl)
 {
     Monitoring = new Monitoring.MonitoringClient(Channel);
     Wallets    = new Wallets.WalletsClient(Channel);
     Balances   = new Balances.BalancesClient(Channel);
     Operations = new Operations.OperationsClient(Channel);
     Transfers  = new Transfers.TransfersClient(Channel);
 }
        public EventStoreGrpcOperationsClient(Uri address, Func <HttpClient> createHttpClient = default)
        {
            if (address == null)
            {
                throw new ArgumentNullException(nameof(address));
            }

            _channel = GrpcChannel.ForAddress(address, new GrpcChannelOptions {
                HttpClient = createHttpClient?.Invoke(),
            });
            var callInvoker = _channel.CreateCallInvoker().Intercept(new TypedExceptionInterceptor());

            _client = new Operations.OperationsClient(callInvoker);
        }
        static void Main(string[] args)
        {
            Parser.Default.ParseArguments <SampleClientArguments>(args)
            .WithParsed(parsedArgs =>
            {
                var gatewayServiceUrl = parsedArgs.Local
                        ? string.Format(LocalEndPointUrlFormat, "4040")
                        : string.Format(CloudEndPointUrlFormat, "gateway", parsedArgs.GoogleProject);

                var partyServiceUrl = parsedArgs.Local
                        ? string.Format(LocalEndPointUrlFormat, "4041")
                        : string.Format(CloudEndPointUrlFormat, "party", parsedArgs.GoogleProject);

                var authServiceUrl = parsedArgs.Local
                        ? string.Format(LocalEndPointUrlFormat, "4042")
                        : string.Format(CloudEndPointUrlFormat, "playfab-auth", parsedArgs.GoogleProject);

                var playerId = RandomString(15);
                Console.WriteLine($"Using a randomly generated PlayFab player ID: {playerId}");

                // First, get a token from PlayFab.
                PlayFabSettings.staticSettings.TitleId = parsedArgs.PlayFabTitleId;
                var playFabLoginTask = PlayFabClientAPI.LoginWithCustomIDAsync(new LoginWithCustomIDRequest
                {
                    TitleId       = parsedArgs.PlayFabTitleId,
                    CustomId      = playerId,
                    CreateAccount = true
                });
                var playFabLoginResult = playFabLoginTask.GetAwaiter().GetResult();
                if (playFabLoginResult.Error != null)
                {
                    Console.WriteLine($"Got login error from PlayFab: {playFabLoginResult.Error.ErrorMessage}");
                    Environment.Exit(1);
                    return;
                }

                var playFabId = playFabLoginResult.Result.PlayFabId;

                Console.WriteLine($"Got a token for PlayFab ID {playFabId}.");

                // Next, exchange the token with our auth service for a PIT.
                var playFabAuthClient = new AuthService.AuthServiceClient(
                    new Channel(authServiceUrl, ChannelCredentials.Insecure));
                var authResult = playFabAuthClient.ExchangePlayFabToken(new ExchangePlayFabTokenRequest
                {
                    PlayfabToken = playFabLoginResult.Result.SessionTicket
                });
                Console.WriteLine("Got a PIT.");
                var pitMetadata = new Metadata {
                    { PitRequestHeaderName, authResult.PlayerIdentityToken }
                };

                // Create a single-player party for the player.
                var partyClient = new PartyService.PartyServiceClient(
                    new Channel(partyServiceUrl, ChannelCredentials.Insecure));
                var partyResponse =
                    partyClient.CreateParty(new CreatePartyRequest {
                    MinMembers = 1, MaxMembers = 1
                }, pitMetadata);
                Console.WriteLine($"Created a new party with id {partyResponse.PartyId}.");

                var gatewayEndpoint = gatewayServiceUrl;
                var gatewayClient   =
                    new GatewayService.GatewayServiceClient(new Channel(gatewayEndpoint,
                                                                        ChannelCredentials.Insecure));
                var operationsClient =
                    new Operations.OperationsClient(new Channel(gatewayEndpoint, ChannelCredentials.Insecure));

                var op = gatewayClient.Join(new JoinRequest
                {
                    MatchmakingType = "match"
                }, pitMetadata);
                Console.WriteLine("Joined queue; waiting for match.");

                while (!op.Done)
                {
                    Thread.Sleep(1000);
                    op = operationsClient.GetOperation(new GetOperationRequest
                    {
                        Name = op.Name
                    }, pitMetadata);
                }

                var response = op.Response.Unpack <JoinResponse>();
                Console.WriteLine(
                    $"Got deployment: {response.DeploymentName}. Login token: [{response.LoginToken}].");
            });
        }