public void Run()
{
var archiverThread =
new Thread(
() =>
_archiver.Process(_parameters.InputFilePath, _parameters.OutputFilePath, _parameters.Operation))
{
Name = "GZipArchiver",
Priority = ThreadPriority.AboveNormal
};
archiverThread.Start();
using (var spinner = new ConsoleSpinner())
{
while (archiverThread.IsAlive)
{
spinner.Turn();
}
}
if (!_isTerminated)
{
OutputResult();
}
}
static void Main(string[] args)
{
Console.WriteLine(SettingsMessage);
Console.WriteLine("\nPress ENTER to begin to downloading files.");
Console.ReadLine();
_isRunning = true;
Task.Factory.StartNew(() =>
{
var spinner = new ConsoleSpinner();
while (_isRunning)
{
Thread.Sleep(100);
spinner.Turn();
}
});
Run();
_isRunning = false;
Console.WriteLine();
Console.WriteLine("\nPress ENTER to exit.");
Console.ReadLine();
}
private void DownloadPatchFile(XenServerPatchAlert patch)
{
if(string.IsNullOrEmpty(patch.Patch.PatchUrl))
{
Results.Add("Patch conatined no URL: " + patch.Patch.Name);
return;
}
string tempFileName = NewTempPath();
DownloadAndUnzipXenServerPatchAction action = new DownloadAndUnzipXenServerPatchAction(patch.Patch.Name,
new Uri(patch.Patch.PatchUrl),
tempFileName);
try
{
Status = "Download and unzip patch " + patch.Patch.Name;
ConsoleSpinner spinner = new ConsoleSpinner();
action.RunAsync();
while(!action.IsCompleted)
{
spinner.Turn(action.PercentComplete);
}
if(!action.Succeeded)
Results.Add("Patch download and unzip unsuccessful: " + action.Exception.Message);
}
catch (Exception ex)
{
Results.Add("Patch download error: " + ex.Message);
}
}
private void DownloadPatchFile(XenServerPatchAlert patch)
{
if (string.IsNullOrEmpty(patch.Patch.PatchUrl))
{
Results.Add("Patch conatined no URL: " + patch.Patch.Name);
return;
}
string tempFileName = NewTempPath();
DownloadAndUnzipXenServerPatchAction action = new DownloadAndUnzipXenServerPatchAction(patch.Patch.Name,
new Uri(patch.Patch.PatchUrl),
tempFileName);
try
{
Status = "Download and unzip patch " + patch.Patch.Name;
ConsoleSpinner spinner = new ConsoleSpinner();
action.RunAsync();
while (!action.IsCompleted)
{
spinner.Turn(action.PercentComplete);
}
if (!action.Succeeded)
{
Results.Add("Patch download and unzip unsuccessful: " + action.Exception.Message);
}
}
catch (Exception ex)
{
Results.Add("Patch download error: " + ex.Message);
}
}
public static void Execute()
{
Print.Header("Generate Data");
Program.Data.Clear();
const int numberOfEmployeesToGenerate = 100_000;
//var numberOfEmployeesToGenerate = ConsoleHelper.GetNumber("How many employees do you want to generate?", 1_000_000);
Console.WriteLine();
ConsoleSpinner.Execute($"Generating {numberOfEmployeesToGenerate:N0} Employees", () =>
{
for (var i = 0; i < numberOfEmployeesToGenerate; i++)
{
var age = Random.Next(20, 60);
var experienceLevel = ExperienceLevel.Values[Random.Next(0, 3)];
var employee = new Employee(age, experienceLevel);
Program.Data.Add(employee);
}
});
Print.PreviewGeneratedData(Program.Data.Take(10));
}
public void SetMessagesInConstructor()
{
ConsoleSpinner spinner = new ConsoleSpinner("Processing", "Complete");
Assert.AreEqual("Processing", spinner.ProcessingMessage);
Assert.AreEqual("Complete", spinner.CompletedMessage);
}
/// <summary>
/// Запуск сервиса обработки файла
/// </summary>
/// <param name="service">Объект сервиса обработки</param>
public static void ProcessStart(ICompressActionsService service)
{
try
{
Console.Write(service.StartInfoConst);
loadSpinner = new ConsoleSpinner(Console.CursorLeft, Console.CursorTop);
loadSpinner.Start();
service.Start(out string errors);
loadSpinner.Stop();
if (!string.IsNullOrEmpty(errors))
{
Console.WriteLine(errors);
}
else
{
Console.WriteLine(service.SuccessfullEndInfo);
}
}
catch (Exception ex)
{
loadSpinner.Stop();
throw ex;
}
}
static void Main(string[] args)
{
var spin = new ConsoleSpinner();
Console.Write("Working....");
while (true)
{
spin.Turn();
}
}
public void EscribirProgresoConsola(int porcentaje)
{
Console.WriteLine("hola");
var spin = new ConsoleSpinner();
Console.Write("Working....");
while (true)
{
spin.Turn();
}
}
public override void Validate()
{
isComplete = false;
ConsoleSpinner spinner = new ConsoleSpinner();
workerThread.RunWorkerAsync();
while(!isComplete)
spinner.Turn();
}
public override void Validate()
{
isComplete = false;
ConsoleSpinner spinner = new ConsoleSpinner();
workerThread.RunWorkerAsync();
while (!isComplete)
{
spinner.Turn();
}
}
public void GetInformation()
{
string text = @" Please keep in mind that if you want to clear the simulated database
you can do that by clearing the 'data' folder which is located in the
'Forum.App' project folder.
Currently we do NOT have an option for deleting the records with a button but we will add soon.";
Console.WriteLine(String.Format("{0," + Console.WindowWidth / 2 + "}", text));
string secondtext = @"Do you want me to delete the folder for you ?
Please write Yes or No";
Console.WriteLine(secondtext);
try
{
string input = Console.ReadLine();
Console.CursorVisible = false;
if (input.ToLower().Equals("yes"))
{
ConsoleSpinner spinner = new ConsoleSpinner();
while (true)
{
for (int i = 0; i < 10; i++)
{
spinner.Turn("'Data' folder files are being deleted!", 4);
Thread.Sleep(400);
}
DeleteDataFolderFiles();
Console.WriteLine("Files are successfully deleted. The program will continue with it's job shortly.");
break;
}
}
else if (input.ToLower().Equals("no"))
{
Console.WriteLine("The program will continue with it's job shortly.");
}
else
{
throw new ArgumentException("The input must be either Yes or No");
}
Thread.Sleep(3000);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Environment.Exit(1);
}
}
public void SetMessagesInConstructorAndProperties()
{
ConsoleSpinner spinner = new ConsoleSpinner("Processing", "Complete");
Assert.AreEqual("Processing", spinner.ProcessingMessage);
Assert.AreEqual("Complete", spinner.CompletedMessage);
spinner.CompletedMessage = "New Message";
spinner.ProcessingMessage = "New Message";
Assert.AreEqual("New Message", spinner.ProcessingMessage);
Assert.AreEqual("New Message", spinner.CompletedMessage);
}
static void Main(string[] args)
{
Console.WriteLine("Scripts to be generated:");
Scripts.ForEach(Console.WriteLine);
Console.WriteLine("Output Directory:\n\t{0}", OutputFilePath);
Console.WriteLine("\nPress ENTER to start generating scripts.");
Console.ReadLine();
var tasks = new List <Task>();
Scripts.ForEach(script => tasks.Add(Task.Factory.StartNew(() =>
{
lock (Locker)
ProgressQueue.Add(script.Name);
var outputScript = Run(script);
if (ExecuteScripts)
{
ExecuteScript(outputScript);
}
lock (Locker)
ProgressQueue.Remove(script.Name);
if (ProgressQueue.Count > 0)
{
Console.WriteLine("Still in progress: {0}", string.Join(", ", ProgressQueue));
}
})));
Task.Factory.StartNew(() =>
{
var spinner = new ConsoleSpinner();
while (ProgressQueue.Count > 0)
{
Thread.Sleep(100);
spinner.Turn();
}
});
Task.WaitAll(tasks.ToArray());
CreateBatchFile();
CreateBatchFileWithCredentials();
Console.WriteLine();
Console.WriteLine("Done! Scripts {0}can be found at: {1}.", ExecuteScripts ? "and execution results " : "", OutputFilePath);
Console.WriteLine("\nPress ENTER to exit.");
Console.ReadLine();
}
public void IsSpinning()
{
ConsoleSpinner spinner = new ConsoleSpinner("Processing", "Complete");
spinner.Start();
Assert.IsTrue(spinner.IsSpinning);
spinner.Stop();
Assert.IsFalse(spinner.IsSpinning);
spinner.Start();
Assert.IsTrue(spinner.IsSpinning);
spinner.Stop();
Assert.IsFalse(spinner.IsSpinning);
}
public List <Dictionary <object, object> > GetCourses()
{
var spinner = new ConsoleSpinner();
List <Dictionary <object, object> > response = null;
Task.Run(() => {
Console.Write("Pulling course data...");
response = GetPaginated(new RestRequest("courses", Method.GET));
spinner.IsTaskDone = true;
});
spinner.Wait();
ConsoleSpinner.ClearCurrentConsoleLine();
return(response);
}
public void StarteWithDifferentMessage()
{
ConsoleSpinner spinner = new ConsoleSpinner("Processing", "Complete");
Assert.AreEqual("Processing", spinner.ProcessingMessage);
Assert.AreEqual("Complete", spinner.CompletedMessage);
spinner.Start("Other Message");
Assert.AreEqual("Processing", spinner.ProcessingMessage);
Assert.AreEqual("Complete", spinner.CompletedMessage);
spinner.Stop("Other Message");
Assert.AreEqual("Processing", spinner.ProcessingMessage);
Assert.AreEqual("Complete", spinner.CompletedMessage);
}
private static void Main(string[] args)
{
Thread.Sleep(500);
clientHandler = new Client();
var client = new WebSocketClient <IClient, IServer>("ws://127.0.0.1:8181", clientHandler);
var task = client.Connect(OnConnection);
var spinner = new ConsoleSpinner();
Console.Write("Connecting...");
while (!task.IsCompleted && !task.IsCanceled && !task.IsFaulted)
{
spinner.Turn();
}
Console.ReadKey();
}
public static void Main(string[] args)
{
try
{
WelcomeMSG();
while (true)
{
string input = Console.ReadLine().ToLower();
if (input == "ready")
{
Console.Clear();
WelcomeMSG();
Player player = new Player();
ConsoleSpinner spin = new ConsoleSpinner();
Console.Write("Setting up game...");
DateTime start = DateTime.Now;
while (DateTime.Now.Subtract(start).Seconds < 2)
{
Thread.Sleep(90);
spin.Turn();
}
Console.SetCursorPosition(0, 10);
Console.WriteLine("Game initialized, now entering house\n");
GameRound.NewGame(player);
break;
}
else if (input == "exit")
{
Environment.Exit(0);
}
else
{
Console.WriteLine("type \"ready\" is you want to start, \"exit\" if you want to exit");
}
}
}
catch (Exception exception)
{
var trace = new StackTrace(exception);
var frame = trace.GetFrame(0);
var method = frame.GetMethod();
using (StreamWriter sw = new StreamWriter(@"errors.txt", true))
{
sw.WriteLine(string.Concat(method.DeclaringType.FullName, ".", method.Name));
}
}
Console.ReadLine();
}
public static void Execute()
{
Print.Header("Generate Data");
Program.TrainingData.Clear();
Program.TestData.Clear();
Console.WriteLine();
ConsoleSpinner.Execute($"Generating {NumberOfEmployeesToGenerate * 2:N0} Employees", () =>
{
AddEmployees(Program.TrainingData, NumberOfEmployeesToGenerate);
AddEmployees(Program.TestData, NumberOfEmployeesToGenerate);
});
Print.PreviewGeneratedData(Program.TrainingData.Take(10));
}
static void Main(string[] args)
{
var titleFinal = "";
for (int i = 0; i < (botTitle + " [0]").Length; i++)
{
titleFinal += (botTitle + " [0]")[i];
Console.Title = titleFinal;
Thread.Sleep(75);
}
string tempID = ((Path.GetRandomFileName()).Replace(".", "")).ToUpper();
Console.Clear();
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("────────────────────────────────────────────────────────────────────────────────");
try
{
skypeVar.Attach(7, false);
skypeVar.MessageStatus += new _ISkypeEvents_MessageStatusEventHandler(skypeVar_MessageStatus);
skypeVar.UserAuthorizationRequestReceived += new _ISkypeEvents_UserAuthorizationRequestReceivedEventHandler(skypeVar_UserAuthorizationRequestReceived);
try
{
consoleMessage("Detected [" + skypeVar.Friends.Count + "] contacts", tempID);
consoleMessage("Bot hosted on [" + skypeVar.CurrentUserHandle + "]", tempID);
consoleMessage("Connceted to Skype.exe", tempID);
}
catch
{
consoleError("Contacts cannot be loaded", tempID);
consoleError("Unable to detect username", tempID);
consoleError("Cannot connect to Skype.exe", tempID);
}
}
catch
{
consoleError("Failed to attach " + botName + " to Skype", tempID);
}
Console.WriteLine(Environment.NewLine + "────────────────────────────────────────────────────────────────────────────────");
var s = new ConsoleSpinner();
while (true)
{
Thread.Sleep(150);
s.UpdateProgress();
}
}
private async Task OnExecuteAsync()
{
ConsoleSpinner spinner = new ConsoleSpinner();
ProvisioningData provisioningData = await LoadProvisioningData();
Console.Write("Processing Provisioning Data, please wait ");
Task baseTask = ProcessDocker(GetDockerBasePath(), provisioningData);
Task demoTask = ProcessDocker(GetDockerDemoPath(), provisioningData);
Task overrideTask = ProcessDocker(GetDockerOverridePath(), provisioningData);
Task kubernetesTask = ProcessKubernetes(GetKubernetesPath(), provisioningData);
Task kubernetesDemoTask = ProcessKubernetes(GetKubernetesDemoPath(), provisioningData);
await Task.WhenAll(new[] { baseTask, demoTask, overrideTask, kubernetesTask, kubernetesDemoTask });
Console.WriteLine();
Console.WriteLine();
}
private void ValidatePictureHashes(Dictionary <int, PictureHash> pictureHashes)
{
var spin = new ConsoleSpinner();
Console.Write("Validating image hashes... ");
// Verify we've written all images we said we would
foreach (var ph in pictureHashes)
{
spin.Turn();
var fileHash = GetHash(File.ReadAllBytes(ph.Value.Path));
if (fileHash.Equals(pictureHashes[ph.Key].Hash))
{
continue;
}
throw new Exception($"Hash validation failed. Delete {ph.Value.Path} and re-run ImageExport command.");
}
}
public static void Execute()
{
Print.Header("Train Model");
if (!Validate.DataIsLoaded())
{
return;
}
SplitData(Program.Data, out var trainingData, out var validationData);
IEnumerable <string> previewData = null;
Program.TrainedModel = ConsoleSpinner.Execute("Training", () => SalaryPredictionService.Train(trainingData, out previewData));
Print.PreviewTransformedData(previewData);
var metrics = ConsoleSpinner.Execute("Evaluating", () => SalaryPredictionService.Evaluate(Program.TrainedModel, validationData));
Print.Metrics(metrics);
}
public bool DownloadFile(string url, string path, string fileName)
{
bool success = false;
var spinner = new ConsoleSpinner();
Task.Run(() => {
Console.Write("Downloading " + fileName + "...");
fileName = OSHelper.SanitizeFileName(fileName);
OSHelper.MakeFolder(path);
var tempFile = OSHelper.CombinePaths(path, Path.GetRandomFileName() + ".tmp");
try
{
// var tempFile = Path.GetTempFileName();
// using var writer = File.OpenWrite(tempFile);
using var writer = File.OpenWrite(tempFile);
var request = new RestRequest(url);
request.ResponseWriter = responseStream =>
{
using (responseStream)
{
responseStream.CopyTo(writer);
}
};
var response = client.DownloadData(request);
success = true;
}
catch (Exception e)
{
Console.WriteLine("Download failed exception {0}", e.ToString());
success = false;
}
File.Move(tempFile, OSHelper.CombinePaths(path, fileName));
spinner.IsTaskDone = true;
});
spinner.Wait();
ConsoleSpinner.ClearCurrentConsoleLine();
return(success);
}
public List <Dictionary <object, object> > GetCourseFolders(string courseName, string courseID)
{
var spinner = new ConsoleSpinner();
List <Dictionary <object, object> > folders = null;
Task.Run(() => {
Console.Write("Pulling " + courseName + " folder structure...");
string folderURL = "courses/" + courseID + "/folders/";
folders = GetPaginated(new RestRequest(folderURL, Method.GET));
ConsoleSpinner.ClearCurrentConsoleLine();
Console.Write("Pulling " + courseName + " file structure...");
foreach (var folder in folders)
{
folder.Add("files", GetPaginated(new RestRequest("folders/" + folder["id"].ToString() + "/files/", Method.GET)));
}
spinner.IsTaskDone = true;
});
spinner.Wait();
ConsoleSpinner.ClearCurrentConsoleLine();
return(folders);
}
public static CancellationTokenSource Spin(this ConsoleSpinner spinner, ConsoleColor color)
{
// Cria uma thread em background para executar a animação.
// Devolve um token ao invocador para este decidir quando deve parar a animação.
CancellationTokenSource tokenSource = new CancellationTokenSource();
Task.Run(async() =>
{
Console.CursorVisible = false;
while (!tokenSource.IsCancellationRequested)
{
Console.ForegroundColor = color;
spinner.UpdateProgress();
Console.ResetColor();
await Task.Delay(100);
}
Console.CursorVisible = true;
}, tokenSource.Token);
return(tokenSource);
}
private void RemovePicturesFromDb(NopDbContext db)
{
var spin = new ConsoleSpinner();
Console.Write("Removing pictures... ");
var pictures = db.Pictures;
var pictureCount = pictures.Count();
// Clear pictures in DB
// Work with only 100 pictures at a time from the DB
for (var i = 0; i < pictureCount; i = i + 100)
{
spin.Turn();
var pictureBatch = pictures.OrderBy(p => p.Id).Skip(i).Take(100);
foreach (var picture in pictureBatch)
{
picture.PictureBinary = new byte[0];
}
db.SaveChanges();
}
// Turn off StoreInDB setting
Console.Write("Turning off StoreInDB setting...");
var setting = db.Settings.SingleOrDefault(s => s.StoreId == _options.StoreId && s.Name == "Media.Images.StoreInDB");
if (setting == null)
{
return;
}
setting.Value = false.ToString();
db.SaveChanges();
}
private static async Task RemoveAllExistingResourcesAsync(HttpClient httpClient, IReadOnlyCollection <Space> rootSpaces)
{
if (!rootSpaces.Any())
{
return;
}
Console.WriteLine();
IReadOnlyCollection <Resource> resourcesToRemove = await rootSpaces.GetExistingResourcesUnderSpacesAsync(httpClient);
Console.WriteLine($"Removing {resourcesToRemove.Count} resources.");
var resourceIdsDeleting = new List <Guid>();
foreach (Resource resourceToRemove in resourcesToRemove)
{
bool success = await resourceToRemove.DeleteResourceAsync(httpClient, JsonSerializerSettings);
if (success)
{
resourceIdsDeleting.Add(Guid.Parse(resourceToRemove.Id));
}
else
{
Console.WriteLine($"Failed to remove Resource, please try manually. (Id: {resourceToRemove.Id})");
}
}
if (resourceIdsDeleting.Any())
{
Console.WriteLine("Polling until all resources have been deleted.");
var tokenSource = new CancellationTokenSource();
ICollection <Task> statusVerificationTasks = resourceIdsDeleting
.Select(resourceId => ResourcesHelpers.WaitTillResourceDeletionCompletedAsync(httpClient, resourceId, tokenSource.Token))
.ToArray();
// Ensuring that it won't sit here forever.
Task processingTasks = Task.WhenAny(Task.WhenAll(statusVerificationTasks), Task.Delay(TimeSpan.FromMinutes(10)));
ConsoleSpinner spinner = new ConsoleSpinner();
while (!processingTasks.IsCompleted)
{
Console.CursorVisible = false;
spinner.Turn();
await Task.Delay(250);
}
if (statusVerificationTasks.Any(t => t.Status != TaskStatus.RanToCompletion))
{
// Timeout occurred, need to cancel all the other tasks
tokenSource.Cancel();
Console.WriteLine("Timeout occurred. Unable to verify that all resources have been deleted.");
}
else
{
Console.WriteLine("Resource deletion complete.");
}
}
Console.WriteLine();
}
public async Task <int> InvokeAsync(InvocationContext context)
{
var rawVersion = context.ParseResult.ValueForArgument("version");
if (rawVersion == null)
{
await Console.Error.WriteLineAsync($"Missing version argument");
return(1);
}
Version version;
if (rawVersion.ToString()?.ToLower() == "latest")
{
try
{
version = _nodeWeb.GetLatestNodeVersion();
}
catch (Exception)
{
await Console.Error.WriteLineAsync("Unable to determine latest Node.js version.");
return(1);
}
}
else if (rawVersion.ToString()?.Split(".").Length < 3)
{
try
{
version = _nodeWeb.GetLatestNodeVersion(rawVersion.ToString());
}
catch (Exception)
{
await Console.Error.WriteLineAsync($"Unable to get latest Node.js version " +
$"with prefix {rawVersion}.");
return(1);
}
}
else
{
try
{
version = VersionParser.Parse(rawVersion.ToString());
}
catch (ArgumentException)
{
await Console.Error.WriteLineAsync($"Invalid version argument: {rawVersion}");
return(1);
}
}
//
// Is the requested version already installed?
//
if (_nodeLocal.GetInstalledVersions().FindIndex(v => v.Version.Equals(version)) != -1)
{
await Console.Error.WriteLineAsync($"{version} already installed");
return(1);
}
//
// Download it
//
var downloadUrl = _nodeWeb.GetDownloadUrl(version);
var zipPath = Path.Join(_globalContext.StoragePath, Path.GetFileName(downloadUrl));
var progressBar = new ProgressBar(100, "Download progress", new ProgressBarOptions
{
ProgressCharacter = '\u2593',
ForegroundColor = ConsoleColor.Yellow,
ForegroundColorDone = ConsoleColor.Green,
});
var webClient = new WebClient();
webClient.DownloadProgressChanged += (s, e) => { progressBar.Tick(e.ProgressPercentage); };
webClient.DownloadFileCompleted += (s, e) => { progressBar.Dispose(); };
try
{
await webClient.DownloadFileTaskAsync(downloadUrl, zipPath).ConfigureAwait(false);
}
catch (Exception e)
{
await Console.Error.WriteLineAsync("Unable to download the Node.js zip file.");
if (e.InnerException == null)
{
return(1);
}
await Console.Error.WriteLineAsync(e.InnerException.Message);
await Console.Error.WriteLineAsync("You may need to run this command from an " +
"elevated prompt. (Run as Administrator)");
return(1);
}
Console.WriteLine("Extracting...");
ConsoleSpinner.Instance.Update();
var timer = new Timer(250);
timer.Elapsed += (s, e) => ConsoleSpinner.Instance.Update();
timer.Enabled = true;
ZipFile.ExtractToDirectory(zipPath, _globalContext.StoragePath);
timer.Enabled = false;
ConsoleSpinner.Reset();
File.Delete(zipPath);
Console.WriteLine($"Done. To use, run `nodeswap use {version}`");
return(0);
}
/// <summary>
/// Install PIP and Ansible
/// </summary>
private void InstallAnsibleWithPIP()
{
bool retVal;
ConsoleSpinner spinner = new ConsoleSpinner()
{
SpinColor = ConsoleColor.Yellow,
SpinnerSpeed_ms = 100,
HideCursor = true,
};
General.ApplicationHeader(true);
Log.Verbose("Some of these might timeout. Depends on the speed of the harddrive, memory, cpu, etc. This doesn't mean it didn't work, only means it took longer than expected.", ConsoleColor.Cyan, true, false, 45);
Log.Verbose($"{General.PadString("[ .. ] Installing Python3.", 45)}", ConsoleColor.White, false);
Console.CursorLeft = 3;
spinner.Start();
retVal = SendCommand("sudo yum install python3-pip", false, 60);
spinner.Stop();
if (retVal)
{
Log.Verbose(0, $"OK", ConsoleColor.Green);
}
else
{
Log.Verbose(0, $"TO", ConsoleColor.Red);
}
Log.Verbose($"{General.PadString("[ .. ] Downloading get-pip.py.", 45)}", ConsoleColor.White, false);
Console.CursorLeft = 3;
spinner.Start();
retVal = SendCommand("curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py", false, 60);
spinner.Stop();
if (retVal)
{
Log.Verbose(0, $"OK", ConsoleColor.Green);
}
else
{
Log.Verbose(0, $"TO", ConsoleColor.Red);
}
Log.Verbose($"{General.PadString("[ .. ] Installing PIP.", 45)}", ConsoleColor.White, false);
Console.CursorLeft = 3;
spinner.Start();
retVal = SendCommand("!!Successfully", "python3 get-pip.py", false, 60);
spinner.Stop();
if (retVal)
{
Log.Verbose(0, $"OK", ConsoleColor.Green);
}
else
{
Log.Verbose(0, $"TO", ConsoleColor.Red);
}
Log.Verbose($"{General.PadString("[ .. ] Installing pexpect for python.", 45)}", ConsoleColor.White, false);
Console.CursorLeft = 3;
spinner.Start();
retVal = SendCommand("pip install pexpect", false, 30);
spinner.Stop();
if (retVal)
{
Log.Verbose(0, $"OK", ConsoleColor.Green);
}
else
{
Log.Verbose(0, $"TO", ConsoleColor.Red);
}
Log.Verbose($"{General.PadString("[ .. ] PIP Installing Ansible.", 45)}", ConsoleColor.White, false);
Console.CursorLeft = 3;
spinner.Start();
retVal = SendCommand("!!Successfully", "pip install ansible", false, 120);
spinner.Stop();
if (retVal)
{
Log.Verbose(0, $"OK", ConsoleColor.Green);
}
else
{
Log.Verbose(0, $"TO", ConsoleColor.Red);
}
Log.Verbose($"{General.PadString("[ .. ] Cleanup...", 45)}", ConsoleColor.White, false);
Console.CursorLeft = 3;
spinner.Start();
SendCommand(Defs.Command_Prompt_Only, "rm -f get-pip.py", false, 5);
spinner.Stop();
Log.Verbose(0, $"OK", ConsoleColor.Green);
Log.Verbose("Finished..\n", ConsoleColor.White);
Log.Verbose("Press any key to continue...", ConsoleColor.White);
Console.ReadKey();
General.ApplicationHeader(true);
SendCommand("pip --version", true);
SendCommand("python3 --version", true);
SendCommand("pip freeze", true);
}
static void Main(string[] args)
{
string binaryDataFile = docDir + "nvdcve-consolidated.dat";
Console.WriteLine("Loading saved data from file...");
using (var spin = new ConsoleSpinner())
{
spin.Start();
LoadBinaryData(binaryDataFile);
spin.Stop();
}
Console.WriteLine("Loading completed.");
// If the number of years is specified on the command line
// then download the historical data first.
if (args.Length != 0)
{
int numYears;
bool test = int.TryParse(args[0], out numYears);
if (test)
{
if (numYears >= 0)
{
UpdateHistoricalData(numYears);
}
}
}
DownloadModifiedData();
if (countRemoved > 0)
{
Console.WriteLine("Removed {0} duplicate records from consolidated data.", countRemoved);
}
Console.WriteLine("Saving data to file...");
using (var spin = new ConsoleSpinner())
{
spin.Start();
SaveBinaryData(binaryDataFile);
spin.Stop();
}
Console.WriteLine("Saving completed.");
#if DEBUG
Console.WriteLine("Press the ANY key to exit!");
Console.ReadLine();
#endif
}
public void SetUp()
{
_consoleSpinner = new ConsoleSpinner();
_consoleSpinner.Delay = TimeSpan.FromMilliseconds(10);
}
protected async override Task <int> ExecuteCommand(LoginCommand arguments)
{
Console.WriteLine("Logging in...");
logger.LogInformation("Logging in... with {Arguments}", arguments);
if (!arguments.NoCache)
{
var userToken = await tokenStorage.LoadUserTokenAsync();
logger.LogInformation("Loaded {UserToken}", userToken);
if (userToken != null)
{
userToken = await refreshTokenHandler.RefreshTokenAsync(userToken);
logger.LogInformation("Refreshed {UserToken}", userToken);
if (userToken != null)
{
Console.WriteLine("Login successful!");
logger.LogInformation("Login successful!");
await StoreToken(arguments, userToken);
return(0);
}
}
}
var disco = await discoveryProvider.FetchDiscoveryDocument();
var request = new DeviceAuthorizationRequest
{
Address = disco.DeviceAuthorizationEndpoint,
ClientId = configurationProvider.ClientId,
Scope = configurationProvider.Scope
};
logger.LogInformation("RequestDeviceAuthorizationAsync {Request}", request);
var result = await httpClient.RequestDeviceAuthorizationAsync(request);
if (result.IsError)
{
Console.WriteLine(result.Error);
var ex = new Exception(result.Error);
logger.LogError(ex, "RequestDeviceAuthorizationAsync {Request} {Response}", request, result);
throw ex;
}
else
{
logger.LogInformation("RequestDeviceAuthorizationAsync {Request} {Response}", request, result);
}
Console.WriteLine($"Visit: {result.VerificationUri}");
Console.WriteLine();
Console.WriteLine("And enter this code");
Console.WriteLine("-------------------");
Console.WriteLine($"- {result.UserCode} -");
Console.WriteLine("-------------------");
var fetchToken = true;
var interval = (result.Interval == 0 ? 5 : result.Interval) * 1000;
var spinner = new ConsoleSpinner();
while (fetchToken)
{
spinner.Turn();
Console.Write(" Fetching token....");
var tokenResponse = await httpClient.RequestDeviceTokenAsync(new DeviceTokenRequest
{
Address = disco.TokenEndpoint,
ClientId = configurationProvider.ClientId,
DeviceCode = result.DeviceCode,
});
if (tokenResponse.IsError)
{
if (tokenResponse.Error == "authorization_pending" || tokenResponse.Error == "slow_down")
{
await Task.Delay(interval);
}
else
{
spinner.ClearLine();
Console.WriteLine(tokenResponse.Error);
throw new Exception(tokenResponse.Error);
}
}
else
{
var userToken = new UserToken(
tokenResponse.AccessToken,
tokenResponse.RefreshToken,
tokenResponse.IdentityToken,
DateTime.UtcNow.AddSeconds(tokenResponse.ExpiresIn)
);
spinner.ClearLine();
Console.WriteLine("Login successful!");
await StoreToken(arguments, userToken);
return(0);
}
}
return(0);
}
