ResourcePoolService
using Relativity.Transfer.Dto;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
namespace Relativity.Transfer
{
internal class ResourcePoolService : IResourcePoolService
{
private readonly RelativityConnectionInfo connectionInfo;
private readonly ITransferLog transferLog;
public RelativityConnectionInfo ConnectionInfo => connectionInfo;
public int MaxRetryAttempts { get; set; }
public double TimeoutSeconds { get; set; }
public ResourcePoolService(RelativityConnectionInfo connectionInfo)
: this(connectionInfo, new NullTransferLog())
{
}
public ResourcePoolService(RelativityConnectionInfo connectionInfo, ITransferLog log)
: this(connectionInfo, log, 5, 300)
{
}
public ResourcePoolService(RelativityConnectionInfo connectionInfo, ITransferLog log, int maxRetryAttempts, double timeoutSeconds)
{
if (connectionInfo == null)
throw new ArgumentNullException("connectionInfo");
if (log == null)
throw new ArgumentNullException("log");
this.connectionInfo = connectionInfo;
transferLog = log;
MaxRetryAttempts = maxRetryAttempts;
TimeoutSeconds = timeoutSeconds;
}
public Task<IEnumerable<ResourcePool>> GetResourcePoolsAsync(CancellationToken token)
{
return GetResourcePoolsAsync(null, token);
}
[AsyncStateMachine(typeof(<GetResourcePoolAsync>d__16))]
public Task<ResourcePool> GetResourcePoolAsync(string name, CancellationToken token)
{
<GetResourcePoolAsync>d__16 stateMachine = default(<GetResourcePoolAsync>d__16);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<ResourcePool>.Create();
stateMachine.<>4__this = this;
stateMachine.name = name;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
[AsyncStateMachine(typeof(<GetResourcePoolsAsync>d__17))]
public Task<IEnumerable<ResourcePool>> GetResourcePoolsAsync(string condition, CancellationToken token)
{
<GetResourcePoolsAsync>d__17 stateMachine = default(<GetResourcePoolsAsync>d__17);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<IEnumerable<ResourcePool>>.Create();
stateMachine.<>4__this = this;
stateMachine.condition = condition;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
public Task<IEnumerable<ResourceServer>> GetResourceServersAsync(ResourcePool pool, CancellationToken token)
{
if (pool == null)
throw new ArgumentNullException("pool");
return GetResourceServersAsync(pool, null, token);
}
[AsyncStateMachine(typeof(<GetResourceServersAsync>d__19))]
public Task<IEnumerable<ResourceServer>> GetResourceServersAsync(ResourcePool pool, string condition, CancellationToken token)
{
<GetResourceServersAsync>d__19 stateMachine = default(<GetResourceServersAsync>d__19);
stateMachine.<>t__builder = AsyncTaskMethodBuilder<IEnumerable<ResourceServer>>.Create();
stateMachine.<>4__this = this;
stateMachine.pool = pool;
stateMachine.token = token;
stateMachine.<>1__state = -1;
stateMachine.<>t__builder.Start(ref stateMachine);
return stateMachine.<>t__builder.Task;
}
private static ResourcePool CreateResourcePool(ResourcePoolDto dto)
{
return new ResourcePool {
ArtifactId = dto.ArtifactId,
Name = dto.Name
};
}
private static ResourceServer CreateResourceServer(ResourcePool pool, ResourceServerDto dto)
{
return new ResourceServer {
ArtifactId = dto.ArtifactId,
Name = dto.Name,
ResourcePool = pool,
ResourceServerType = new ResourceServerType {
ArtifactId = (dto.ServerType?.ArtifactId ?? 0),
Name = dto.ServerType?.Name
}
};
}
}
}