RelativityTransferHost
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Relativity.Transfer
{
public class RelativityTransferHost : IRelativityTransferHost, IDisposable
{
private readonly ITransferLog transferLog;
private readonly ITransferClientFactory clientFactory;
private bool disposed;
public RelativityConnectionInfo ConnectionInfo { get; }
public RelativityTransferHost(RelativityConnectionInfo connectionInfo, ITransferLog log)
: this(connectionInfo, log, new TransferClientFactory(connectionInfo, log))
{
}
public RelativityTransferHost(RelativityConnectionInfo connectionInfo, ITransferLog log, ITransferClientFactory clientFactory)
{
if (connectionInfo == null)
throw new ArgumentNullException("connectionInfo");
if (log == null)
throw new ArgumentNullException("log");
if (clientFactory == null)
throw new ArgumentNullException("clientFactory");
ConnectionInfo = connectionInfo;
disposed = false;
transferLog = log;
this.clientFactory = clientFactory;
AppDomain.CurrentDomain.AssemblyResolve += OnAssemblyResolve;
LogVersionInfo();
}
public void Clear()
{
TransferCache.Clear();
}
public Task<IEnumerable<IConnectionCheckResult>> ConnectionChecksAsync(DiagnosticsConfiguration configuration)
{
return ConnectionChecksAsync(configuration, CancellationToken.None);
}
[AsyncStateMachine(typeof(<ConnectionChecksAsync>d__10))]
public Task<IEnumerable<IConnectionCheckResult>> ConnectionChecksAsync(DiagnosticsConfiguration configuration, CancellationToken token)
{
<ConnectionChecksAsync>d__10 stateMachine = default(<ConnectionChecksAsync>d__10);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<IEnumerable<IConnectionCheckResult>>.Create();
stateMachine.<>4__this = this;
stateMachine.configuration = configuration;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public ITransferClient CreateClient(ClientConfiguration configuration)
{
return clientFactory.CreateTransferClient(configuration);
}
[AsyncStateMachine(typeof(<CreateClientAsync>d__12))]
public Task<ITransferClient> CreateClientAsync()
{
<CreateClientAsync>d__12 stateMachine = default(<CreateClientAsync>d__12);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ITransferClient>.Create();
stateMachine.<>4__this = this;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<CreateClientAsync>d__13))]
public Task<ITransferClient> CreateClientAsync(CancellationToken token)
{
<CreateClientAsync>d__13 stateMachine = default(<CreateClientAsync>d__13);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ITransferClient>.Create();
stateMachine.<>4__this = this;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<CreateClientAsync>d__14))]
public Task<ITransferClient> CreateClientAsync(ClientConfiguration configuration)
{
<CreateClientAsync>d__14 stateMachine = default(<CreateClientAsync>d__14);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ITransferClient>.Create();
stateMachine.<>4__this = this;
stateMachine.configuration = configuration;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<CreateClientAsync>d__15))]
public Task<ITransferClient> CreateClientAsync(ClientConfiguration configuration, CancellationToken token)
{
<CreateClientAsync>d__15 stateMachine = default(<CreateClientAsync>d__15);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ITransferClient>.Create();
stateMachine.<>4__this = this;
stateMachine.configuration = configuration;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<CreateClientAsync>d__16))]
public Task<ITransferClient> CreateClientAsync(ClientConfiguration configuration, ITransferClientStrategy strategy)
{
<CreateClientAsync>d__16 stateMachine = default(<CreateClientAsync>d__16);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ITransferClient>.Create();
stateMachine.<>4__this = this;
stateMachine.configuration = configuration;
stateMachine.strategy = strategy;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<CreateClientAsync>d__17))]
public Task<ITransferClient> CreateClientAsync(ClientConfiguration configuration, ITransferClientStrategy strategy, CancellationToken token)
{
<CreateClientAsync>d__17 stateMachine = default(<CreateClientAsync>d__17);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ITransferClient>.Create();
stateMachine.<>4__this = this;
stateMachine.configuration = configuration;
stateMachine.strategy = strategy;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public Task<Workspace> GetWorkspaceAsync()
{
return GetWorkspaceAsync(new ClientConfiguration());
}
public Task<Workspace> GetWorkspaceAsync(CancellationToken token)
{
return GetWorkspaceAsync(new ClientConfiguration(), token);
}
public Task<Workspace> GetWorkspaceAsync(ClientConfiguration configuration)
{
return GetWorkspaceAsync(configuration, CancellationToken.None);
}
public Task<Workspace> GetWorkspaceAsync(ClientConfiguration configuration, CancellationToken token)
{
return GetWorkspaceAsync(ConnectionInfo.WorkspaceId, configuration, token);
}
public Task<Workspace> GetWorkspaceAsync(int workspaceArtifactId, CancellationToken token)
{
return GetWorkspaceAsync(workspaceArtifactId, new ClientConfiguration(), token);
}
[AsyncStateMachine(typeof(<GetWorkspaceAsync>d__23))]
public Task<Workspace> GetWorkspaceAsync(int workspaceArtifactId, ClientConfiguration configuration, CancellationToken token)
{
<GetWorkspaceAsync>d__23 stateMachine = default(<GetWorkspaceAsync>d__23);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<Workspace>.Create();
stateMachine.<>4__this = this;
stateMachine.workspaceArtifactId = workspaceArtifactId;
stateMachine.configuration = configuration;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
public IFileStorageSearch CreateFileStorageSearch()
{
return CreateFileStorageSearch(new ClientConfiguration());
}
public IFileStorageSearch CreateFileStorageSearch(int maxRetryAttempts, double timeoutSeconds)
{
ClientConfiguration configuration = new ClientConfiguration {
MaxHttpRetryAttempts = maxRetryAttempts,
HttpTimeoutSeconds = timeoutSeconds
};
return CreateFileStorageSearch(configuration);
}
public IFileStorageSearch CreateFileStorageSearch(ClientConfiguration configuration)
{
if (configuration == null)
throw new ArgumentNullException("configuration");
return new FileStorageSearch(ConnectionInfo, configuration, transferLog);
}
public Task VersionCheckAsync()
{
return VersionCheckAsync(new ClientConfiguration());
}
public Task VersionCheckAsync(CancellationToken token)
{
return VersionCheckAsync(new ClientConfiguration(), token);
}
public Task VersionCheckAsync(ClientConfiguration configuration)
{
return VersionCheckAsync(configuration, CancellationToken.None);
}
public Task VersionCheckAsync(ClientConfiguration configuration, CancellationToken token)
{
return VersionCheckAsync(ConnectionInfo, configuration, transferLog, token);
}
public static Task VersionCheckAsync(RelativityConnectionInfo connectionInfo)
{
return VersionCheckAsync(connectionInfo, CancellationToken.None);
}
public static Task VersionCheckAsync(RelativityConnectionInfo connectionInfo, CancellationToken token)
{
return VersionCheckAsync(connectionInfo, new ClientConfiguration(), token);
}
public static Task VersionCheckAsync(RelativityConnectionInfo connectionInfo, ClientConfiguration configuration)
{
return VersionCheckAsync(connectionInfo, configuration, CancellationToken.None);
}
public static Task VersionCheckAsync(RelativityConnectionInfo connectionInfo, ClientConfiguration configuration, CancellationToken token)
{
return VersionCheckAsync(connectionInfo, configuration, null, token);
}
public static Task VersionCheckAsync(RelativityConnectionInfo connectionInfo, ITransferLog log, CancellationToken token)
{
return VersionCheckAsync(connectionInfo, new ClientConfiguration(), log, token);
}
[AsyncStateMachine(typeof(<VersionCheckAsync>d__37))]
public static Task VersionCheckAsync(RelativityConnectionInfo connectionInfo, ClientConfiguration configuration, ITransferLog log, CancellationToken token)
{
<VersionCheckAsync>d__37 stateMachine = default(<VersionCheckAsync>d__37);
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.connectionInfo = connectionInfo;
stateMachine.configuration = configuration;
stateMachine.log = log;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
private static Assembly OnAssemblyResolve(object sender, ResolveEventArgs args)
{
AssemblyName assemblyName = new AssemblyName(args.Name);
if (string.Compare(assemblyName.Name, "Newtonsoft.Json", StringComparison.OrdinalIgnoreCase) == 0) {
string text = Path.Combine(GlobalSettings.Instance.PluginDirectory, assemblyName.Name + ".dll");
if (File.Exists(text))
return Assembly.LoadFrom(text);
}
return null;
}
private static ServiceFactory CreateServiceFactory(RelativityConnectionInfo connectionInfo, ClientConfiguration configuration, ITransferLog log)
{
return new ServiceFactory(connectionInfo, configuration, log);
}
private void Dispose(bool disposing)
{
if (!disposed) {
AppDomain.CurrentDomain.AssemblyResolve -= OnAssemblyResolve;
IDisposable disposable = transferLog;
if (disposing)
disposable?.Dispose();
disposed = true;
}
}
private void LogVersionInfo()
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
transferLog.LogInformation($"""{executingAssembly.GetName().Version}""", Array.Empty<object>());
}
}
}