RestServerClientFactory.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
 
namespace Tgstation.Server.Client
{
    public sealed class RestServerClientFactory : IRestServerClientFactory
    {
        internal static IApiClientFactory ApiClientFactory { get; set; }
 
        readonly ProductHeaderValue productHeaderValue;
 
        static RestServerClientFactory()
        {
            ApiClientFactory = new ApiClientFactory();
        }
 
        public RestServerClientFactory(ProductHeaderValue productHeaderValue)
        {
            this.productHeaderValue = productHeaderValue ?? throw new ArgumentNullException(nameof(productHeaderValue));
        }
 
        public ValueTask<IRestServerClient> CreateFromLogin(
            Uri host,
            string username,
            string password,
            IEnumerable<IRequestLogger>? requestLoggers = null,
            TimeSpan? timeout = null,
            bool attemptLoginRefresh = true,
            CancellationToken cancellationToken = default)
        {
            if (host == null)
                throw new ArgumentNullException(nameof(host));
            if (username == null)
                throw new ArgumentNullException(nameof(username));
            if (password == null)
                throw new ArgumentNullException(nameof(password));
 
            var loginHeaders = new ApiHeaders(productHeaderValue, username, password);
            return CreateWithNewToken(
                host,
                loginHeaders,
                requestLoggers,
                timeout,
                attemptLoginRefresh,
                cancellationToken);
        }
 
        public ValueTask<IRestServerClient> CreateFromOAuth(
            Uri host,
            string oAuthCode,
            OAuthProvider oAuthProvider,
            IEnumerable<IRequestLogger>? requestLoggers = null,
            TimeSpan? timeout = null,
            CancellationToken cancellationToken = default)
        {
            if (host == null)
                throw new ArgumentNullException(nameof(host));
            if (oAuthCode == null)
                throw new ArgumentNullException(nameof(oAuthCode));
 
            var loginHeaders = new ApiHeaders(productHeaderValue, oAuthCode, oAuthProvider);
            return CreateWithNewToken(
                host,
                loginHeaders,
                requestLoggers,
                timeout,
                false,
                cancellationToken);
        }
 
        public IRestServerClient CreateFromToken(Uri host, TokenResponse token)
        {
            if (host == null)
                throw new ArgumentNullException(nameof(host));
            if (token == null)
                throw new ArgumentNullException(nameof(token));
            if (token.Bearer == null)
                throw new InvalidOperationException("token.Bearer should not be null!");
 
            var serverClient = new RestServerClient(
                ApiClientFactory.CreateApiClient(
                    host,
                    new ApiHeaders(
                        productHeaderValue,
                        token),
                    null,
                    false));
            return serverClient;
        }
 
        public async ValueTask<ServerInformationResponse> GetServerInformation(
            Uri host,
            IEnumerable<IRequestLogger>? requestLoggers = null,
            TimeSpan? timeout = null,
            CancellationToken cancellationToken = default)
        {
            await using var api = ApiClientFactory.CreateApiClient(
                host,
                new ApiHeaders(
                    productHeaderValue,
                    new TokenResponse
                    {
                        Bearer = "unused",
                    }),
                null,
                true);
 
            if (requestLoggers != null)
                foreach (var requestLogger in requestLoggers)
                    api.AddRequestLogger(requestLogger);
 
            if (timeout.HasValue)
                api.Timeout = timeout.Value;
 
            return await api.Read<ServerInformationResponse>(Routes.ApiRoot, cancellationToken).ConfigureAwait(false);
        }
 
        async ValueTask<IRestServerClient> CreateWithNewToken(
            Uri host,
            ApiHeaders loginHeaders,
            IEnumerable<IRequestLogger>? requestLoggers,
            TimeSpan? timeout,
            bool attemptLoginRefresh,
            CancellationToken cancellationToken)
        {
            requestLoggers ??= Enumerable.Empty<IRequestLogger>();
 
            TokenResponse token;
            await using (var api = ApiClientFactory.CreateApiClient(host, loginHeaders, null, false))
            {
                foreach (var requestLogger in requestLoggers)
                    api.AddRequestLogger(requestLogger);
 
                if (timeout.HasValue)
                    api.Timeout = timeout.Value;
                token = await api.Update<TokenResponse>(Routes.ApiRoot, cancellationToken).ConfigureAwait(false);
            }
 
            var apiHeaders = new ApiHeaders(productHeaderValue, token);
            var client = new RestServerClient(
                ApiClientFactory.CreateApiClient(
                    host,
                    apiHeaders,
                    attemptLoginRefresh ? loginHeaders : null,
                    false));
            if (timeout.HasValue)
                client.Timeout = timeout.Value;
 
            foreach (var requestLogger in requestLoggers)
                client.AddRequestLogger(requestLogger);
 
            return client;
        }
    }
}