static int Main(string[] args)
{
var client = NitroClient.FromJson();
var progress = new ConsoleProgress();
var key = client.GetKeyInfo();
if (key is null)
{
Console.Error.WriteLine("Can't get key");
return(1);
}
if (!key.IsActive())
{
Console.Error.WriteLine("Key is not active");
return(1);
}
Console.WriteLine($"Today traffic left: {(key.TrafficLeft / 1024 / 1024):N0} Mb");
if (args.Length != 0)
{
foreach (var url in args)
{
client.DownloadFile(url, progress);
}
Console.WriteLine();
Console.WriteLine("ALL DONE");
Console.WriteLine();
}
return(0);
}
public void ConsoleProgressExample()
{
var firstProgress = new ConsoleProgress(title: "ConsoleProgress", length: 50);
var secondProgress = new SimpleProgress(title: "SimpleProgress", length: 50);
var flow = new ConsoleFlow
(
firstProgress,
secondProgress
);
flow.Display();
while (true)
{
var key = Console.ReadKey(true).Key;
if (key == ConsoleKey.Escape)
{
break;
}
else if (key == ConsoleKey.UpArrow)
{
firstProgress.Value = Math.Clamp(firstProgress.Value + 0.1f, 0f, 1f);
}
else if (key == ConsoleKey.DownArrow)
{
secondProgress.Value = Math.Clamp(secondProgress.Value + 0.1f, 0f, 1f);
}
}
}
static void Main()
{
Console.SetOut(new HexColor());
ConsoleEx.AssemblyHeader(useColor: true);
Console.WriteLine("Testing `066`Woof.Console`:");
Console.WriteLine();
var tasksCount = TasksLeft = 8;
for (int i = 0; i < tasksCount; i++)
{
lock (L1) {
Console.Write($"Starting test task #{i + 1}...");
var progress = new ConsoleProgress();
Task.Run(async() => await TestTask(progress));
Task.Delay(1).Wait();
}
}
Semaphore.Wait();
Console.WriteLine();
using var hexDump = new HexDump { Format = HexDump.Formats.HexColor };
var testData = new byte[48];
PRNG.NextBytes(testData);
hexDump.Write(testData);
Console.WriteLine();
var delayFilter = new Delay();
Console.SetOut(delayFilter);
Console.WriteLine("Testing `0ff`Delay` filter..............`070`OK!`");
Console.SetOut(delayFilter.Out); // remove the delay filter.
Console.WriteLine();
ConsoleEx.WaitForCtrlC("All test completed successfully, press Ctrl+C to exit...");
}
private void ReadTables(CremaDataSet dataSet, IDataBase dataBase, string tableNames)
{
var authentication = this.CommandContext.GetAuthentication(this);
var tables = dataBase.Dispatcher.Invoke(() => this.GetFilterTables(dataBase.TableContext.Tables, tableNames));
if (tables.Any() == false)
{
throw new CremaException("조건에 맞는 테이블이 존재하지 않습니다.");
}
var step = new StepProgress(new ConsoleProgress(this.Out)
{
Style = ConsoleProgressStyle.None
});
step.Begin(tables.Length);
foreach (var item in tables)
{
dataBase.Dispatcher.Invoke(() =>
{
var previewSet = item.GetDataSet(authentication, -1);
var previewTable = previewSet.Tables[item.Name];
previewTable.CopyTo(dataSet);
var name = item.Name;
step.Next("read {0} : {1}", ConsoleProgress.GetProgressString(step.Step + 1, tables.Length), item.Name);
});
}
step.Complete();
}
public static void ApplyFix()
{
if (!ActiveFix)
{
return;
}
var patchPath = Path.Combine(Path.GetDirectoryName(Plugin.CurrentPlugin.Context.AssemblyPath), "./maps_bindings_fix.sql");
logger.Debug("Apply maps bindings fix");
if (File.Exists(patchPath))
{
File.Delete(patchPath);
}
var console = new ConsoleProgress();
var maps = World.Instance.GetMaps().ToArray();
var counter = 0;
var patches = 0;
foreach (var request in maps.Select(FixMap))
{
if (request != string.Empty)
{
File.AppendAllText(patchPath, request + "\r\n");
patches++;
}
counter++;
console.Update(string.Format("{0:0.0}% " + "({1} patches)", (counter / (double)maps.Length) * 100, patches));
}
}
private static void OnChunkDownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
ChildProgressBar progress = ChildConsoleProgresses.GetOrAdd(e.ProgressId, id =>
ConsoleProgress?.Spawn(10000, $"chunk {id}", ChildOption));
progress.Tick((int)(e.ProgressPercentage * 100));
}
public static void ApplyFix()
{
var worldDb = Program.ConnectToWorld();
Console.WriteLine("Load maps ...");
World.Instance.ChangeDataSource(worldDb.Database);
World.Instance.LoadSpaces();
var console = new ConsoleProgress();
Console.WriteLine("Apply fix ...");
var maps = World.Instance.GetMaps().ToArray();
var counter = 0;
var patches = 0;
foreach (var map in maps)
{
FixMap(map);
worldDb.Database.Update(map.Record);
counter++;
console.Update(string.Format("{0:0.0}% " + "({1} patches)", (counter / (double)maps.Length) * 100, patches));
}
console.End();
Console.WriteLine("Maps transitions fix applied");
}
public void CanGetNewFileFromAnotherRep()
{
ConsoleProgress progress = new ConsoleProgress();
BobSetup bobSetup = new BobSetup(progress, _pathToTestRoot);
bobSetup.ChangeTextFile();
string usbPath = Path.Combine(_pathToTestRoot, "USB-A");
Directory.CreateDirectory(usbPath);
bobSetup.SetupClone(usbPath);
RepositoryAddress otherDirPath = RepositoryAddress.Create("USBA", Path.Combine(usbPath, RepositoryAddress.ProjectNameVariable), false);
Synchronizer bob = bobSetup.GetSynchronizer();
bob.ExtraRepositorySources.Add(otherDirPath);
//now stick a new file over in the "usb", so we can see if it comes back to us
File.WriteAllText(Path.Combine(otherDirPath.GetPotentialRepoUri(bob.Repository.Identifier, BobSetup.ProjectFolderName, progress), "incoming.abc"), "this would be a file coming in");
var options = GetFullSyncOptions("adding a file to the usb for some reason");
ProjectFolderConfiguration usbProject = BobSetup.CreateFolderConfig(Path.Combine(usbPath, BobSetup.ProjectFolderName));
var synchronizer = Synchronizer.FromProjectConfiguration(usbProject, progress);
synchronizer.Repository.SetUserNameInIni("usba", progress);
synchronizer.SyncNow(options);
//now we should get that file
options = GetFullSyncOptions("test getting new file from usb");
options.DoMergeWithOthers = false;
options.DoSendToOthers = false;
options.RepositorySourcesToTry.Add(otherDirPath);
bob.SyncNow(options);
Assert.That(Path.Combine(bobSetup._languageProjectPath, "incoming.abc"), Does.Exist);
}
public HgTestSetup()
{
_progress = new ConsoleProgress();
Root = new TemporaryFolder("ChorusHgWrappingTest");
HgRepository.CreateRepositoryInExistingDir(Root.Path, _progress);
Repository = new HgRepository(Root.Path, new NullProgress());
}
private void Read()
{
try
{
using (FileStream _compressedFile = new FileStream(SourceFile, FileMode.Open))
{
while (_compressedFile.Position < _compressedFile.Length)
{
byte[] lengthBuffer = new byte[8]; //8
_compressedFile.Read(lengthBuffer, 0, lengthBuffer.Length);
int blockLength = BitConverter.ToInt32(lengthBuffer, 4); //4
byte[] compressedData = new byte[blockLength];
lengthBuffer.CopyTo(compressedData, 0);
_compressedFile.Read(compressedData, 8, blockLength - 8);
int _dataSize = BitConverter.ToInt32(compressedData, blockLength - 4);//-4
byte[] lastBuffer = new byte[_dataSize];
ByteBlock _block = new ByteBlock(_counter, lastBuffer, compressedData);
QueueReader.EnqueueForWriting(_block);
_counter++;
ConsoleProgress.ProgressBar(_compressedFile.Position, _compressedFile.Length);
}
QueueReader.Stop();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Cancelled = true;
}
}
public void Sync_NonExistantLangDepotProject_ExitsGracefullyWithCorrectErrorResult()
{
_model = new SyncControlModel(_project, SyncUIFeatures.Minimal, null);
_model.SyncOptions.RepositorySourcesToTry.Add(RepositoryAddress.Create("languageforge", "http://hg-public.languagedepot.org/dummy"));
var progress = new ConsoleProgress()
{
ShowVerbose = true
};
_model.AddMessagesDisplay(progress);
SyncResults results = null;
_model.SynchronizeOver += new EventHandler((sender, e) => results = (sender as SyncResults));
_model.Sync(true);
var start = DateTime.Now;
while (results == null)
{
Thread.Sleep(100);
Application.DoEvents(); //else the background worker may starve
if ((DateTime.Now.Subtract(start).Minutes > 1))
{
Assert.Fail("Gave up waiting.");
}
}
Assert.IsFalse(results.Succeeded);
Assert.IsNotNull(results.ErrorEncountered);
}
public void Run_PathHasDangerousCharacters_DoesCopy()
{
//couldn't make it break on what came to me over email: var problemPart = "07Support&F 7f3";
var problemPart = "{9}";
using (var from = new TemporaryFolder("synctest_source"))
using (var to = new TemporaryFolder("synctest_dest"))
{
using (var sub = new TemporaryFolder(from, problemPart))
{
var fileName = "1.txt";
System.IO.File.WriteAllText(sub.Combine(fileName), "Blah blah");
var source = new RawDirectoryGroup("1", from.Path, null, null);
var groups = new List <FileGroup>(new[] { source });
var progress = new ConsoleProgress()
{
ShowVerbose = true
};
var sync = new MirrorController(to.Path, groups, 100, progress);
sync.Run();
string path = to.Combine("1", problemPart, fileName);
Assert.That(File.Exists(path), path);
}
}
}
private static void OnDownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
double nonZeroSpeed = e.BytesPerSecondSpeed + 0.0001;
int estimateTime = (int)((e.TotalBytesToReceive - e.BytesReceived) / nonZeroSpeed);
bool isMinutes = estimateTime >= 60;
string timeLeftUnit = "seconds";
bool isElapsedTimeMoreThanOneSecond = Environment.TickCount64 - LastTick >= 1000;
ConsoleProgress.Tick((int)(e.ProgressPercentage * 100));
if (isMinutes)
{
timeLeftUnit = "minutes";
estimateTime /= 60;
}
if (isElapsedTimeMoreThanOneSecond)
{
AverageSpeed.Add(e.BytesPerSecondSpeed);
LastTick = Environment.TickCount64;
}
string avgSpeed = CalcMemoryMensurableUnit((long)AverageSpeed.Average());
string speed = CalcMemoryMensurableUnit(e.BytesPerSecondSpeed);
string bytesReceived = CalcMemoryMensurableUnit(e.BytesReceived);
string totalBytesToReceive = CalcMemoryMensurableUnit(e.TotalBytesToReceive);
string progressPercentage = $"{e.ProgressPercentage:F3}".Replace("/", ".");
Console.Title = $"{progressPercentage}% - " +
$"{speed}/s (avg: {avgSpeed}/s) - " +
$"[{bytesReceived} of {totalBytesToReceive}], " +
$"{estimateTime} {timeLeftUnit} left";
}
public void CanCollaborateOnLift()
{
ConsoleProgress progress = new ConsoleProgress();
BobSetup bobSetup = new BobSetup(progress, _pathToTestRoot);
bobSetup.ChangeTextFile();
//Ok, this is unrealistic, but we just clone Bob onto Sally
string sallyMachineRoot = Path.Combine(_pathToTestRoot, "sally");
Directory.CreateDirectory(sallyMachineRoot);
string sallyProjectRoot = bobSetup.SetupClone(sallyMachineRoot);
ProjectFolderConfiguration sallyProject = BobSetup.CreateFolderConfig(sallyProjectRoot);
var repository = HgRepository.CreateOrUseExisting(sallyProject.FolderPath, progress);
repository.SetUserNameInIni("sally", progress);
// bob makes a change and syncs
File.WriteAllText(bobSetup._pathToLift, LiftFileStrings.lift12Dog);
var bobOptions = new SyncOptions
{
CheckinDescription = "added 'dog'",
DoMergeWithOthers = false, // just want a fast checkin
DoSendToOthers = false, // just want a fast checkin
DoPullFromOthers = false // just want a fast checkin
};
bobSetup.GetSynchronizer().SyncNow(bobOptions);
//now Sally modifies the original file, not having seen Bob's changes yet
var sallyPathToLift = Path.Combine(sallyProject.FolderPath, Path.Combine("lexicon", "foo.lift"));
File.WriteAllText(sallyPathToLift, LiftFileStrings.lift12Cat);
//Sally syncs, pulling in Bob's change, and encountering a need to merge (no conflicts)
var sallyOptions = new SyncOptions
{
CheckinDescription = "adding cat",
DoPullFromOthers = true,
DoSendToOthers = true,
DoMergeWithOthers = true
};
sallyOptions.RepositorySourcesToTry.Add(RepositoryAddress.Create("bob's machine", bobSetup.BobProjectPath, false));
var synchronizer = Synchronizer.FromProjectConfiguration(sallyProject, progress);
synchronizer.SyncNow(sallyOptions);
//Debug.WriteLine("bob's: " + File.ReadAllText(bobSetup._pathToLift));
var contents = File.ReadAllText(sallyPathToLift);
//Debug.WriteLine("sally's: " + contents);
Assert.That(contents, Does.Contain("cat"));
Assert.That(contents, Does.Contain("dog"));
}
public void BasicTest()
{
var labels = array("alpha", "bravo", "charlie", "delta", "echo", "foxtrot");
var progress = new ConsoleProgress(10, 30);
foreach (var label in labels)
{
progress.Progress(label, true);
}
}
public override void OnExit(MethodExecutionArgs args)
{
ConsoleProgress progress = new ConsoleProgress();
progress.ProgressBar(60);
for (int i = 0; i < 101; i++)
{
progress.Update(i);
System.Threading.Thread.Sleep(25);
}
}
public void MakeClone_NoProblems_MakesClone()
{
using (var repo = new RepositorySetup("source"))
using (var f = new TemporaryFolder("clonetest"))
{
var model = new CloneFromUsb();
var progress = new ConsoleProgress();
progress.ShowVerbose = true;
model.MakeClone(repo.ProjectFolder.Path, f.Path, progress);
Assert.IsTrue(Directory.Exists(f.Combine(RepositorySetup.ProjectName, ".hg")));
}
}
public void ErrorsEncountered_ErrorOriginatesWithOneHandler_MultiProgressHasErrorsEncountered()
{
var multiProgress = new MultiProgress();
var statusProgress = new StatusProgress();
multiProgress.Add(statusProgress);
var consoleProgress = new ConsoleProgress();
multiProgress.AddMessageProgress(consoleProgress);
statusProgress.WriteError("some error happened!");
Assert.That(multiProgress.ErrorEncountered, Is.True);
}
public void ErrorsEncountered_ErrorOriginatesWithMultiProgress_BothHandlersHaveErrorsEncountered()
{
var multiProgress = new MultiProgress();
var statusProgress = new StatusProgress();
multiProgress.Add(statusProgress);
var consoleProgress = new ConsoleProgress();
multiProgress.AddMessageProgress(consoleProgress);
multiProgress.WriteError("error!");
Assert.That(consoleProgress.ErrorEncountered, Is.True);
Assert.That(statusProgress.ErrorEncountered, Is.True);
}
/// <summary>
/// Train on a set of patterns a specified number of iterations.
/// </summary>
/// <param name="folder">The folder which contains the images to train on. Each image MUST be named with the solution to the CAPTCHA.</param>
/// <param name="iterations">The number of iterations to train.</param>
/// <returns></returns>
public PatternResult TrainOnSet(string folder, int iterations)
{
SolutionSet set = LoadSolutionSet(folder);
if (set.Patterns.Count == 0)
{
set = CreateSolutionSet(folder);
}
using (trainingProgress = new ConsoleProgress("Training "))
{
return(Train(set, iterations));
}
}
public override void OnExit(MethodExecutionArgs args)
{
ConsoleProgress progress = new ConsoleProgress();
progress.ProgressBar(60);
for (int i = 0; i < 101; i++)
{
progress.Update(i);
System.Threading.Thread.Sleep(50);
}
Console.Clear();
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("\nPizza hazır. Afiyet olsun.");
}
public static ConsoleProgress <DataTransferProgress> CreateTransferConsoleProgress(string name)
{
return(ConsoleProgress.Create <DataTransferProgress>(name, (p, c) =>
{
if (p.Description != null)
{
c.Report(p.Description);
}
else if (p.Progress != null)
{
c.Report(p.Progress.Value);
}
}));
}
public static async Task TestTask(ConsoleProgress p)
{
var randomDelayValue = PRNG.Next(50, 150);
for (int i = 0; i < 10; i++)
{
await Task.Delay(randomDelayValue);
p.Dot();
}
lock (L1) p.Done("`070`OK!`");
if (--TasksLeft < 1)
{
Semaphore.Release();
}
}
static void Main(string[] args)
{
var pathname = args[0];
var prog = new ConsoleProgress();
var data = new FwData(pathname, prog);
data.FixErrorsAndSave();
if (prog.DotsWritten)
{
Console.WriteLine();
}
foreach (var err in data.Errors)
{
Console.WriteLine(err);
}
}
private static async Task Populate(params ISeriesParser[] parser)
{
var options = new ProgressBarOptions
{
ForegroundColor = ConsoleColor.Yellow,
BackgroundColor = ConsoleColor.DarkYellow,
ProgressCharacter = '─'
};
var memCache = new MemFile();
var manager = new MangaDownloader(new FileSystem(), parser, Client2.GetDocumentAsync);
var index = new MangaIndex(manager, null, memCache);
var first = true;
ConsoleProgress pb = null;
IProgress <double> GetProgress(string context)
{
pb?.Dispose();
if (first)
{
first = false;
}
else
{
Console.WriteLine();
Console.WriteLine();
}
return(pb = new ConsoleProgress(options, context));
}
try
{
await index.Update(GetProgress);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
//res = await Task.WhenAll(manager.Providers.Select(p => manager.ListInstances(p, pb).ContinueWith(t => (t.Result, provider: p))));
//var res = await MyDictionary;
//MyDictionary = new AsyncLazy<Dictionary<string, MangaInfo>>(CreateDictionary);
}
public void MakeClone_TargetExists_CreatesCloneInWhenTargetIsEmpty()
{
using (var repo = new RepositorySetup("source"))
using (var f = new TemporaryFolder("clonetest"))
{
var model = new CloneFromUsb();
var progress = new ConsoleProgress();
progress.ShowVerbose = true;
var extantFolder = f.Combine(RepositorySetup.ProjectName);
Directory.CreateDirectory(extantFolder);
var cloneFolder = model.MakeClone(repo.ProjectFolder.Path, f.Path, progress);
Assert.AreEqual(extantFolder, cloneFolder);
Assert.IsTrue(Directory.Exists(extantFolder));
Assert.IsFalse(Directory.Exists(extantFolder + "1"));
}
}
private static void OnDownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
{
var nonZeroSpeed = e.BytesPerSecondSpeed == 0 ? 0.0001 : e.BytesPerSecondSpeed;
var estimateTime = (int)((e.TotalBytesToReceive - e.BytesReceived) / nonZeroSpeed);
var isMins = estimateTime >= 60;
var timeLeftUnit = "seconds";
if (isMins)
{
timeLeftUnit = "mins";
estimateTime /= 60;
}
Console.Title = $"{e.ProgressPercentage:N3}% - {CalcMemoryMensurableUnit(e.BytesPerSecondSpeed)}/s - " +
$"[{CalcMemoryMensurableUnit(e.BytesReceived)} of {CalcMemoryMensurableUnit(e.TotalBytesToReceive)}], {estimateTime} {timeLeftUnit} left";
ConsoleProgress.Tick((int)(e.ProgressPercentage * 100));
}
static void Main(string[] args)
{
IProgress progress = null;
if (args.Contains("--silent"))
{
progress = new SilentProgress();
}
else
{
progress = new ConsoleProgress();
}
string inputFolder = Directory.GetCurrentDirectory();
int i = args.ToList().IndexOf("--folder");
if (i >= 0 && i + 1 < args.Count())
{
inputFolder = args[i + 1];
}
string logfilepath = Path.Combine(inputFolder, "Log", "log-.txt");
Log.Logger = new LoggerConfiguration()
.WriteTo.File(logfilepath, rollingInterval: RollingInterval.Day)
.CreateLogger();
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
new TopStopWork(progress)
.WithFolder(inputFolder)
.ProcessFolder();
}
catch (Exception ex)
{
Log.Error($"Error processing folder {inputFolder}: {ex}");
}
sw.Stop();
Log.Information($"Folder {inputFolder} took {HumanTime(sw)} (more precisely, {sw.ElapsedMilliseconds / 1000.0} sec) to process.");
}
void BetterLoading()
{
Console.WriteLine();
Write("We will now simulate a more complex loading sample, please wait!");
Console.CursorVisible = false;
Console.ForegroundColor = ConsoleColor.Green;
for (var i = 0; i <= 100; i++)
{
Thread.Sleep(20);
ConsoleProgress.SetProgress(i, Console.WindowWidth);
}
Console.CursorVisible = true;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine();
}
private void Read()
{
try
{
using (FileStream sourceFile = new FileStream(base.sourceFile, FileMode.Open))
{
int bytesRead;
byte[] lastBuffer;
long fileLength = sourceFile.Length;
while (sourceFile.Position < fileLength && !cancelled)
{
if (queueReader.Count() > maxQueueSize || queueWriter.Count() > maxQueueSize)
{
continue;
}
if (fileLength - sourceFile.Position <= chunkSize)
{
bytesRead = (int)(fileLength - sourceFile.Position);
}
else
{
bytesRead = chunkSize;
}
lastBuffer = new byte[bytesRead];
sourceFile.Read(lastBuffer, 0, bytesRead);
queueReader.EnqueueForCompress(lastBuffer);
ConsoleProgress.ProgressBar(sourceFile.Position, sourceFile.Length);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
cancelled = true;
}
finally
{
queueReader.Stop();
}
}
