public void TestConnectionWrapperCheckValuesAre()
{
var wrapper = new ConnectionWrapper();
Mock <IConfiguration> mockAStorage = new Mock <IConfiguration>();
APIConnectionInformation info = new APIConnectionInformation();
info.Token = "Token";
info.ApiUri = "https://apiuri.com";
info.StorageUri = "https://storageuri.com";
info.AccountEmail = "*****@*****.**";
info.ForcePathStyle = true;
info.StorageUnsafeSsl = true;
mockAStorage.Setup(foo => foo.ApiConnection).Returns(info);
IConfiguration config = mockAStorage.Object;
QarnotSDK.Connection connection = wrapper.CreateConnection(config);
Assert.AreEqual("Token", connection.Token);
Assert.AreEqual(new Uri("https://apiuri.com/"), connection.Uri);
Assert.AreEqual(new Uri("https://storageuri.com/"), connection.StorageUri);
Assert.AreEqual(true, connection.ForceStoragePathStyle);
Assert.AreEqual("*****@*****.**", connection.StorageAccessKey);
Assert.IsInstanceOf <UnsafeS3HttpClientFactory>(connection.S3HttpClientFactory);
}
private QPool CreatePool(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
QarnotSDK.QPool pool = new QarnotSDK.QPool(connect, config.Name, config.Profile, config.InstanceCount, config.Shortname, config.TasksDefaultWaitForPoolResourcesSynchronization);
pool.SetTags(config.Tags.ToArray());
pool.Resources = this.Tools.CreateResources(config.Resources, connect, ct);
foreach (var item in this.Tools.CreateConstants(config.Constants))
{
pool.SetConstant(item.Key, item.Value);
}
foreach (var item in this.Tools.CreateConstraints(config.Constraints))
{
pool.SetConstraint(item.Key, item.Value);
}
foreach (var item in this.Tools.CreateLabels(config.Labels))
{
pool.SetLabel(item.Key, item.Value);
}
pool.IsElastic = config.IsElastic;
pool.ElasticMinimumTotalNodes = config.ElasticMinimumTotalNodes == default(int) ? pool.ElasticMinimumTotalNodes : config.ElasticMinimumTotalNodes;
pool.ElasticMaximumTotalNodes = config.ElasticMaximumTotalNodes == default(int) ? pool.ElasticMaximumTotalNodes : config.ElasticMaximumTotalNodes;
pool.ElasticMinimumIdlingNodes = config.ElasticMinimumIdlingNodes == default(int) ? pool.ElasticMinimumIdlingNodes : config.ElasticMinimumIdlingNodes;
pool.ElasticResizePeriod = config.ElasticResizePeriod == default(int) ? pool.ElasticResizePeriod : config.ElasticResizePeriod;
pool.ElasticResizeFactor = config.ElasticResizeFactor == default(int) ? pool.ElasticResizeFactor : config.ElasticResizeFactor;
pool.ElasticMinimumIdlingTime = config.ElasticMinimumIdlingTime == default(int) ? pool.ElasticMinimumIdlingTime : config.ElasticMinimumIdlingTime;
CLILogs.Info("create pool");
return(pool);
}
public QAbstractStorage CreateResult(string name, QarnotSDK.Connection connection, CancellationToken ct)
{
if (!string.IsNullOrEmpty(name))
{
return(connection.CreateBucketAsync(name, ct).Result as QAbstractStorage);
}
return(null);
}
private async Task <QBucket> CreateBucket(BucketConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
var bucket = await connect.CreateBucketAsync(config.Name, ct);
if (config.CacheTTL.HasValue)
{
bucket.WithCacheTTL(config.CacheTTL.Value);
}
return(bucket);
}
private async Task <QTask> CreateTask(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
QarnotSDK.QTask task = null;
if (config.InstanceCount > 0)
{
task = await this.CreateInstanceTaskAsync(config, connect);
}
else
{
task = await this.CreateRangeTaskAsync(config, connect);
}
task.SetTags(config.Tags.ToArray());
task.Resources = this.Tools.CreateResources(config.Resources, connect, ct);
task.Results = this.Tools.CreateResult(config.Result, connect, ct);
this.Tools.CreateConstants(config.Constants).ToList().ForEach(item => task.SetConstant(item.Key, item.Value));
foreach (var item in this.Tools.CreateConstraints(config.Constraints))
{
task.SetConstraint(item.Key, item.Value);
}
foreach (var item in this.Tools.CreateLabels(config.Labels))
{
task.SetLabel(item.Key, item.Value);
}
task.SetTaskDependencies(config.Dependents.Select(id => new Guid(id)).ToArray());
task.ResultsWhitelist = config.Whitelist;
task.ResultsBlacklist = config.Blacklist;
if (config.MaxRetriesPerInstance.HasValue)
{
task.MaxRetriesPerInstance = config.MaxRetriesPerInstance.Value;
}
if (config.ExportApiAndStorageCredentialsInEnvironment.HasValue)
{
task.Privileges.ExportApiAndStorageCredentialsInEnvironment = config.ExportApiAndStorageCredentialsInEnvironment.Value;
}
if (config.DefaultResourcesCacheTTLSec.HasValue)
{
task.DefaultResourcesCacheTTLSec = config.DefaultResourcesCacheTTLSec.Value;
}
CLILogs.Info("create task");
return(task);
}
private QPool CreatePool(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
QarnotSDK.QPool pool = new QarnotSDK.QPool(connect, config.Name, config.Profile, config.InstanceCount, config.Shortname, config.TasksDefaultWaitForPoolResourcesSynchronization);
pool.SetTags(config.Tags.ToArray());
pool.Resources = this.Tools.CreateResources(config.Resources, connect, ct);
foreach (var item in this.Tools.CreateConstants(config.Constants))
{
pool.SetConstant(item.Key, item.Value);
}
foreach (var item in this.Tools.CreateConstraints(config.Constraints))
{
pool.SetConstraint(item.Key, item.Value);
}
foreach (var item in this.Tools.CreateLabels(config.Labels))
{
pool.SetLabel(item.Key, item.Value);
}
pool.IsElastic = config.IsElastic;
pool.ElasticMinimumTotalSlots = config.ElasticMinimumTotalSlots == default(int) ? pool.ElasticMinimumTotalSlots : config.ElasticMinimumTotalSlots;
pool.ElasticMaximumTotalSlots = config.ElasticMaximumTotalSlots == default(int) ? pool.ElasticMaximumTotalSlots : config.ElasticMaximumTotalSlots;
pool.ElasticMinimumIdlingSlots = config.ElasticMinimumIdlingSlots == default(int) ? pool.ElasticMinimumIdlingSlots : config.ElasticMinimumIdlingSlots;
pool.ElasticResizePeriod = config.ElasticResizePeriod == default(int) ? pool.ElasticResizePeriod : config.ElasticResizePeriod;
pool.ElasticResizeFactor = config.ElasticResizeFactor == default(int) ? pool.ElasticResizeFactor : config.ElasticResizeFactor;
pool.ElasticMinimumIdlingTime = config.ElasticMinimumIdlingTime == default(int) ? pool.ElasticMinimumIdlingTime : config.ElasticMinimumIdlingTime;
if (config.ExportApiAndStorageCredentialsInEnvironment.HasValue)
{
pool.Privileges.ExportApiAndStorageCredentialsInEnvironment = config.ExportApiAndStorageCredentialsInEnvironment.Value;
}
if (config.DefaultResourcesCacheTTLSec.HasValue)
{
pool.DefaultResourcesCacheTTLSec = config.DefaultResourcesCacheTTLSec.Value;
}
CLILogs.Info("create pool");
return(pool);
}
private async Task <QJob> CreateJobAsync(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
CLILogs.Info("create job");
QPool pool = null;
if (!string.IsNullOrEmpty(config.PoolUuidOrShortname))
{
pool = await connect.RetrievePoolByUuidAsync(config.PoolUuidOrShortname, ct);
}
QJob job = new QJob(connect, config.Name, pool, config.Shortname, config.IsDependents);
if (config.MaximumWallTime.HasValue && config.MaximumWallTime.Value != default(TimeSpan))
{
job.MaximumWallTime = config.MaximumWallTime.Value;
}
return(job);
}
private async Task <QTask> CreateTask(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
QarnotSDK.QTask task = null;
if (config.InstanceCount > 0)
{
task = await this.CreateInstanceTaskAsync(config, connect);
}
else
{
task = await this.CreateRangeTaskAsync(config, connect);
}
task.SetTags(config.Tags.ToArray());
task.Resources = this.Tools.CreateResources(config.Resources, connect, ct);
task.Results = this.Tools.CreateResult(config.Result, connect, ct);
this.Tools.CreateConstants(config.Constants).ToList().ForEach(item => task.SetConstant(item.Key, item.Value));
foreach (var item in this.Tools.CreateConstraints(config.Constraints))
{
task.SetConstraint(item.Key, item.Value);
}
foreach (var item in this.Tools.CreateLabels(config.Labels))
{
task.SetLabel(item.Key, item.Value);
}
task.SetTaskDependencies(config.Dependents.Select(id => new Guid(id)).ToArray());
task.ResultsWhitelist = config.Whitelist;
task.ResultsBlacklist = config.Blacklist;
CLILogs.Info("create task");
return(task);
}
private async Task <QTask> CreateRangeTaskAsync(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct = default(CancellationToken))
{
AdvancedRanges range = new AdvancedRanges(config.Range);
if (!string.IsNullOrEmpty(config.JobUuidOrShortname))
{
QarnotSDK.QJob job;
if (Guid.TryParse(config.JobUuidOrShortname, out var jobUuid))
{
job = await connect.RetrieveJobByUuidAsync(config.JobUuidOrShortname, ct);
}
else
{
job = await connect.RetrieveJobByShortnameAsync(config.JobUuidOrShortname, ct);
}
return(new QarnotSDK.QTask(connect, config.Name, job, range, config.Shortname));
}
else if (!string.IsNullOrEmpty(config.PoolUuidOrShortname))
{
QarnotSDK.QPool pool;
if (Guid.TryParse(config.PoolUuidOrShortname, out var poolUuid))
{
pool = new QarnotSDK.QPool(connect, poolUuid);
}
else
{
pool = await connect.RetrievePoolByShortnameAsync(config.PoolUuidOrShortname, ct);
}
return(new QarnotSDK.QTask(connect, config.Name, pool, range, config.Shortname, config.WaitForPoolResourcesSynchronization));
}
return(new QarnotSDK.QTask(connect, config.Name, config.Profile, range, config.Shortname));
}
public async Task <List <QarnotSDK.QPool> > RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
DefaultRunConfiguration config = configuration as DefaultRunConfiguration;
QarnotSDK.QPool pool = null;
List <QPool> listPool = null;
if (!string.IsNullOrEmpty(config.Name))
{
CLILogs.Debug("Retrieve QPools by name : " + config.Name);
pool = await connection.RetrievePoolByNameAsync(config.Name, cancellationToken : ct);
}
else if (!string.IsNullOrEmpty(config.Id))
{
CLILogs.Debug("Retrieve QPool by Uuid : " + config.Id);
pool = await connection.RetrievePoolByUuidAsync(config.Id, cancellationToken : ct);
}
else if (config.Tags != null && config.Tags.Count > 0)
{
if (config.TagsIntersect)
{
CLILogs.Debug("Retrieve QPools by Tags Intersect : " + config.Tags.ToString());
var poolTagFilter = new QDataDetail <QPool>();
var filterList = config.Tags.Select(tag => QFilter <QPool> .Contains(t => t.Tags, tag));
listPool = await connection.RetrievePoolsAsync(poolTagFilter, cancellationToken : ct);
}
else
{
CLILogs.Debug("Retrieve QPools by Tags : " + config.Tags.ToString());
listPool = await connection.RetrievePoolsByTagsAsync(config.Tags, cancellationToken : ct);
}
}
else
{
CLILogs.Debug("Retrieve all the QPools");
listPool = await connection.RetrievePoolsAsync(cancellationToken : ct);
}
return(listPool ?? new List <QPool>()
{
pool
});
}
public async Task <List <QarnotSDK.QBucket> > RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
BucketConfiguration config = configuration as BucketConfiguration;
if (config != null && !string.IsNullOrEmpty(config.Name))
{
CLILogs.Debug("Retrieve QBucket by Name : " + config.Name);
return(new List <QBucket>()
{
await connection.RetrieveBucketAsync(config.Name, cancellationToken : ct),
});
}
else
{
CLILogs.Debug("Retrieve all the QBuckets");
return(await connection.RetrieveBucketsAsync(cancellationToken : ct));
}
}
public async Task <List <QarnotSDK.QTask> > RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
DefaultRunConfiguration config = configuration as DefaultRunConfiguration;
QarnotSDK.QTask task = null;
List <QTask> listTask = null;
if (!string.IsNullOrEmpty(config.Name))
{
CLILogs.Debug("Retrieve QTasks by Name : " + config.Name);
task = await connection.RetrieveTaskByNameAsync(config.Name, cancellationToken : ct);
}
else if (!string.IsNullOrEmpty(config.Id))
{
CLILogs.Debug("Retrieve QTask by Uuid : " + config.Id);
task = await connection.RetrieveTaskByUuidAsync(config.Id, cancellationToken : ct);
}
else if (config.Tags != null && config.Tags.Count > 0)
{
if (config.TagsIntersect)
{
var taskTagFilter = new QDataDetail <QTask>();
var filterList = config.Tags.Select(tag => QFilter <QTask> .Contains(t => t.Tags, tag));
taskTagFilter.Filter = QFilter <QTask> .And(filterList.ToArray());
listTask = await connection.RetrieveTasksAsync(taskTagFilter, cancellationToken : ct);
}
else
{
CLILogs.Debug("Retrieve QTasks by Tags : " + config.Tags.ToString());
listTask = await connection.RetrieveTasksByTagsAsync(config.Tags, cancellationToken : ct);
}
}
else
{
CLILogs.Debug("Retrieve all the QTasks");
listTask = await connection.RetrieveTasksAsync(cancellationToken : ct);
}
return(listTask ?? new List <QTask>()
{
task
});
}
private async Task <QBucket> CreateBucket(BucketConfiguration config, QarnotSDK.Connection connect, CancellationToken ct)
{
return(await connect.CreateBucketAsync(config.Name, ct));
}
private async Task <QTask> CreateInstanceTaskAsync(CreateConfiguration config, QarnotSDK.Connection connect, CancellationToken ct = default(CancellationToken))
{
if (!string.IsNullOrEmpty(config.JobUuid))
{
QarnotSDK.QJob job = await connect.RetrieveJobByUuidAsync(config.JobUuid, ct);
return(new QarnotSDK.QTask(connect, config.Name, job, config.InstanceCount, config.Shortname));
}
else if (!string.IsNullOrEmpty(config.PoolUuid))
{
QarnotSDK.QPool pool = new QarnotSDK.QPool(connect, new Guid(config.PoolUuid));
return(new QarnotSDK.QTask(connect, config.Name, pool, config.InstanceCount, config.Shortname, config.WaitForPoolResourcesSynchronization));
}
return(new QarnotSDK.QTask(connect, config.Name, config.Profile, config.InstanceCount, config.Shortname));
}
public async override Task <CommandValues.GenericInfoCommandValue> Create(IConfiguration iconfig, QarnotSDK.Connection connect, CancellationToken ct)
{
CreateConfiguration config = iconfig as CreateConfiguration;
QTask task = await this.CreateTask(config, connect, ct);
await this.LaunchTaskAsync(task, ct);
await this.LaunchPostSubmitTaskMethodsAsync(task, config, ct);
return(this.PrintTaskInformation(task));
}
public async Task <QarnotSDK.QBucket> RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
BucketConfiguration config = configuration as BucketConfiguration;
CLILogs.Debug("Retrieve QBucket by Name : " + config.Name);
return(await connection.RetrieveBucketAsync(config.Name, ct));
}
public abstract Task <CommandValues.GenericInfoCommandValue> Create(IConfiguration iconfig, QarnotSDK.Connection connect, CancellationToken ct);
public async Task <QarnotSDK.UserInformation> RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
AccountConfiguration config = configuration as AccountConfiguration;
return(await connection.RetrieveUserInformationAsync(config.GetBucket, cancellationToken : ct));
}
public async override Task <CommandValues.GenericInfoCommandValue> Create(IConfiguration iconfig, QarnotSDK.Connection connect, CancellationToken ct)
{
CreateConfiguration config = iconfig as CreateConfiguration;
QJob job = await this.CreateJobAsync(config, connect, ct);
await this.LaunchJobAsync(job, ct);
return(this.PrintJobInformation(job));
}
public async Task <QarnotSDK.ApiSettings> RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
return(await connection.RetrieveApiSettingsAsync(cancellationToken : ct));
}
public async override Task <CommandValues.GenericInfoCommandValue> Create(IConfiguration iconfig, QarnotSDK.Connection connect, CancellationToken ct)
{
BucketConfiguration config = iconfig as BucketConfiguration;
if (!config.ApiConnection.DisableBucketPathsSanitization &&
(PathSanitization.IsThePathInvalid(config.RemoteRelativePath)))
{
return(new CommandValues.GenericInfoCommandValue()
{
Uuid = config.Name,
Message = "Creation failed. Invalid remote path",
});
}
QBucket bucket = await this.CreateBucket(config, connect, ct);
await this.LaunchBucket(bucket, ct);
List <Task> listOfTask = new List <Task>();
listOfTask.AddRange(config.LocalPathFiles.Select(localFile => bucket.UploadFileAsync(localFile, config.RemoteRelativePath, cancellationToken: ct)));
listOfTask.AddRange(config.LocalPathFolders.Select(localFolder => bucket.UploadFolderAsync(localFolder, config.RemoteRelativePath, cancellationToken: ct)));
await Task.WhenAll(listOfTask);
return(this.PrintBucketInformation(bucket));
}
public async Task <List <QarnotSDK.QJob> > RetrieveAsync(IConfiguration configuration, QarnotSDK.Connection connection, CancellationToken ct)
{
DefaultRunConfiguration config = configuration as DefaultRunConfiguration;
QarnotSDK.QJob job = null;
List <QJob> listJob = null;
if (!string.IsNullOrEmpty(config.Name))
{
CLILogs.Debug("Retrieve QJobs by name : " + config.Name);
QDataDetail <QJob> level = new QDataDetail <QJob>()
{
Filter = QFilter <QJob> .Eq(t => t.Name, config.Name),
};
listJob = await connection.RetrieveJobsAsync(level, cancellationToken : ct);
}
else if (!string.IsNullOrEmpty(config.Id))
{
CLILogs.Debug("Retrieve QJob by Uuid : " + config.Id);
job = await connection.RetrieveJobByUuidAsync(config.Id, cancellationToken : ct);
}
else
{
CLILogs.Debug("Retrieve all the QJobs");
listJob = await connection.RetrieveJobsAsync(cancellationToken : ct);
}
return(listJob ?? new List <QJob>()
{
job
});
}
public async override Task <CommandValues.GenericInfoCommandValue> Create(IConfiguration iconfig, QarnotSDK.Connection connect, CancellationToken ct)
{
CreateConfiguration config = iconfig as CreateConfiguration;
QarnotSDK.QPool pool = this.CreatePool(config, connect, ct);
await this.LaunchPoolAsync(pool, ct);
return(this.PrintPoolInformation(pool));
}
public List <QAbstractStorage> CreateResources(List <string> names, QarnotSDK.Connection connection, CancellationToken ct)
{
return(names.Select(name => connection.CreateBucketAsync(name, ct).Result as QAbstractStorage).ToList());
}
