private async Task CleanupAsync(TargetFtpConfig targetFtp, LastRunConfig lastRun, List <FileInfo> files)
{
if (lastRun == null)
{
return;
}
using (var helper = IFtpFactory.CleanupHelper(targetFtp))
{
IOutputConsole.ClearLine();
IOutputConsole.Write("cleanup...");
helper.DidCleanup += (sender, remoteFile) =>
{
IOutputConsole.ClearLine();
IOutputConsole.Write($"cleanup [{remoteFile}]");
};
helper.Error += (sender, remoteFile) =>
{
IOutputConsole.ClearLine();
IOutputConsole.Write($"error [{remoteFile}]");
};
await helper.DeleteNotContainedFiles(lastRun, files);
}
}
private void LogEnvironmentVariableOverride(string flightName, string variableName, string variableValue)
{
NuGetUIThreadHelper.JoinableTaskFactory.RunAsync(async() =>
{
IOutputConsole console = await _outputConsoleProvider.Value.CreatePackageManagerConsoleAsync();
await console.WriteLineAsync(string.Format(CultureInfo.CurrentUICulture, Resources.ExperimentVariableOverrideLogText, flightName, variableName, variableValue));
}).PostOnFailure(nameof(NuGetExperimentationService), nameof(LogEnvironmentVariableOverride));
}
public async Task StartAsync(
RestoreOperationSource operationSource,
Lazy <ErrorListTableDataSource> errorListDataSource,
JoinableTaskFactory jtf,
CancellationTokenSource cts)
{
Assumes.Present(errorListDataSource);
Assumes.Present(jtf);
Assumes.Present(cts);
_operationSource = operationSource;
_errorListDataSource = errorListDataSource;
_jtc = jtf.Context.CreateCollection();
_taskFactory = jtf.Context.CreateFactory(_jtc);
_externalCts = cts;
_externalCts.Token.Register(() => _cancelled = true);
#if VS14
_progressFactory = t => WaitDialogProgress.StartAsync(_serviceProvider, _taskFactory, t);
#else
_progressFactory = t => StatusBarProgress.StartAsync(_serviceProvider, _taskFactory, t);
#endif
await _taskFactory.RunAsync(async() =>
{
await _taskFactory.SwitchToMainThreadAsync();
OutputVerbosity = GetMSBuildOutputVerbositySetting();
switch (_operationSource)
{
case RestoreOperationSource.Implicit: // background auto-restore
_outputConsole = _outputConsoleProvider.CreatePackageManagerConsole();
break;
case RestoreOperationSource.OnBuild:
_outputConsole = _outputConsoleProvider.CreateBuildOutputConsole();
_outputConsole.Activate();
break;
case RestoreOperationSource.Explicit:
_outputConsole = _outputConsoleProvider.CreatePackageManagerConsole();
_outputConsole.Activate();
_outputConsole.Clear();
break;
}
});
if (_errorListDataSource.IsValueCreated)
{
// Clear old entries
_errorListDataSource.Value.ClearNuGetEntries();
}
}
private static void PrintUserInfo(IOutputConsole OutputProvider)
{
string USER_KEY = RegHelper.ROOT_KEY + @"\UserInfo";
string firstName = (string)RegHelper.GetRegValue(USER_KEY, "firstname", 0);
string lastName = (string)RegHelper.GetRegValue(USER_KEY, "lastname", 0);
string company = (string)RegHelper.GetRegValue(USER_KEY, "company", 0);
string email = (string)RegHelper.GetRegValue(USER_KEY, "email", 0);
OutputProvider.WriteLine("This product is registered to \nUser\t:\t" + firstName + " " + lastName + "\nEmail\t:\t" + email + "\nCompany\t:\t" + company);
}
public static void PrintLogo(IOutputConsole outputProvider, bool printLogo, string TOOLNAME)
{
if (printLogo)
{
string logo = @"Alachisoft (R) NCache Utility " + TOOLNAME + ". Version NCache Open Source 4.9" + @"
Copyright (C) Alachisoft 2018. All rights reserved.";
outputProvider.WriteLine(logo + "\n");
}
}
public static void PrintLogo(IOutputConsole outputProvider, bool printLogo, string TOOLNAME)
{
if (printLogo)
{
string logo = @"Alachisoft (R) NCache Utility " + TOOLNAME + ". Version NCache Open Source 5.0 SP5" +
@"
Copyright (C) Alachisoft 2021. All rights reserved.";
outputProvider.WriteLine(logo);
outputProvider.WriteLine(Environment.NewLine);
}
}
public async Task StartAsync(
RestoreOperationSource operationSource,
Lazy <INuGetErrorList> errorList,
JoinableTaskFactory jtf,
CancellationTokenSource cts)
{
Assumes.Present(errorList);
Assumes.Present(jtf);
Assumes.Present(cts);
_operationSource = operationSource;
_errorList = errorList;
_jtc = jtf.Context.CreateCollection();
_taskFactory = jtf.Context.CreateFactory(_jtc);
_externalCts = cts;
_externalCts.Token.Register(() => _cancelled = true);
_progressFactory = t => StatusBarProgress.StartAsync(_asyncServiceProvider, _taskFactory, t);
await _taskFactory.RunAsync(async() =>
{
OutputVerbosity = await GetMSBuildOutputVerbositySettingAsync();
switch (_operationSource)
{
case RestoreOperationSource.Implicit: // background auto-restore
_outputConsole = await _outputConsoleProvider.Value.CreatePackageManagerConsoleAsync();
break;
case RestoreOperationSource.OnBuild:
_outputConsole = await _outputConsoleProvider.Value.CreateBuildOutputConsoleAsync();
await _outputConsole.ActivateAsync();
break;
case RestoreOperationSource.Explicit:
_outputConsole = await _outputConsoleProvider.Value.CreatePackageManagerConsoleAsync();
await _outputConsole.ActivateAsync();
await _outputConsole.ClearAsync();
break;
}
});
if (_errorList.IsValueCreated)
{
// Clear old entries
_errorList.Value.ClearNuGetEntries();
}
}
public TestStressManager(string cacheId, int totalLoopCount, int testCaseIterations, int testCaseIterationDelay, int getsPerIteration, int updatesPerIteration, int dataSize, int expiration, int threadCount, int reportingInterval, bool noLogo, IOutputConsole outputProvider, PowerShellAdapter adapter)
{
_cacheId = cacheId;
_totalLoopCount = totalLoopCount;
_testCaseIterations = testCaseIterations;
_testCaseIterationDelay = testCaseIterationDelay;
_getsPerIteration = getsPerIteration;
_updatesPerIteration = updatesPerIteration;
_dataSize = dataSize;
_expiration = expiration;
_threadCount = threadCount;
_reportingInterval = reportingInterval;
_outputProvider = outputProvider;
_adapter = adapter;
}
public async Task ResetState(TargetCommand command)
{
foreach (var ftp in command.Target.Ftp)
{
var targetFtp = CreateTargetFtp(command, ftp);
using (var ftpClient = IFtpFactory.Client(targetFtp))
{
await ftpClient.DeleteAsync(_LastRunFileName);
IOutputConsole.ClearLine();
IOutputConsole.WriteLine($"Reset state [{targetFtp.Name}] OK.");
IOutputConsole.WriteLine("");
}
}
}
/// <summary>
/// Constructor
/// </summary>
public StressThreadTask(ICache cache, int totalLoopCount, int testCaseIterations, int testCaseIterationDelay, int getsPerIteration, int updatesPerIteration, int dataSize, int expiration, int threadCount, int reportingInterval, int threadIndex, IOutputConsole outputProvider, PowerShellAdapter adapter)
{
_cache = cache;
_totalLoopCount = totalLoopCount;
_testCaseIterations = testCaseIterations;
_testCaseIterationDelay = testCaseIterationDelay;
_getsPerIteration = getsPerIteration;
_updatesPerIteration = updatesPerIteration;
_dataSize = dataSize;
_expiration = expiration;
_threadCount = threadCount;
_reportingInterval = reportingInterval;
_threadIndex = threadIndex;
_pid = System.Diagnostics.Process.GetCurrentProcess().Id;
CreateThread();
_outputProvider = outputProvider;
_adapter = adapter;
}
public async Task ApplyCurrentStateAsync(TargetCommand command)
{
var files = GetFiles(command.Target);
foreach (var ftp in command.Target.Ftp)
{
var targetFtp = CreateTargetFtp(command, ftp);
using (var ftpClient = IFtpFactory.Client(targetFtp))
{
await UploadLastRunAsync(ftpClient, files);
IOutputConsole.ClearLine();
IOutputConsole.WriteLine($"Apply current state [{targetFtp.Name}] OK.");
IOutputConsole.WriteLine("");
}
}
}
public override async Task Process(OkCommand command)
{
IOutputConsole.Write($"Waiting for [{command.Url}]...");
var start = DateTime.Now;
while (true)
{
var status = await ICurlHelper.Curl(command.Url);
if (status == HttpStatusCode.OK)
{
var ts = DateTime.Now - start;
IOutputConsole.WriteLine($" {(int)ts.TotalSeconds} sec. OK");
IOutputConsole.WriteLine("");
return;
}
}
}
private async Task <List <FileInfo> > UploadFilesAsync(TargetFtpConfig targetFtp, List <FileInfo> files)
{
var result = new List <FileInfo>();
var worker = new FtpWorker(targetFtp);
Container.Shared.Inject(worker);
worker.Enqueue(files.ToArray());
var root = IRootHelper.GetRoot();
worker.FileWillUpload += (sender, a) =>
{
lock (this)
{
IOutputConsole.ClearLine();
IOutputConsole.Write($"uploading {a.FilesLeft} {root.GetRealtive(a.File)}");
}
};
worker.FileDidUpload += (sender, a) =>
{
lock (result)
{
result.Add(a.File);
}
};
worker.FileError += (sender, a) =>
{
lock (this)
{
IOutputConsole.ClearLine();
IOutputConsole.WriteLine($"error: {root.GetRealtive(a.File)}, [{a.Message}]");
}
};
await worker.UploadAsync();
return(result);
}
internal OutputConsoleLogger(
IVisualStudioShell visualStudioShell,
IOutputConsoleProvider consoleProvider,
Lazy <INuGetErrorList> errorList)
{
Verify.ArgumentIsNotNull(visualStudioShell, nameof(visualStudioShell));
Verify.ArgumentIsNotNull(consoleProvider, nameof(consoleProvider));
Verify.ArgumentIsNotNull(errorList, nameof(errorList));
_visualStudioShell = visualStudioShell;
_errorList = errorList;
_verbosityLevel = new AsyncLazyInt(() => GetMSBuildVerbosityLevelAsync(), NuGetUIThreadHelper.JoinableTaskFactory);
Run(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
await _visualStudioShell.SubscribeToBuildBeginAsync(() => _errorList.Value.ClearNuGetEntries());
await _visualStudioShell.SubscribeToAfterClosingAsync(() => _errorList.Value.ClearNuGetEntries());
_outputConsole = await consoleProvider.CreatePackageManagerConsoleAsync();
});
}
public static void ConveyCommandToAllRunningCacheHost(ConfiguredCacheInfo[] cacheHostprocesses, string Action, string server, IOutputConsole OutputProvider)
{
foreach (ConfiguredCacheInfo cacheHost in cacheHostprocesses)
{
NCacheRPCService nCache = new NCacheRPCService("");
nCache.Port = cacheHost.ManagementPort;
nCache.ServerName = server;
if (nCache.Port > 0)
{
ICacheServer hostService = nCache.GetCacheServer(new TimeSpan(0, 0, 0, 30));
if (Action.ToLower().Equals("start"))
{
OutputProvider.WriteLine("Starting monitoring on server {0}:{1}.", nCache.ServerName, nCache.Port);
hostService.StartMonitoringActivity();
}
else if (Action.ToLower().Equals("stop"))
{
OutputProvider.WriteLine("Stop monitoring on server {0}:{1}.", nCache.ServerName, nCache.Port);
hostService.StopMonitoringActivity();
}
hostService.PublishActivity();
}
}
}
public static void PrintMessage(IOutputConsole outputProvider, string msg)
{
outputProvider.WriteErrorLine(msg);
}
public static void SetOutputConsole(IOutputConsole output)
{
Output = output;
OuputCache();
}
public override async Task Process(TargetCommand command)
{
foreach (var ftp in command.Target.Ftp)
{
var targetFtp = CreateTargetFtp(command, ftp);
using (var ftpClient = IFtpFactory.Client(targetFtp))
{
var lastRun = await ReadLastRunAsync(ftpClient);
var modifiedSince = lastRun?.Dt;
var localFiles = GetFiles(command.Target);
var filesToUpload = localFiles;
if (modifiedSince.HasValue)
{
filesToUpload =
localFiles
.Where(x => AppliesToModified(x, modifiedSince))
.ToList();
}
if (lastRun != null)
{
var remoteFilesHash =
lastRun
.Files
.ToHashSet();
var root = IRootHelper.GetRoot();
foreach (var file in localFiles)
{
var remotePath = root.GetRealtive(file);
if (remoteFilesHash.Contains(remotePath))
{
continue;
}
if (!filesToUpload.Any(x => x.FullName == file.FullName))
{
filesToUpload.Add(file);
}
}
}
IOutputConsole.WriteLine($"Target [{command.Value}/{targetFtp.Name}]");
if (!filesToUpload.HasContent())
{
PrintNoFiles();
}
else
{
IOutputConsole.WriteLine($"found {filesToUpload.Count} files");
await UploadFilesAsync(targetFtp, filesToUpload);
}
if (!command.Target.CleanupDisable)
{
await CleanupAsync(targetFtp, lastRun, localFiles);
}
await UploadLastRunAsync(ftpClient, localFiles);
PrintFinished();
if (command.Target.OK.HasContent())
{
await IOkProcessor.Process(new OkCommand { Url = command.Target.OK });
}
}
}
}
private async Task UploadLastRunAsync(IFtpClient ftpClient, List <FileInfo> files)
{
IOutputConsole.ClearLine();
IOutputConsole.Write("uploading .LastRun");
await WriteLastRunAsync(ftpClient, files);
}
private void PrintNoFiles()
{
IOutputConsole.WriteLine("no files to upload");
IOutputConsole.WriteLine("");
}
private void PrintFinished()
{
IOutputConsole.ClearLine();
IOutputConsole.WriteLine("finished");
IOutputConsole.WriteLine("");
}
