/// <summary> /// Runs this step asynchronously. /// </summary> protected async Task <Result <T, IError> > RunAsync( IStateMonad stateMonad, CancellationToken cancellationToken) { var methodParameters = await TryGetMethodParameters(stateMonad, cancellationToken); if (methodParameters.IsFailure) { return(methodParameters.ConvertFailure <T>()); } var nuixConnection = await stateMonad.GetOrCreateNuixConnection(this, false); if (nuixConnection.IsFailure) { return(nuixConnection.ConvertFailure <T>().MapError(x => x.WithLocation(this))); } var runResult = await nuixConnection.Value.RunFunctionAsync( stateMonad, this, RubyScriptStepFactory.RubyFunction, methodParameters.Value, CasePathParameter, cancellationToken ); if (runResult.IsFailure && runResult.Error.GetErrorBuilders() .Any(x => x.Data is ErrorData.ExceptionData { Exception: ChannelClosedException }))
public async Task GetOrCreateNuixConnection_WhenScriptFileDoesNotExist_ReturnsError() { var fakeExternalProcess = new ExternalProcessMock( 1, ConnectionTestsHelper.GetCreateCaseAction() ); var fileMock = Mock.Of <IFile>(f => f.Exists(It.IsAny <string>()) == false); IStateMonad state = ConnectionTestsHelper.GetStateMonad( TestLoggerFactory.Create(), fakeExternalProcess, ConsoleAdapter.Instance ); //Remove the script from the file system var nuixFileSystem = state.ExternalContext.TryGetContext <IFileSystem>(ConnectorInjection.FileSystemKey); nuixFileSystem.Value.File.Delete(NuixConnectionHelper.NuixGeneralScriptName); var connection = await state.GetOrCreateNuixConnection(null, false); Assert.True(connection.IsFailure); Assert.Matches( $"Could not find.+{NuixConnectionHelper.NuixGeneralScriptName}'", connection.Error.AsString ); }
/// <inheritdoc /> protected override async Task <Result <Unit, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { await Task.CompletedTask; var r = await stateMonad.GetOrCreateNuixConnection(this, false); if (r.IsFailure) { return(r.MapError(x => x.WithLocation(this)).ConvertFailure <Unit>()); } return(Unit.Default); }
public async Task GetOrCreateNuixConnection_OnStartExternalProcessFailure_ReturnsError() { var fakeExternalProcess = new ExternalProcessMock(1, ConnectionTestsHelper.GetCreateCaseAction()) { ProcessPath = "WrongPath", ValidateArguments = false }; var loggerFactory = TestLoggerFactory.Create(); IStateMonad state = ConnectionTestsHelper.GetStateMonad( fakeExternalProcess, loggerFactory ); var createConnection = await state.GetOrCreateNuixConnection(null, true); createConnection.ShouldBeFailure(); createConnection.Error.AsString.Should() .Be($"External Process Failed: 'Could not start '{Constants.NuixConsoleExe}''"); }
/// <inheritdoc /> protected override async Task <Result <StringStream, IError> > Run( IStateMonad stateMonad, CancellationToken cancellationToken) { //var isAdmin = IsCurrentProcessAdmin(); //var isLinux = IsLinux; //if(isAdmin &&!isLinux) // return new SingleError("You cannot run arbitrary Nuix Scripts as Administrator", ErrorCode.ExternalProcessError, new StepErrorLocation(this)); var functionName = await FunctionName.Run(stateMonad, cancellationToken) .Map(x => x.GetStringAsync()) ; if (functionName.IsFailure) { return(functionName.ConvertFailure <StringStream>()); } var scriptText = await ScriptText.Run(stateMonad, cancellationToken) .Map(x => x.GetStringAsync()); if (scriptText.IsFailure) { return(scriptText.ConvertFailure <StringStream>()); } var parameters = await Parameters.Run(stateMonad, cancellationToken); if (parameters.IsFailure) { return(parameters.ConvertFailure <StringStream>()); } var nuixConnection = await stateMonad.GetOrCreateNuixConnection(this, false); if (nuixConnection.IsFailure) { return(nuixConnection.ConvertFailure <StringStream>() .MapError(x => x.WithLocation(this))); } var rubyFunctionParameters = parameters.Value .Select(x => new RubyFunctionParameter(ConvertString(x.Name), x.Name, true)) .ToList(); var parameterDict = parameters.Value .ToDictionary( x => new RubyFunctionParameter(ConvertString(x.Name), x.Name, true), x => x.BestValue.ObjectValue ) .Where(x => x.Value != null) .ToDictionary(x => x.Key, x => x.Value !); if (EntityStreamParameter != null) { var streamResult = await EntityStreamParameter.Run(stateMonad, cancellationToken); if (streamResult.IsFailure) { return(streamResult.ConvertFailure <StringStream>()); } const string streamParameter = "datastream"; var parameter = new RubyFunctionParameter( ConvertString(streamParameter), streamParameter, true ); rubyFunctionParameters.Add(parameter); parameterDict.Add(parameter, streamResult.Value); } var function = new RubyFunction <string>( ConvertString(functionName.Value), scriptText.Value, rubyFunctionParameters, new Version(5, 0), ArraySegment <NuixFeature> .Empty ); var runResult = await nuixConnection.Value.RunFunctionAsync( stateMonad, this, function, parameterDict, CasePathParameter.IgnoresOpenCase.Instance, cancellationToken ) .Map(x => new StringStream(x)); if (runResult.IsFailure) { return(runResult.MapError(x => x.WithLocation(this)).ConvertFailure <StringStream>()); } return(runResult.Value); }