public virtual Task <T2> ExecuteAsync(T1 obj, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("print list"); T2 objToPrint = ListObj.CreateObj(obj) as T2; return(Task.FromResult(objToPrint)); }
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 virtual Task <CommandValues.UserInformationCommandValue> ExecuteAsync(UserInformation apiSettings, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("print Account info"); CommandValues.UserInformationCommandValue objToPrint = InfoObj.CreateObj(apiSettings) as CommandValues.UserInformationCommandValue; objToPrint.AccountInformation["Email"] = apiSettings.Email; objToPrint.AccountInformation["MaxInstances"] = apiSettings.MaxInstances.ToString(); objToPrint.AccountInformation["Quota Bucket Number"] = apiSettings.BucketCount.ToString() + "/" + apiSettings.MaxBucket.ToString(); if (iconfig.HumanReadable) { objToPrint.AccountInformation["Quota Bytes Bucket"] = BytesFormat.ConvertToHumanReadable(apiSettings.UsedQuotaBytesBucket) + "/" + BytesFormat.ConvertToHumanReadable(apiSettings.QuotaBytesBucket); } else { objToPrint.AccountInformation["Quota Bytes Bucket"] = apiSettings.UsedQuotaBytesBucket.ToString() + "/" + apiSettings.QuotaBytesBucket.ToString(); } objToPrint.AccountInformation["Quota Task Count"] = apiSettings.TaskCount.ToString() + "/" + apiSettings.MaxTask.ToString(); objToPrint.AccountInformation["Quota Running Task"] = apiSettings.RunningTaskCount.ToString() + "/" + apiSettings.MaxRunningTask.ToString(); objToPrint.AccountInformation["Quota Total Pool"] = apiSettings.PoolCount.ToString() + "/" + apiSettings.MaxPool.ToString(); objToPrint.AccountInformation["Quota Running Pool"] = apiSettings.RunningPoolCount.ToString() + "/" + apiSettings.MaxRunningPool.ToString(); objToPrint.AccountInformation["Quota Running Instances"] = apiSettings.RunningInstanceCount.ToString() + "/" + apiSettings.MaxInstances.ToString(); objToPrint.AccountInformation["Quota Running Cores"] = apiSettings.RunningCoreCount.ToString(); return(Task.FromResult(objToPrint)); }
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 virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QBucket bucket, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Bucket : Upload"); BucketConfiguration config = iconfig as BucketConfiguration; List <Task> listOfTask = new List <Task>(); if (!config.ApiConnection.DisableBucketPathsSanitization && (PathSanitization.IsThePathInvalid(config.RemoteRelativePath))) { return(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = "Upload failed. Invalid remote path", }); } if (!string.IsNullOrEmpty(config.String)) { CLILogs.Debug("Command Bucket : Upload String "); CLILogs.Debug(config.StringPath); await bucket.UploadStringAsync(config.String, config.StringPath, cancellationToken : ct); } 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(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = "Bucket Upload", }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QPool pool, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { PoolSetElasticSettingsConfiguration config = iconfig as PoolSetElasticSettingsConfiguration; CLILogs.Debug("Command pool : Pool name " + pool?.Name ?? config?.Name); CLILogs.Debug("Command pool : Set Pool Elastic info"); if (pool == default) { var message = "Elastic settings update failed. Pool not found"; throw new System.Exception(message); } 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; await pool.CommitAsync(ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = pool.Uuid.ToString(), Message = "Pool set ", }); }
public virtual async Task <CommandValues.BucketInfoCommandValue> ExecuteAsync(QBucket bucket, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Bucket : Info"); await bucket.UpdateAsync(ct); BucketConfiguration config = iconfig as BucketConfiguration; List <string> folderList = new List <string>(); string folder = config.RemoteRelativePath ?? ""; if (!config.ApiConnection.DisableBucketPathsSanitization && (PathSanitization.IsThePathInvalid(folder))) { return(null); } folderList = await ExtractBucketFilesInfoFromBucket(bucket, folder, ct, iconfig.HumanReadable); return(new CommandValues.BucketInfoCommandValue() { Shortname = bucket.Shortname, TotalFileCount = bucket.FileCount.ToString(), TotalUsedSpaceBytes = iconfig.HumanReadable ? this.ConvertBytes.ConvertToHumanReadable(bucket.UsedSpaceBytes, 2) : bucket.UsedSpaceBytes.ToString(), BucketFilesDetail = folderList, }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QBucket bucket, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Bucket : SyncFrom"); BucketConfiguration config = iconfig as BucketConfiguration; if (bucket == default) { var message = "Synchronization failed. Bucket not found"; throw new System.Exception(message); } string localFolderPath = config.LocalPathGet; bool donTDelete = config.DeleteFiles; string remoteFolderRelativePath = config.RemoteRelativePath; if (!config.ApiConnection.DisableBucketPathsSanitization && (PathSanitization.IsThePathInvalid(remoteFolderRelativePath))) { var message = "Synchronization failed. Invalid remote path"; throw new System.Exception(message); } CLILogs.Debug("Local path : " + localFolderPath); await bucket.SyncRemoteToLocalAsync(localFolderPath, ct, donTDelete, remoteFolderRelativePath); return(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = "Bucket sync to " + localFolderPath, }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QBucket bucket, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { BucketConfiguration config = iconfig as BucketConfiguration; if (bucket == default) { var message = "Removal failed. Bucket not found"; throw new System.Exception(message); } if (!config.ApiConnection.DisableBucketPathsSanitization && (config.RemoteRelativePaths.Any(remoteFile => PathSanitization.IsThePathInvalid(remoteFile)))) { var message = "Removal failed. Invalid remote path(s)"; throw new System.Exception(message); } CLILogs.Debug("Command Bucket : Remove entities " + string.Join(", ", config.RemoteRelativePaths)); string returnString = "Bucket delete paths : " + string.Join(", ", config.RemoteRelativePaths); await config.RemoteRelativePaths.ParallelForEachAsync(bucket.DeleteEntryAsync, 10, ct : ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = returnString, }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QTask task, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Task : Snapshot Task"); var config = iconfig as SnapshotConfiguration; if (task == default) { var message = "Snapshot failed. Task not found"; throw new System.Exception(message); } task.SnapshotWhitelist = config.Whitelist; task.SnapshotBlacklist = config.Blacklist; if (config.SnapshotPeriodicSec > 0) { await task.TriggerPeriodicSnapshotAsync(config.SnapshotPeriodicSec, config.Whitelist, config.Blacklist, cancellationToken : ct); } else { await task.TriggerSnapshotAsync(config.Whitelist, config.Blacklist, cancellationToken : ct); } return(new CommandValues.GenericInfoCommandValue() { Uuid = task.Uuid.ToString(), Message = "Task Snapshot", }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QTask task, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Task : Wait"); var config = iconfig as StdConfiguration; bool end = false; while (end == false) { if (config.Stdout) { var stdmessage = await task.FreshStdoutAsync(ct); if (!string.IsNullOrEmpty(stdmessage)) { CLILogs.Info("Stdout:" + Environment.NewLine + stdmessage.Replace("\\n", Environment.NewLine)); } } if (config.Stderr) { var stdmessage = await task.FreshStderrAsync(ct); if (!string.IsNullOrEmpty(stdmessage)) { CLILogs.Info("Stderr:" + Environment.NewLine + stdmessage.Replace("\\n", Environment.NewLine)); } } end = await task.WaitAsync(taskTimeoutSeconds : 2, ct : ct); } var info = new CommandValues.GenericInfoCommandValue(); info.Uuid = task.Uuid.ToString(); info.Message = "Task Wait end status : " + task.State; return(info); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QBucket bucket, IConfiguration iconfig, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Bucket : SyncTo"); BucketConfiguration config = iconfig as BucketConfiguration; string localFolderPath = config.LocalPathGet; bool donTDelete = config.DeleteFiles; string remoteFolderRelativePath = config.RemoteRelativePath; if (!config.ApiConnection.DisableBucketPathsSanitization && (PathSanitization.IsThePathInvalid(remoteFolderRelativePath))) { return(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = "Synchronization failed. Invalid remote path", }); } CLILogs.Debug("Local path : " + localFolderPath); await bucket.SyncLocalToRemoteAsync(localFolderPath, ct, donTDelete, remoteFolderRelativePath); return(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = localFolderPath + "send to Bucket", }); }
/// <summary> /// Set The connection Information to the computer. /// </summary> /// <param name="iconfig">Configuration Object.</param> public void SaveSettings(IConfiguration iconfig) { CLILogs.Debug("Set the config value"); string path = this.GetPath((LocalSetUpConfiguration)iconfig); this.SetConfigInformation(path, iconfig); }
public static void CreateOneLogger(CLILogs.LogsLevel level) { if (Verbose <= level && level < LogsLevel.NoVerbose) { Logs[level] = Printer.PrinterFactory.Factory(level, !NoColor); CLILogs.Debug("Verbose set " + Enum.GetName(typeof(LogsLevel), level)); } }
public static void DebugException(Exception ex) { CLILogs.Debug("InnerException : " + ex?.InnerException?.ToString()); CLILogs.Debug("StackTrace : " + ex?.StackTrace); CLILogs.Debug("Source : " + ex?.Source); CLILogs.Debug("Data : " + ex?.Data.ToString()); CLILogs.Debug("TargetSite : " + ex?.TargetSite?.ToString()); CLILogs.Error(ex?.Message); }
public static void IConfiguration(IConfiguration config) { var jd = new FormatterFactory.JsonFormatter(); CLILogs.Debug("Config format"); CLILogs.Debug("Type " + Enum.GetName(typeof(ConfigType), config.Type)); CLILogs.Debug("Command " + Enum.GetName(typeof(CommandApi), config.Command)); CLILogs.Debug(jd.Format(config)); }
/// <summary> /// Print the CommandLine help. /// </summary> /// <param name="parser">Parser used (CommandLine).</param> /// <param name="errs">Error list.</param> /// <param name="argv">argv list.</param> /// <typeparam name="T">The generic type parameter: Object to parser to get the usage.</typeparam> /// <returns>String usage.</returns> public string PrintHelp <T>(CommandLine.ParserResult <T> parser, System.Collections.Generic.IEnumerable <CommandLine.Error> errs, string[] argv) { // create logs if not already created CLILogs.CreateLoggers(); string helpText = PrintHelpErrorUsage(parser); ParseException ex = new ParseException(); // check if a "help" flag is used if (argv.Length > 1 && argv[1] == "help") { CLILogs.Usage(PrintHelpUsage(parser)); throw new ParseHelpException(); } if (errs == null) { CLILogs.Usage(helpText); throw ex; } if (errs.Any(x => x.Tag == CommandLine.ErrorType.VersionRequestedError)) { helpText = PrintHelpVersion(parser); ex = new ParseVersionException(); } else if (errs.Any(x => x.Tag == CommandLine.ErrorType.HelpRequestedError)) { helpText = PrintHelpUsage(parser); ex = new ParseHelpException(); } else if (errs.Any(x => x.Tag == CommandLine.ErrorType.HelpVerbRequestedError)) { helpText = PrintHelpVerbUsage(parser); ex = new ParseHelpException(); } else if (errs.Any(x => x.Tag == CommandLine.ErrorType.NoVerbSelectedError || x.Tag == CommandLine.ErrorType.BadVerbSelectedError)) { helpText = PrintHelpErrorVerbUsage(parser); string errorList = string.Empty; errs.ToList().ForEach(e => errorList += e.ToString()); ex = new ParseException(errorList); CLILogs.Debug("Parsing error : " + errorList); } else { string errorList = string.Empty; errs.ToList().ForEach(e => errorList += e.ToString()); ex = new ParseException(errorList); CLILogs.Debug("Parsing error : " + errorList); } CLILogs.Usage(helpText); throw ex; }
public virtual Task <T2> ExecuteAsync(T1 obj, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("print info"); if (objectTransformer != null) { objectTransformer.Transform(obj); } return(Task.FromResult <T2>(obj)); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QTask task, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Task : Delete"); await task.DeleteAsync(cancellationToken : ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = task.Uuid.ToString(), Message = "Task delete ", }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QPool pool, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command pool : delete"); await pool.DeleteAsync(ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = pool.Uuid.ToString(), Message = "Pool delete ", }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QJob job, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("command job : delete"); await job.DeleteAsync(cancellationToken : ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = job.Uuid.ToString(), Message = "Job delete ", }); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QBucket bucket, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Bucket : Delete"); await bucket.DeleteAsync(ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = bucket.Shortname, Message = "Bucket deleted", }); }
public virtual APIConnectionInformation ReadFile(string filePath) { if (string.IsNullOrEmpty(filePath)) { throw new FileNotFoundException(); } CLILogs.Debug("File info get " + filePath); string[] lines = File.ReadAllLines(filePath); return(this.ParseLines(lines)); }
private void ParseKeyValuePair(Dictionary <string, string> pairs, string line) { int position = line.IndexOf("="); if (position > 0) { var key = line.Substring(0, position); var value = line.Substring(position + 1); pairs[key] = value; CLILogs.Debug(" [" + key + "] = [" + value + "]"); } }
public static void CreateLoggers() { if (!LogSet) { LogSet = true; foreach (LogsLevel level in Enum.GetValues(typeof(LogsLevel))) { CreateOneLogger(level); } CLILogs.Debug("Set Console Color " + (!NoColor).ToString()); } }
private string CreateXML(object obj) { string jsonSerialize = JsonConvert.SerializeObject(obj); CLILogs.Debug(jsonSerialize); try { return(JsonConvert.DeserializeXNode(jsonSerialize, "Information", false).ToString()); } catch (Newtonsoft.Json.JsonSerializationException ex) { CLILogs.Error(ex.Message); return("Value not found"); } }
private Dictionary <string, string> ParseKeyValuePairs(List <string> lines, string name) { Dictionary <string, string> pairs = new Dictionary <string, string>(); if (lines == null) { return(pairs); } CLILogs.Debug(name + " find :"); lines.ForEach(line => ParseKeyValuePair(pairs, line)); return(pairs); }
public virtual async Task <CommandValues.GenericInfoCommandValue> ExecuteAsync(QJob job, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("command job : terminate"); if (job.State == QJobStates.Active) { await job.TerminateAsync(ct); return(new CommandValues.GenericInfoCommandValue() { Uuid = job.Uuid.ToString(), Message = "Job terminate ", }); } return(null); }
public virtual async Task <string> ExecuteAsync(QTask task, IConfiguration iconfig = null, CancellationToken ct = default(CancellationToken)) { CLILogs.Debug("Command Task : Print Stdout"); var config = iconfig as StdConfiguration; string message = ""; if (config.Fresh) { message = await task.FreshStdoutAsync(ct); } else { message = await task.StdoutAsync(ct); } return(string.Join(Environment.NewLine, message.Split("\\n", StringSplitOptions.RemoveEmptyEntries))); }
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)); } }