public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { // Write counter to a file - Should be running for 10 seconds roughly int counter = 1000; string[] lines = new string[counter]; for (int i = 0; i < counter; i++) { lines[i] = DateTime.Now.Ticks.ToString(); Thread.Sleep(10); } File.WriteAllLines(@"C:\temp\MyDummyTasklet_out_" + DateTime.Now.Ticks + ".txt", lines); return RepeatStatus.Finished; }
/// <summary> /// Configures a <see cref="Sorter{T}"/> and executes it. /// </summary> /// <param name="contribution">ignored</param> /// <param name="chunkContext">ignored</param> /// <returns><see cref="RepeatStatus.Finished"/></returns> public new RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { Logger.Info("Starting ExtendedSort tasklet."); SplitSorter<byte[]> sorter = (SplitSorter<byte[]>)BuildSorter(); var stopwatch = new Stopwatch(); stopwatch.Start(); sorter.Sort(Input.Select(r => r.GetFileInfo()).ToList(), Output.GetFileInfo()); stopwatch.Stop(); Logger.Info("Total sort time: {0:F2}s", stopwatch.ElapsedMilliseconds / 1000d); contribution.ExitStatus = ExitStatus.Completed; return RepeatStatus.Finished; }
/// <summary> /// Manage the StepContext lifecycle. Business processing should be /// delegated to <see cref="DoInChunkContext"/>. This /// is to ensure that the current thread has a reference to the context, even /// if the callback is executed in a pooled thread. Handles the registration /// and unregistration of the step context, so clients should not duplicate /// those calls. /// </summary> /// <param name="stepExecution"></param> /// <param name="doInChunkContext"></param> /// <returns></returns> public static RepeatCallback GetRepeatCallback(StepExecution stepExecution, DoInChunkContext doInChunkContext) { BlockingCollection <ChunkContext> attributeQueue = new BlockingCollection <ChunkContext>(); return(context => { // The StepContext has to be the same for all chunks, // otherwise step-scoped beans will be re-initialised for each chunk. StepContext stepContext = StepSynchronizationManager.Register(stepExecution); if (Logger.IsDebugEnabled) { Logger.Debug("Preparing chunk execution for StepContext: {0}", ObjectUtils.IdentityToString(stepContext)); } ChunkContext chunkContext; attributeQueue.TryTake(out chunkContext); if (chunkContext == null) { chunkContext = new ChunkContext(stepContext); } try { Logger.Debug("Chunk execution starting: queue size= {0}", attributeQueue.Count); return doInChunkContext(context, chunkContext); //Delegation } finally { // Still some stuff to do with the data in this chunk, // pass it back. if (!chunkContext.Complete) { attributeQueue.Add(chunkContext); } StepSynchronizationManager.Close(); } }); }
/// <summary> /// Scan remote directory for files matching the given file name pattern and download /// them, if any, to the given local directory. /// @see ITasklet#Execute /// </summary> /// <param name="contribution"></param> /// <param name="chunkContext"></param> /// <returns></returns> public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { //Delegated DoExecute(); return RepeatStatus.Finished; }
public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { _logger.Info("OK transition was used"); return RepeatStatus.Finished; }
/// <summary> /// Custom constructor /// </summary> /// <param name="chunkContext"></param> /// <param name="semaphore"></param> /// <param name="owner"></param> public ChunkTransactionCallback(ChunkContext chunkContext, Semaphore semaphore, TaskletStep owner) { _chunkContext = chunkContext; _stepExecution = chunkContext.StepContext.StepExecution; _semaphore = semaphore; _ownerStep = owner; }
/// <summary> /// Do nothing execution, since all the logic is in after step /// </summary> /// <param name="contribution"></param> /// <param name="chunkContext"></param> /// <returns></returns> public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { return RepeatStatus.Finished; }
/// <summary> /// Manage the StepContext lifecycle. Business processing should be /// delegated to #DoInChunkContext(RepeatContext, ChunkContext). This /// is to ensure that the current thread has a reference to the context, even /// if the callback is executed in a pooled thread. Handles the registration /// and unregistration of the step context, so clients should not duplicate /// those calls. /// </summary> /// <param name="stepExecution"></param> /// <param name="doInChunkContext"></param> /// <returns></returns> public static RepeatCallback GetRepeatCallback(StepExecution stepExecution, DoInChunkContext doInChunkContext) { BlockingCollection<ChunkContext> attributeQueue = new BlockingCollection<ChunkContext>(); return context => { // The StepContext has to be the same for all chunks, // otherwise step-scoped beans will be re-initialised for each chunk. StepContext stepContext = StepSynchronizationManager.Register(stepExecution); if (Logger.IsDebugEnabled) { Logger.Debug("Preparing chunk execution for StepContext: {0}", ObjectUtils.IdentityToString(stepContext)); } ChunkContext chunkContext; attributeQueue.TryTake(out chunkContext); if (chunkContext == null) { chunkContext = new ChunkContext(stepContext); } try { Logger.Debug("Chunk execution starting: queue size= {0}", attributeQueue.Count); return doInChunkContext(context, chunkContext); //Delegation } finally { // Still some stuff to do with the data in this chunk, // pass it back. if (!chunkContext.Complete) { attributeQueue.Add(chunkContext); } StepSynchronizationManager.Close(); } }; }
public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { // open connection using (DbConnection connection = _providerFactory.CreateConnection()) { connection.ConnectionString = _connectionString; connection.Open(); string preparedCommand = PrepareCommands(Resource); DbCommand command = connection.CreateCommand(); command.CommandText = preparedCommand; int sqlDone = command.ExecuteNonQuery(); if(Logger.IsTraceEnabled) { Logger.Trace("SQL script execution end with {0} return code", sqlDone); } } return RepeatStatus.Finished; }
/// <summary> /// Configures a <see cref="Sorter{T}"/> and executes it. /// </summary> /// <param name="contribution">ignored</param> /// <param name="chunkContext">ignored</param> /// <returns><see cref="RepeatStatus.Finished"/></returns> public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { Logger.Info("Starting sort tasklet."); var sorter = BuildSorter(); var stopwatch = new Stopwatch(); stopwatch.Start(); sorter.Sort(); stopwatch.Stop(); Logger.Info("Total sort time: {0:F2}s", stopwatch.ElapsedMilliseconds / 1000d); contribution.ExitStatus = ExitStatus.Completed; return RepeatStatus.Finished; }
private void CheckStoppingState(ChunkContext chunkContext) { if (_stoppable) { JobExecution jobExecution = JobExplorer.GetJobExecution(chunkContext.StepContext.StepExecution.GetJobExecutionId().Value); if (jobExecution.IsStopping()) { _stopped = true; } } }
/// <summary> /// Wraps command execution into system process call. /// </summary> /// <returns></returns> /// <exception cref="Exception"></exception> public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { if (Logger.IsTraceEnabled) { Logger.Trace("*** Executing PowerShell Script File: {0}", ScriptResource.GetFullPath()); } //=> PowerShell will throw an error if we do not Suppress ambient transaction... // see https://msdn.microsoft.com/en-us/library/system.transactions.transaction.current(v=vs.110).aspx#NotExistJustToMakeTheAElementVisible using (var transactionScope = new TransactionScope(TransactionScopeOption.Suppress)) { //=> Runspace configuration information includes the assemblies, commands, format and type files, // providers, and scripts that are available within the runspace. RunspaceConfiguration runspaceConfiguration = RunspaceConfiguration.Create(); //Creates a single runspace that uses the default host and runspace configuration using (Runspace runSpace = RunspaceFactory.CreateRunspace(runspaceConfiguration)) { //=> When this runspace is opened, the default host and runspace configuration // that are defined by Windows PowerShell will be used. runSpace.Open(); //=> Set Variables so they are available to user script... if (Variables != null && Variables.Any()) { foreach (KeyValuePair<string, object> variable in Variables) { runSpace.SessionStateProxy.SetVariable(variable.Key, variable.Value); } } //=> this is exit status variables to be tested on exit from power shell script... // it is defined in PwerShell global scope...and must be set by scipt writer on exit... runSpace.SessionStateProxy.SetVariable("ScriptExitStatus", _scriptExitStatus); //=> Allows the execution of commands from a CLR //RunspaceInvoke scriptInvoker = new RunspaceInvoke(runSpace); //scriptInvoker.Invoke("Set-ExecutionPolicy Unrestricted"); using (PowerShell psInstance = PowerShell.Create()) { try { // prepare a new collection to store output stream objects PSDataCollection<PSObject> outputCollection = new PSDataCollection<PSObject>(); outputCollection.DataAdded += AllStreams_DataAdded; psInstance.Streams.Error.DataAdded += AllStreams_DataAdded; psInstance.Streams.Verbose.DataAdded += AllStreams_DataAdded; psInstance.Streams.Warning.DataAdded += AllStreams_DataAdded; psInstance.Streams.Debug.DataAdded += AllStreams_DataAdded; psInstance.Runspace = runSpace; //=> This tasklet should be in the same dll as ExitStatus, i.e. Summer.Batch.Core.dll // we need to get the path to loaded Summer.Batch.Core.dll so we can load it in PowerShell var assemblyLocation = System.Reflection.Assembly.GetExecutingAssembly().Location; //=> need to load Summer.Batch.Core into runspace so we can reference ExitStatus psInstance.AddScript("[System.Reflection.Assembly]::LoadFrom(\""+assemblyLocation+"\")").AddStatement(); //=> add user command and its parameters... psInstance.AddCommand(ScriptResource.GetFullPath()); if (Parameters != null && Parameters.Any()) { foreach (KeyValuePair<string, object> variable in Parameters) { psInstance.AddParameter(variable.Key, variable.Value); } } //=> Invoke Asynchronously... IAsyncResult asyncResult = psInstance.BeginInvoke<PSObject, PSObject>(null, outputCollection); // do something else until execution has completed. long t0 = DateTime.Now.Ticks; while (!asyncResult.IsCompleted) { //=> take a nap and let script do its job... Thread.Sleep(new TimeSpan(_checkInterval)); //=> to check if job was told to stop... CheckStoppingState(chunkContext); //=> lets make sure we did not exceed alloted time... long timeFromT0 = (long)(new TimeSpan(DateTime.Now.Ticks - t0)).TotalMilliseconds; if (timeFromT0 > _timeout) { //=> Stop PowerShell... psInstance.Stop(); //=> behave based on TimeoutBehaviorOption if (_timeoutBehavior.Equals(TimeoutBehaviorOption.SetExitStatusToFailed)) { contribution.ExitStatus = ExitStatus.Failed; break; } else if (_timeoutBehavior.Equals(TimeoutBehaviorOption.ThrowException)) { //=> lets dump what we got before throwing an error... LogStreams(); throw new FatalStepExecutionException("Execution of PowerShell script exceeded allotted time.", null); } } else if (_execution.TerminateOnly) { //=> Stop PowerShell... psInstance.Stop(); //=> lets dump what we got before throwing an error... LogStreams(); throw new JobInterruptedException( string.Format("Job interrupted while executing PowerShell script '{0}'", ScriptResource.GetFilename())); } else if (_stopped) { psInstance.Stop(); contribution.ExitStatus = ExitStatus.Stopped; break; } } // end while scope //=> Wait to the end of execution... //psInstance.EndInvoke(_asyncResult); //NOTE: asyncResult.IsCompleted will be set to true if PowerShell.Stop was called or // PowerShell completed its work //=> if status not yet set (script completed)...handle completion... if (contribution.ExitStatus.IsRunning()) { //=> script needs to set exit code...if exit code not set we assume 0 var lastExitCode = (int)runSpace.SessionStateProxy.PSVariable.GetValue("LastExitCode", 0); _scriptExitStatus = runSpace.SessionStateProxy.GetVariable("ScriptExitStatus") as ExitStatus; //=> set exit status... if (_scriptExitStatus != null && !_scriptExitStatus.IsRunning()) { if (Logger.IsTraceEnabled) { Logger.Trace("***> ScriptExitStatus returned by script => {0}", _scriptExitStatus); } contribution.ExitStatus = _scriptExitStatus; } else //=> let user decide on ExitStatus { if (Logger.IsTraceEnabled) { if (_scriptExitStatus == null) { Logger.Trace("***> ScriptExitStatus is null. Using PowerShellExitCodeMapper to determine ExitStatus."); } else if (_scriptExitStatus.IsRunning()) { Logger.Trace("***> ScriptExitStatus is EXECUTING or UNKNOWN. Using PowerShellExitCodeMapper to determine ExitStatus."); } } if (PowerShellExitCodeMapper != null) { //=> determine exit status using User Provided PowerShellExitCodeMapper contribution.ExitStatus = PowerShellExitCodeMapper.GetExitStatus(lastExitCode); } else //at this point we are not able to determine exit status, user needs to fix this... { //=> lets dump what we got before throwing an error... LogStreams(); throw new FatalStepExecutionException( "PowerShellTasklet is not able to determine ExitStatus. ScriptExitStatus is null or (is EXECUTING or UNKNOWN) and "+ "PowerShellExitCodeMapper is NOT defined. Please set $global:ScriptExitStatus or define PowerShellExitCodeMapper.", null); } } } if (Logger.IsInfoEnabled) { Logger.Info("PowerShell execution exit status [{0}]", contribution.ExitStatus); } //=> output captured stream data to Log... LogStreams(); } catch (RuntimeException ex) { Logger.Error(ex.Message); throw; } } // end PowerShell Scope //=> close Runspace... runSpace.Close(); //=> we are done... return RepeatStatus.Finished; } // end of Runspace Scope }// end of TransactionScope }
public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { _logger.Info("KO transition was used"); throw new Exception("Job failed: Wrong transition used"); }
/// <summary> /// @see ITasklet#Execute() /// </summary> /// <param name="contribution"></param> /// <param name="chunkContext"></param> /// <returns></returns> public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { switch (Mode) { case FileUtilsMode.Copy: Copy(); break; case FileUtilsMode.Delete: foreach (IResource target in Targets) { if (target.Exists()) { Delete(target); } else { Error(target); } } break; case FileUtilsMode.Merge: Merge(true); break; case FileUtilsMode.MergeCopy: Merge(false); break; case FileUtilsMode.Reset: Reset(); break; default: throw new InvalidOperationException("This mode is not supported :[" + Mode + "]"); } return RepeatStatus.Finished; }
/// <summary> /// Generates the report /// @see ITasklet#Execute /// </summary> /// <param name="contribution"></param> /// <param name="chunkContext"></param> /// <returns></returns> public RepeatStatus Execute(StepContribution contribution, ChunkContext chunkContext) { LocalReport report = new LocalReport { ReportPath = ReportFile.GetFileInfo().FullName }; if (Parameters != null && Parameters.Any()) { if (Logger.IsTraceEnabled) { Logger.Trace("{0} parameter(s) were given for the report ", Parameters.Count); } report.SetParameters(Parameters.Select(p=>new ReportParameter(p.Key,p.Value))); } else { if (Logger.IsTraceEnabled) { Logger.Trace("No parameter was given for the report "); } } //DataSet DataSet ds = DbOperator.Select(Query,QueryParameterSource); //ReportDataSource ReportDataSource rds = new ReportDataSource { Name = DatasetName, Value = ds.Tables[0] }; report.DataSources.Add(rds); if (Logger.IsTraceEnabled) { Logger.Trace("Report init : DONE => Preparing to render"); } byte[] output = report.Render(ReportFormat); if (Logger.IsTraceEnabled) { Logger.Trace("Report init : rendering DONE => Preparing to serialize"); } //Create target directory if required OutFile.GetFileInfo().Directory.Create(); //dump to target file using (FileStream fs = new FileStream(OutFile.GetFileInfo().FullName, FileMode.Create)) { fs.Write(output,0,output.Length); } if (Logger.IsTraceEnabled) { Logger.Info("Report init : serialization DONE - end of ReportTasklet execute."); } return RepeatStatus.Finished; }