GraphQLServerClientFactory.cs

Go to the documentation of this file.

using System;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
 
using StrawberryShake;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Client.GraphQL.Serializers;
using Tgstation.Server.Common.Extensions;
 
namespace Tgstation.Server.Client.GraphQL
{
    public sealed class GraphQLServerClientFactory : IGraphQLServerClientFactory
    {
        readonly IRestServerClientFactory restClientFactory;
 
        static ServiceProvider SetupServiceProvider(Uri host, bool addAuthorizationHandler, AuthenticationHeaderValue? headerOverride = null, OAuthProvider? oAuthProvider = null)
        {
            var serviceCollection = new ServiceCollection();
 
            var clientBuilder = serviceCollection
                .AddGraphQLClient();
            var graphQLEndpoint = new Uri(host, Routes.GraphQL);
 
            clientBuilder.ConfigureHttpClient(
                client =>
                {
                    client.BaseAddress = graphQLEndpoint;
                    client.DefaultRequestHeaders.Add(ApiHeaders.ApiVersionHeader, $"Tgstation.Server.Api/{ApiHeaders.Version.Semver()}");
                    if (oAuthProvider.HasValue)
                    {
                        client.DefaultRequestHeaders.Add(ApiHeaders.OAuthProviderHeader, oAuthProvider.ToString());
                    }
                },
                clientBuilder =>
                {
                    if (addAuthorizationHandler)
                        clientBuilder.AddHttpMessageHandler(() => new AuthorizationMessageHandler(headerOverride));
                });
 
            serviceCollection.AddSerializer<UnsignedIntSerializer>();
            serviceCollection.AddSerializer<SemverSerializer>();
            serviceCollection.AddSerializer<JwtSerializer>();
 
            return serviceCollection.BuildServiceProvider();
        }
 
        public GraphQLServerClientFactory(IRestServerClientFactory restClientFactory)
        {
            this.restClientFactory = restClientFactory ?? throw new ArgumentNullException(nameof(restClientFactory));
        }
 
        public ValueTask<IAuthenticatedGraphQLServerClient> CreateFromLogin(Uri host, string username, string password, bool attemptLoginRefresh = true, CancellationToken cancellationToken = default)
        {
            var basicCredentials = new AuthenticationHeaderValue(
                ApiHeaders.BasicAuthenticationScheme,
                Convert.ToBase64String(
                    Encoding.UTF8.GetBytes($"{username}:{password}")));
 
            return CreateWithAuthCall(
                host,
                basicCredentials,
                null,
                attemptLoginRefresh,
                cancellationToken);
        }
 
        public ValueTask<IAuthenticatedGraphQLServerClient> CreateFromOAuth(Uri host, string oAuthCode, OAuthProvider oAuthProvider, CancellationToken cancellationToken = default)
        {
            var oAuthCredentials = new AuthenticationHeaderValue(
                ApiHeaders.OAuthAuthenticationScheme,
                oAuthCode);
 
            return CreateWithAuthCall(
                host,
                oAuthCredentials,
                oAuthProvider,
                false,
                cancellationToken);
        }
 
        public IAuthenticatedGraphQLServerClient CreateFromToken(Uri host, string token)
        {
            var authenticationHeader = new AuthenticationHeaderValue(
                ApiHeaders.BearerAuthenticationScheme,
                token);
 
            var serviceProvider = SetupServiceProvider(
                host,
                true,
                authenticationHeader);
 
            return new AuthenticatedGraphQLServerClient(
                serviceProvider.GetRequiredService<IGraphQLClient>(),
                serviceProvider,
                serviceProvider.GetRequiredService<ILogger<GraphQLServerClient>>(),
                CreateAuthenticatedTransferClient(host, token));
        }
 
        public IGraphQLServerClient CreateUnauthenticated(Uri host)
        {
            var serviceProvider = SetupServiceProvider(host, false);
 
            return new GraphQLServerClient(
                serviceProvider.GetRequiredService<IGraphQLClient>(),
                serviceProvider,
                serviceProvider.GetRequiredService<ILogger<GraphQLServerClient>>());
        }
 
        async ValueTask<IAuthenticatedGraphQLServerClient> CreateWithAuthCall(
            Uri host,
            AuthenticationHeaderValue initialCredentials,
            OAuthProvider? oAuthProvider,
            bool attemptLoginRefresh,
            CancellationToken cancellationToken)
        {
            var serviceProvider = SetupServiceProvider(
                host,
                true,
                oAuthProvider: oAuthProvider);
            try
            {
                var client = serviceProvider.GetRequiredService<IGraphQLClient>();
 
                IOperationResult<ILoginResult> result;
 
                var previousAuthHeader = AuthorizationMessageHandler.Header.Value;
                AuthorizationMessageHandler.Header.Value = initialCredentials;
                try
                {
                    result = await client.Login.ExecuteAsync(cancellationToken).ConfigureAwait(false);
                }
                finally
                {
                    AuthorizationMessageHandler.Header.Value = previousAuthHeader;
                }
 
                var serverClient = new AuthenticatedGraphQLServerClient(
                    client,
                    serviceProvider,
                    serviceProvider.GetRequiredService<ILogger<GraphQLServerClient>>(),
                    newHeader => AuthorizationMessageHandler.Header.Value = newHeader,
                    attemptLoginRefresh ? initialCredentials : null,
                    result,
                    bearer => CreateAuthenticatedTransferClient(host, bearer));
 
                await Task.Yield();
 
                return serverClient;
            }
            catch
            {
                await serviceProvider.DisposeAsync().ConfigureAwait(false);
                throw;
            }
        }
 
        IRestServerClient CreateAuthenticatedTransferClient(Uri host, string bearer)
        {
            var restClient = restClientFactory.CreateFromToken(
                host,
                new TokenResponse
                {
                    Bearer = bearer,
                });
 
            return restClient;
        }
    }
}