public async Task WhenOptimizeImgWithRigidDiskBlockThenSizeIsChanged() { // arrange var path = $"{Guid.NewGuid()}.img"; var rigidDiskBlockSize = 8192; var fakeCommandHelper = new FakeCommandHelper(rigidDiskBlock: new RigidDiskBlock { DiskSize = rigidDiskBlockSize }); // var bytes = fakeCommandHelper.CreateTestData(); fakeCommandHelper.WriteableMedias.Add(new Media(path, path, rigidDiskBlockSize, Media.MediaType.Raw, false, new MemoryStream(new byte[16384]))); var cancellationTokenSource = new CancellationTokenSource(); // optimize var optimizeCommand = new OptimizeCommand(new NullLogger <OptimizeCommand>(), fakeCommandHelper, path); var result = await optimizeCommand.Execute(cancellationTokenSource.Token); Assert.True(result.IsSuccess); // assert media contains optimized rigid disk block size var optimizedBytes = fakeCommandHelper.GetMedia(path).GetBytes(); Assert.Equal(rigidDiskBlockSize, optimizedBytes.Length); }
/// <summary> /// Optimizes Solr's index /// </summary> /// <param name="waitFlush">Wait for flush</param> /// <param name="waitSearcher">Wait for new searcher</param> /// <param name="expungeDeletes">Merge segments with deletes away</param> /// <param name="maxSegments">Optimizes down to, at most, this number of segments</param> public static void Optimize(bool waitFlush, bool waitSearcher, bool expungeDeletes, int maxSegments) { var cmd = new OptimizeCommand { WaitFlush = waitFlush, WaitSearcher = waitSearcher, ExpungeDeletes = expungeDeletes, MaxSegments = maxSegments }; cmd.Execute(Connection); }
/// <summary> /// Optimizes Solr's index /// </summary> /// <param name="waitFlush">Wait for flush</param> /// <param name="waitSearcher">Wait for new searcher</param> public static void Optimize(bool waitFlush, bool waitSearcher) { var cmd = new OptimizeCommand { WaitFlush = waitFlush, WaitSearcher = waitSearcher }; cmd.Execute(Connection); }
public ResponseHeader Optimize(CommitOptions options) { options = options ?? new CommitOptions(); var cmd = new OptimizeCommand { WaitFlush = options.WaitFlush, WaitSearcher = options.WaitSearcher, ExpungeDeletes = options.ExpungeDeletes, MaxSegments = options.MaxSegments, }; return(SendAndParseHeader(cmd)); }
private static OptimizeCommand GetOptimizeCommand(CommitOptions options) { options = options ?? new CommitOptions(); var cmd = new OptimizeCommand { WaitFlush = options.WaitFlush, WaitSearcher = options.WaitSearcher, ExpungeDeletes = options.ExpungeDeletes, MaxSegments = options.MaxSegments, }; return(cmd); }
public void ExecuteBasic() { var conn = new MSolrConnection(); conn.post += (url, content) => { Assert.AreEqual("/update", url); Assert.AreEqual("<optimize />", content); Console.WriteLine(content); return(null); }; var cmd = new OptimizeCommand(); cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }
public void ExecuteWithBasicOptions() { var conn = new MSolrConnection(); conn.post += (url, content) => { Assert.AreEqual("/update", url); Assert.AreEqual("<optimize waitSearcher=\"true\" waitFlush=\"true\" />", content); Console.WriteLine(content); return(null); }; var cmd = new OptimizeCommand { WaitFlush = true, WaitSearcher = true }; cmd.Execute(conn); Assert.AreEqual(1, conn.post.Calls); }
public async ValueTask Handle(IBackgroundTaskContext context) { if (context.BackgroundTask is not OptimizeBackgroundTask optimizeBackgroundTask) { return; } try { await progressHubContext.SendProgress(new Progress { Title = optimizeBackgroundTask.Title, IsComplete = false, PercentComplete = 50, }, context.Token); var commandHelper = new CommandHelper(); var optimizeCommand = new OptimizeCommand(loggerFactory.CreateLogger <OptimizeCommand>(), commandHelper, optimizeBackgroundTask.Path); var result = await optimizeCommand.Execute(context.Token); await Task.Delay(1000, context.Token); await progressHubContext.SendProgress(new Progress { Title = optimizeBackgroundTask.Title, IsComplete = true, HasError = result.IsFaulted, ErrorMessage = result.IsFaulted ? result.Error.Message : null, PercentComplete = 100 }, context.Token); } catch (Exception e) { await progressHubContext.SendProgress(new Progress { Title = optimizeBackgroundTask.Title, IsComplete = true, HasError = true, ErrorMessage = e.Message, PercentComplete = 100 }, context.Token); } }
public void ExecuteBasic() { var mocks = new MockRepository(); var conn = mocks.StrictMock <ISolrConnection>(); With.Mocks(mocks).Expecting(() => { conn.Post("/update", "<optimize />"); LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) { Console.WriteLine(s); return(null); })); }).Verify(() => { var cmd = new OptimizeCommand(); cmd.Execute(conn); }); }
public void ExecuteWithAllOptions() { var conn = new MSolrConnection(); conn.post += (url, content) => { Assert.Equal("/update", url); Assert.Equal("<optimize waitSearcher=\"true\" waitFlush=\"true\" expungeDeletes=\"true\" maxSegments=\"2\" />", content); testOutputHelper.WriteLine(content); return(null); }; var cmd = new OptimizeCommand { MaxSegments = 2, ExpungeDeletes = true, WaitFlush = true, WaitSearcher = true }; cmd.Execute(conn); Assert.Equal(1, conn.post.Calls); }
public void ExecuteWithAllOptions() { var mocks = new MockRepository(); var conn = mocks.StrictMock <ISolrConnection>(); With.Mocks(mocks).Expecting(() => { conn.Post("/update", "<optimize waitSearcher=\"true\" waitFlush=\"true\" expungeDeletes=\"true\" maxSegments=\"2\" />"); LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s) { Console.WriteLine(s); return(null); })); }).Verify(() => { var cmd = new OptimizeCommand(); cmd.MaxSegments = 2; cmd.ExpungeDeletes = true; cmd.WaitFlush = true; cmd.WaitSearcher = true; cmd.Execute(conn); }); }
public async Task WhenOptimizeImgWithoutRigidDiskBlockThenSizeIsNotChanged() { // arrange var path = $"{Guid.NewGuid()}.img"; var fakeCommandHelper = new FakeCommandHelper(); var bytes = fakeCommandHelper.CreateTestData(); fakeCommandHelper.WriteableMedias.Add(new Media(path, path, bytes.Length, Media.MediaType.Raw, false, new MemoryStream(bytes))); var cancellationTokenSource = new CancellationTokenSource(); // optimize var optimizeCommand = new OptimizeCommand(new NullLogger <OptimizeCommand>(), fakeCommandHelper, path); var result = await optimizeCommand.Execute(cancellationTokenSource.Token); Assert.True(result.IsSuccess); // assert bytes and media optimized bytes are identical var optimizedBytes = fakeCommandHelper.GetMedia(path).GetBytes(); Assert.Equal(bytes.Length, optimizedBytes.Length); Assert.Equal(bytes, optimizedBytes); }
/// <inheritdoc /> public ResponseHeader Optimize(CommitOptions options) { OptimizeCommand cmd = GetOptimizeCommand(options); return(SendAndParseHeader(cmd)); }
/// <summary> /// Optimizes Solr's index /// </summary> public static void Optimize() { var cmd = new OptimizeCommand(); cmd.Execute(Connection); }
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; } }