public async ValueTask Handle(IBackgroundTaskContext context)
{
if (context.BackgroundTask is not PhysicalDriveInfoBackgroundTask infoBackgroundTask)
{
return;
}
var physicalDrives = await physicalDriveManager.GetPhysicalDrives();
var commandHelper = new CommandHelper();
var logger = loggerFactory.CreateLogger <InfoCommand>();
var infoCommand = new InfoCommand(logger, commandHelper, physicalDrives, infoBackgroundTask.Path);
infoCommand.DiskInfoRead += async(_, args) =>
{
await resultHubConnection.SendInfoResult(args.MediaInfo.ToViewModel());
};
var result = await infoCommand.Execute(context.Token);
if (result.IsFaulted)
{
await errorHubConnection.UpdateError(result.Error.Message, context.Token);
}
}
public async Task WhenReadInfoFromSourceImgWithRigidDiskBlockThenDiskInfoIsReturned()
{
// arrange
var path = Path.Combine("TestData", "rigid-disk-block.img");
var fakeCommandHelper = new FakeCommandHelper(new[] { path });
var cancellationTokenSource = new CancellationTokenSource();
// read info from path
var infoCommand = new InfoCommand(new NullLogger <InfoCommand>(), fakeCommandHelper, Enumerable.Empty <IPhysicalDrive>(), path);
MediaInfo mediaInfo = null;
infoCommand.DiskInfoRead += (_, args) =>
{
mediaInfo = args.MediaInfo;
};
await infoCommand.Execute(cancellationTokenSource.Token);
// assert media info
Assert.NotNull(mediaInfo);
//Assert.Equal(mediaInfo.DiskSize, FakeCommandHelper.ImageSize);
Assert.NotNull(mediaInfo.RigidDiskBlock);
}
public async ValueTask Handle(IBackgroundTaskContext context)
{
if (context.BackgroundTask is not ImageFileInfoBackgroundTask infoBackgroundTask)
{
return;
}
var commandHelper = new CommandHelper();
var logger = loggerFactory.CreateLogger <InfoCommand>();
var infoCommand = new InfoCommand(logger, commandHelper, Enumerable.Empty <IPhysicalDrive>(),
infoBackgroundTask.Path);
infoCommand.DiskInfoRead += async(_, args) =>
{
await resultHubContext.SendInfoResult(args.MediaInfo.ToViewModel());
};
var result = await infoCommand.Execute(context.Token);
if (result.IsFaulted)
{
await errorHubContext.SendError(result.Error.Message, context.Token);
}
}
public async Task WhenReadInfoFromSourceImgThenDiskInfoIsReturned()
{
// arrange
var path = $"{Guid.NewGuid()}.img";
var fakeCommandHelper = new FakeCommandHelper(new[] { path });
var cancellationTokenSource = new CancellationTokenSource();
// read info from path
var infoCommand = new InfoCommand(new NullLogger <InfoCommand>(), fakeCommandHelper, Enumerable.Empty <IPhysicalDrive>(), path);
MediaInfo mediaInfo = null;
infoCommand.DiskInfoRead += (_, args) =>
{
mediaInfo = args.MediaInfo;
};
var result = await infoCommand.Execute(cancellationTokenSource.Token);
Assert.True(result.IsSuccess);
// assert media info
Assert.NotNull(mediaInfo);
Assert.Equal(mediaInfo.DiskSize, FakeCommandHelper.ImageSize);
Assert.Null(mediaInfo.RigidDiskBlock);
}
private void ParseCommand(string line)
{
if (string.IsNullOrEmpty(line))
{
return;
}
//NOTE: Parse in ascending length order!
if (line.Substring(0, 1).Equals("#"))
{
return;
}
if (line.Length < 4)
{
Warn("invalid command: {0}", line);
return;
}
if (line.Substring(0, 4).ToLower().Equals("quit") || line.Substring(0, 4).ToLower().Equals("exit"))
{
return;
}
var idx = line.IndexOf(' ');
string cmd;
if (idx < 0)
{
idx = 0;
cmd = line;
}
else
{
cmd = line.Substring(0, idx).ToLower();
}
var args = idx == 0 ? string.Empty : line.Substring(idx + 1).Trim();
if (CR.abort.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new AbortCommand();
c.Execute(context);
StopTimer(CR.abort + " " + args);
return;
}
if (CR.addalias.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new AddAliasCommand();
c.Execute(context, args);
StopTimer(CR.addalias + " " + args);
return;
}
if (CR.addindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new AddIndexCommand();
c.Execute(context, args);
StopTimer(CR.addindex + " " + args);
return;
}
if (CR.close.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CloseCommand();
c.Execute(context, args);
StopTimer(CR.close + " " + args);
return;
}
if (CR.commit.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CommitCommand();
c.Execute(context, args);
StopTimer(CR.commit + " " + args);
return;
}
if (CR.compactcontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CompactContainerCommand();
c.Execute(context, args);
StopTimer(CR.compactcontainer + " " + args);
return;
}
if (CR.contextquery.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new ContextQueryCommand();
c.Execute(context, args);
StopTimer(CR.contextquery + " " + args);
return;
}
if (CR.cquery.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CQueryCommand();
c.Execute(context, args);
StopTimer(CR.cquery + " " + args);
return;
}
if (CR.createcontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new CreateContainerCommand();
c.Execute(context, args);
StopTimer(CR.createcontainer + " " + args);
return;
}
if (CR.delindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new DeleteIndexCommand();
c.Execute(context, args);
StopTimer(CR.delindex + " " + args);
return;
}
if (CR.echo.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
Msg(args);
return;
}
if (CR.getdocuments.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new GetDocumentsCommand();
c.Execute(context, args);
StopTimer(CR.getdocuments + " " + args);
return;
}
if (CR.getmetadata.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new GetMetadataCommand();
c.Execute(context, args);
StopTimer(CR.getmetadata + " " + args);
return;
}
if (CR.help.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
var c = new HelpCommand();
c.Execute(args);
return;
}
if (CR.info.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new InfoCommand();
c.Execute(context, args);
StopTimer(CR.info + " " + args);
return;
}
if (CR.listindexes.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new ListIndexesCommand();
c.Execute(context, args);
StopTimer(CR.listindexes + " " + args);
return;
}
if (CR.lookupedgeindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new LookupEdgeIndexCommand();
c.Execute(context, args);
StopTimer(CR.lookupedgeindex + " " + args);
return;
}
if (CR.lookupindex.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new LookupIndexCommand();
c.Execute(context, args);
StopTimer(CR.lookupindex + " " + args);
return;
}
if (CR.lookupstats.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new LookupStatisticsCommand();
c.Execute(context, args);
StopTimer(CR.lookupstats + " " + args);
return;
}
if (CR.opencontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new OpenContainerCommand();
c.Execute(context, args);
StopTimer(CR.opencontainer + " " + args);
return;
}
if (CR.preload.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new PreloadCommand();
c.Execute(context, args);
StopTimer(CR.preload + " " + args);
return;
}
if (CR.prepare.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new PrepareCommand();
c.Execute(context, args);
StopTimer(CR.prepare + " " + args);
return;
}
if (CR.print.IndexOf(cmd, 0, StringComparison.Ordinal) == 0 || cmd.ToLower().Equals("printnames"))
{
StartTimer();
var c = new PrintCommand();
c.Execute(context, cmd.Equals("printnames") ? "printnames " + args : args);
StopTimer(cmd.Equals("printnames") ? "printNames" : CR.print);
return;
}
if (CR.putdocuments.Equals(cmd))
{
StartTimer();
var c = new PutDocumentsCommand();
c.Execute(context, args);
StopTimer(CR.putdocuments + " " + args);
return;
}
if (CR.putdocument.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new PutDocumentCommand();
c.Execute(context, args);
StopTimer(CR.putdocument + " " + args);
return;
}
if (CR.query.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new QueryCommand();
c.Execute(context, args);
StopTimer(CR.query + " " + args);
return;
}
if (CR.queryplan.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new QueryPlanCommand();
c.Execute(context, args);
StopTimer(CR.queryplan + " " + args);
return;
}
if (CR.reindexcontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new ReindexContainerCommand();
c.Execute(context, args);
StopTimer(CR.reindexcontainer + " " + args);
return;
}
if (CR.removealias.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new RemoveAliasCommand();
c.Execute(context, args);
StopTimer(CR.removealias + " " + args);
return;
}
if (CR.removecontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new RemoveContainerCommand();
c.Execute(context, args);
StopTimer(CR.removecontainer + " " + args);
return;
}
if (CR.removedocument.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new RemoveDocumentCommand();
c.Execute(context, args);
StopTimer(CR.removedocument + " " + args);
return;
}
if (CR.run.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
var c = new RunCommand();
c.Execute(context, args);
var l2 = new List <string>(originalArgs)
{
"-s", c.Script
};
StartTimer();
Main(l2.ToArray());
StopTimer(CR.run + " " + args);
return;
}
if (CR.setautoindexing.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetAutoIndexingCommand();
c.Execute(context, args);
StopTimer(CR.setautoindexing + " " + args);
return;
}
if (CR.setbaseuri.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetBaseUriCommand();
c.Execute(context, args);
StopTimer(CR.setbaseuri + " " + args);
return;
}
if (CR.setignore.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
var c = new SetIgnoreCommand();
c.Execute(context, args);
ignoreErrors = c.Ignore;
return;
}
if (CR.setlazy.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetLazyCommand();
c.Execute(context, args);
StopTimer(CR.setlazy + " " + args);
return;
}
if (CR.setmetadata.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetMetadataCommand();
c.Execute(context, args);
StopTimer(CR.setmetadata + " " + args);
return;
}
if (CR.setnamespace.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetNamespaceCommand();
c.Execute(context, args);
StopTimer(CR.setnamespace + " " + args);
return;
}
if (CR.setprojection.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetProjectionCommand();
c.Execute(context, args);
StopTimer(CR.setprojection + " " + args);
return;
}
if (CR.setquerytimeout.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetQueryTimeoutCommand();
c.Execute(context, args);
StopTimer(CR.setquerytimeout + " " + args);
return;
}
if (CR.setvariable.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetVariableCommand();
c.Execute(context, args);
StopTimer(CR.setvariable + " " + args);
return;
}
if (CR.setverbose.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new SetVerboseCommand();
c.Execute(context, args);
StopTimer(CR.setverbose + " " + args);
return;
}
if (CR.sync.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
context.Sync();
StopTimer(CR.sync + " " + args);
return;
}
if (CR.time.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
time = true;
ParseCommand(args);
return;
}
if (CR.transaction.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new TransactionCommand();
c.Execute(context, args);
StopTimer(CR.transaction + " " + args);
return;
}
if (CR.upgradecontainer.IndexOf(cmd, 0, StringComparison.Ordinal) == 0)
{
StartTimer();
var c = new UpgradeContainerCommand();
c.Execute(context, args);
StopTimer(CR.upgradecontainer + " " + args);
return;
}
Warn("Command not recognized: {0}", cmd);
}
public Dictionary <string, string> GetInfo()
{
var command = new InfoCommand();
return(command.Execute());
}
static async Task Run(Arguments arguments)
{
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
var serviceProvider = new ServiceCollection()
.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true))
.BuildServiceProvider();
var loggerFactory = serviceProvider.GetService <ILoggerFactory>();
var isAdministrator = OperatingSystem.IsAdministrator();
if (!isAdministrator)
{
Console.WriteLine("Requires administrator rights!");
}
var commandHelper = new CommandHelper();
var physicalDrives = (await GetPhysicalDrives(arguments)).ToList();
var cancellationTokenSource = new CancellationTokenSource();
switch (arguments.Command)
{
case Arguments.CommandEnum.List:
var listCommand = new ListCommand(loggerFactory.CreateLogger <ListCommand>(), commandHelper, physicalDrives);
listCommand.ListRead += (_, args) =>
{
//
// await Task.Run(() =>
// {
// Console.WriteLine(JsonSerializer.Serialize(physicalDrivesList, JsonSerializerOptions));
// });
InfoPresenter.PresentInfo(args.MediaInfos);
};
var listResult = await listCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(listResult.IsSuccess ? "Done" : $"ERROR: Read failed, {listResult.Error}");
break;
case Arguments.CommandEnum.Info:
var infoCommand = new InfoCommand(loggerFactory.CreateLogger <InfoCommand>(), commandHelper, physicalDrives, arguments.SourcePath);
infoCommand.DiskInfoRead += (_, args) => { InfoPresenter.PresentInfo(args.MediaInfo); };
var infoResult = await infoCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(infoResult.IsSuccess ? "Done" : $"ERROR: Read failed, {infoResult.Error}");
break;
case Arguments.CommandEnum.Read:
Console.WriteLine("Reading physical drive to image file");
GenericPresenter.PresentPaths(arguments);
var readCommand = new ReadCommand(loggerFactory.CreateLogger <ReadCommand>(), commandHelper, physicalDrives, arguments.SourcePath,
arguments.DestinationPath,
arguments.Size);
readCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); };
var readResult = await readCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(readResult.IsSuccess ? "Done" : $"ERROR: Read failed, {readResult.Error}");
break;
case Arguments.CommandEnum.Convert:
Console.WriteLine("Converting source image to destination image file");
GenericPresenter.PresentPaths(arguments);
var convertCommand = new ConvertCommand(loggerFactory.CreateLogger <ConvertCommand>(), commandHelper, arguments.SourcePath,
arguments.DestinationPath,
arguments.Size);
convertCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); };
var convertResult = await convertCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(
convertResult.IsSuccess ? "Done" : $"ERROR: Convert failed, {convertResult.Error}");
break;
case Arguments.CommandEnum.Write:
Console.WriteLine("Writing source image file to physical drive");
GenericPresenter.PresentPaths(arguments);
var writeCommand = new WriteCommand(loggerFactory.CreateLogger <WriteCommand>(), commandHelper, physicalDrives, arguments.SourcePath,
arguments.DestinationPath,
arguments.Size);
writeCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); };
var writeResult = await writeCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(writeResult.IsSuccess ? "Done" : $"ERROR: Write failed, {writeResult.Error}");
break;
case Arguments.CommandEnum.Verify:
Console.WriteLine("Verifying source image to destination");
GenericPresenter.PresentPaths(arguments);
var verifyCommand = new VerifyCommand(loggerFactory.CreateLogger <VerifyCommand>(), commandHelper, physicalDrives, arguments.SourcePath,
arguments.DestinationPath,
arguments.Size);
verifyCommand.DataProcessed += (_, args) => { GenericPresenter.Present(args); };
var verifyResult = await verifyCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(verifyResult.IsSuccess ? "Done" : $"ERROR: Verify failed, {verifyResult.Error}");
break;
case Arguments.CommandEnum.Blank:
Console.WriteLine("Creating blank image");
Console.WriteLine($"Path: {arguments.SourcePath}");
var blankCommand = new BlankCommand(loggerFactory.CreateLogger <BlankCommand>(), commandHelper, arguments.SourcePath, arguments.Size);
var blankResult = await blankCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(blankResult.IsSuccess ? "Done" : $"ERROR: Blank failed, {blankResult.Error}");
break;
case Arguments.CommandEnum.Optimize:
Console.WriteLine("Optimizing image file");
Console.WriteLine($"Path: {arguments.SourcePath}");
var optimizeCommand = new OptimizeCommand(loggerFactory.CreateLogger <OptimizeCommand>(), commandHelper, arguments.SourcePath);
var optimizeResult = await optimizeCommand.Execute(cancellationTokenSource.Token);
Console.WriteLine(optimizeResult.IsSuccess
? "Done"
: $"ERROR: Optimize failed, {optimizeResult.Error}");
break;
}
}
