protected override void Execute(CodeActivityContext context)
{
SshClient sshClient = null;
if (SSHClient.Expression == null)
{
var sshClientArgument = context.DataContext.GetProperties()["SSHClient"];
sshClient = sshClientArgument.GetValue(context.DataContext) as SshClient;
if (sshClient == null)
{
throw (new ArgumentException("SSHClient was not provided and cannot be retrieved from the container."));
}
}
else
{
sshClient = SSHClient.Get(context);
}
var sshCommand = sshClient.CreateCommand(Command.Get(context));
sshCommand.CommandTimeout = Timeout.Get(context);
sshCommand.Execute();
ExitStatus.Set(context, sshCommand.ExitStatus);
Result.Set(context, sshCommand.Result);
Error.Set(context, sshCommand.Error);
}
/// <summary>
/// Calls the registered listeners in reverse order, respecting and
/// prioritizing those that hold an order metadata information.
/// </summary>
/// <param name="stepExecution"></param>
/// <returns></returns>
public ExitStatus AfterStep(StepExecution stepExecution)
{
if (Logger.IsTraceEnabled)
{
Logger.Trace("CompositeStepExecutionListener :: Entering AfterStep");
}
IEnumerator <IStepExecutionListener> enumerator = _list.Reverse();
while (enumerator.MoveNext())
{
if (Logger.IsTraceEnabled)
{
Logger.Trace("CompositeStepExecutionListener :: Before Executing AfterStep - stepExecution.ExitStatus ={0}", stepExecution.ExitStatus);
}
IStepExecutionListener listener = enumerator.Current;
ExitStatus close = listener.AfterStep(stepExecution);
stepExecution.ExitStatus = stepExecution.ExitStatus.And(close);
if (Logger.IsTraceEnabled)
{
Logger.Trace("CompositeStepExecutionListener :: After Executing AfterStep - stepExecution.ExitStatus ={0}", stepExecution.ExitStatus);
}
}
if (Logger.IsTraceEnabled)
{
Logger.Trace("CompositeStepExecutionListener :: Exiting AfterStep");
}
return(stepExecution.ExitStatus);
}
/// <summary>
/// Returns the status of all exits for a specified position
/// </summary>
/// <param name="worldTiles">Tiles already added to world</param>
/// <param name="position">Position</param>
private static Dictionary <TileExits, ExitStatus> GetadjacentExitStatus(Dictionary <Vector3D, TileInfo> worldTiles, Vector3D position)
{
Dictionary <TileExits, ExitStatus> exitStatusDict = new Dictionary <TileExits, ExitStatus>();
//Compute East adjacent Location
Vector3D positionEast = new Vector3D(position.X + 240, position.Y, position.Z);
ExitStatus exitStatusEast = GetExistStatus(worldTiles, positionEast, TileExits.West);
exitStatusDict.Add(TileExits.East, exitStatusEast);
Vector3D positionWest = new Vector3D(position.X - 240, position.Y, position.Z);
ExitStatus exitStatusWest = GetExistStatus(worldTiles, positionWest, TileExits.East);
exitStatusDict.Add(TileExits.West, exitStatusWest);
Vector3D positionNorth = new Vector3D(position.X, position.Y + 240, position.Z);
ExitStatus exitStatusNorth = GetExistStatus(worldTiles, positionNorth, TileExits.South);
exitStatusDict.Add(TileExits.North, exitStatusNorth);
Vector3D positionSouth = new Vector3D(position.X, position.Y - 240, position.Z);
ExitStatus exitStatusSouth = GetExistStatus(worldTiles, positionSouth, TileExits.North);
exitStatusDict.Add(TileExits.South, exitStatusSouth);
return(exitStatusDict);
}
public void OnGameConfirmExit(int score, ExitStatus status)
{
if (ConfirmGameExit != null)
{
ConfirmGameExit(score, status);
}
}
/// <summary>
/// Call to listeners that might add some post execution behaviour.
/// </summary>
/// <param name="execution"></param>
private void HandlePostExecution(JobExecution execution)
{
try
{
if (execution.Status.IsLessThanOrEqualTo(BatchStatus.Stopped) &&
!execution.StepExecutions.Any())
{
ExitStatus exitStatus = execution.ExitStatus;
ExitStatus newExitStatus =
ExitStatus.Noop.AddExitDescription("All steps already completed or no steps configured for this job.");
execution.ExitStatus = exitStatus.And(newExitStatus);
}
execution.EndTime = DateTime.Now;
try
{
_listener.AfterJob(execution);
}
catch (Exception e)
{
Logger.Error(e, "Exception encountered in afterStep callback");
}
JobRepository.Update(execution);
Logger.Debug("Current job execution: {0}", execution);
}
finally
{
JobSynchronizationManager.Release();
}
}
internal static ModuleRuntimeInfo <T> GetModuleRuntimeInfo(ModuleDetails moduleDetails)
{
ExitStatus exitStatus = moduleDetails.Status.ExitStatus;
if (exitStatus == null || !long.TryParse(exitStatus.StatusCode, out long exitCode))
{
exitCode = 0;
}
Option <DateTime> exitTime = exitStatus == null?Option.None <DateTime>() : Option.Some(exitStatus.ExitTime);
Option <DateTime> startTime = !moduleDetails.Status.StartTime.HasValue ? Option.None <DateTime>() : Option.Some(moduleDetails.Status.StartTime.Value);
if (!Enum.TryParse(moduleDetails.Status.RuntimeStatus.Status, true, out ModuleStatus status))
{
status = ModuleStatus.Unknown;
}
if (!(moduleDetails.Config.Settings is JObject jobject))
{
throw new InvalidOperationException($"Module config is of type {moduleDetails.Config.Settings.GetType()}. Expected type JObject");
}
var config = jobject.ToObject <T>();
var moduleRuntimeInfo = new ModuleRuntimeInfo <T>(moduleDetails.Name, moduleDetails.Type, status,
moduleDetails.Status.RuntimeStatus.Description, exitCode, startTime, exitTime, config);
return(moduleRuntimeInfo);
}
/// <summary>
/// @see AbstractPartitionHandler#DoHandle .
/// </summary>
/// <param name="masterStepExecution"></param>
/// <param name="partitionStepExecutions"></param>
/// <returns></returns>
protected override ICollection <StepExecution> DoHandle(StepExecution masterStepExecution, ICollection <StepExecution> partitionStepExecutions)
{
Assert.NotNull(Step, "A Step must be provided.");
HashSet <Task <StepExecution> > tasks = new HashSet <Task <StepExecution> >();
HashSet <StepExecution> result = new HashSet <StepExecution>();
foreach (StepExecution stepExecution in partitionStepExecutions)
{
Task <StepExecution> task = CreateTask(Step, stepExecution);
try
{
_taskExecutor.Execute(task);
tasks.Add(task);
}
catch (TaskRejectedException)
{
// couldn't execute one of the tasks
ExitStatus exitStatus = ExitStatus.Failed.AddExitDescription("TaskExecutor rejected the task for this step.");
// Set the status in case the caller is tracking it through the
// JobExecution.
stepExecution.BatchStatus = BatchStatus.Failed;
stepExecution.ExitStatus = exitStatus;
result.Add(stepExecution);
}
}
foreach (Task <StepExecution> task in tasks)
{
// Accessing Result is blocking (waits for asynchronous execution to complete)
result.Add(task.Result);
}
return(result);
}
public void ReplaceExitCodeTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
status = status.ReplaceExitCode("myReplacedExitCode");
Assert.AreEqual("myReplacedExitCode", status.ExitCode);
}
/// <summary>
/// Template method for step execution logic - calls abstract methods for resource initialization (
/// Open), execution Logic (DoExecute) and resource closing (Close).
/// </summary>
/// <param name="stepExecution"></param>
/// <exception cref="JobInterruptedException"> </exception>
/// <exception cref="UnexpectedJobExecutionException"> </exception>
public void Execute(StepExecution stepExecution)
{
Logger.Debug("Executing: id={0}", stepExecution.Id);
stepExecution.StartTime = DateTime.Now;
stepExecution.BatchStatus = BatchStatus.Started;
stepExecution.DelayConfig = DelayConfig;
JobRepository.Update(stepExecution);
// Start with a default value that will be trumped by anything
ExitStatus exitStatus = ExitStatus.Executing;
DoExecutionRegistration(stepExecution);
try
{
exitStatus = HandleExecution(stepExecution);
}
catch (Exception e)
{
exitStatus = HandleExecutionException(stepExecution, e, exitStatus);
}
finally
{
exitStatus = HandleListener(stepExecution, exitStatus);
exitStatus = HandleUpdateExecutionContext(stepExecution, exitStatus);
HandleUpdateStepExecution(stepExecution, exitStatus);
HandleCloseAndRelease(stepExecution);
stepExecution.ExecutionContext.Put("batch.executed", true);
if (Logger.IsDebugEnabled)
{
Logger.Debug("Step execution complete:{0}", stepExecution.GetSummary());
}
}
}
/// <summary>
/// Logic launched after the step. Will launch the postprocessor.
/// @see IStepExecutionListener#AfterStep
/// </summary>
/// <param name="stepExecution"></param>
/// <returns></returns>
public virtual ExitStatus AfterStep(StepExecution stepExecution)
{
ExitStatus returnStatus = stepExecution.ExitStatus;
if (!"FAILED".Equals(returnStatus.ExitCode))
{
MethodInfo post = this.GetType().GetMethod("Postprocess", BindingFlags.Instance | BindingFlags.NonPublic);
if (post.DeclaringType != typeof(AbstractExecutionListener))
{
using (var scope = TransactionScopeManager.CreateScope())
{
try
{
returnStatus = Postprocess();
}
catch (Exception e)
{
// Need to catch exception to log and set status to FAILED, while
// Spring batch would only log and keep the status COMPLETED
Logger.Error(e, "Exception during postprocessor");
stepExecution.UpgradeStatus(BatchStatus.Failed);
throw;
}
scope.Complete();
}
}
}
return(returnStatus);
}
public void GameProcess()
{
while (_gameStatus != GameStatus.GameEnd && _hero.IsAlive)
{
if (_gameStatus == GameStatus.Paused)
{
if (_control.OnGetAction() == GameControl.ResumeGame)
{
ResumeGame();
}
}
if (PlayerCanMove && _gameStatus != GameStatus.Paused)
{
PlayerMove();
}
}
if (_gameStatus == GameStatus.Stopped)
{
ExitStatus status = ExitStatus.DefaultStatus;
if (_hero.Life > 0 && _boss.Life > 0)
{
status = ExitStatus.StopGame;
}
if (_hero.Life == 0 && _boss.Life > 0)
{
status = ExitStatus.LoseGame;
}
if (_hero.Life > 0 && _boss.Life == 0)
{
status = ExitStatus.WinGame;
}
Exit(status);
}
}
public void IsRunningTest()
{
ExitStatus running = ExitStatus.Executing;
ExitStatus completed = ExitStatus.Completed;
Assert.IsTrue(running.IsRunning());
Assert.IsFalse(completed.IsRunning());
}
public void IsNonDefaultExitStatusTest()
{
ExitStatus stopped = ExitStatus.Stopped;
Assert.IsTrue(ExitStatus.IsNonDefaultExitStatus(stopped));
ExitStatus custom = new ExitStatus("myExitCode");
Assert.IsFalse(ExitStatus.IsNonDefaultExitStatus(custom));
}
public void AddExitDescriptionTest()
{
ExitStatus stopped = ExitStatus.Stopped;
stopped = stopped.AddExitDescription("STOPPED BECAUSE ABNORMALLY ENDED");
Assert.AreEqual("; STOPPED BECAUSE ABNORMALLY ENDED", stopped.ExitDescription);
stopped = stopped.AddExitDescription(".NO MORE INFO");
Assert.AreEqual("; STOPPED BECAUSE ABNORMALLY ENDED; .NO MORE INFO", stopped.ExitDescription);
}
public static void SaveProfileProgress(EFT.Profile profileData, ExitStatus exitStatus, string session, bool isPlayerScav)
{
var request = new SaveProfileRequest {
exit = exitStatus.ToString().ToLower(), profile = profileData, isPlayerScav = isPlayerScav
};
var requestData = request.ToJson();
new HttpUtils.Create(session).Post("/OfflineRaidSave", requestData, true);
}
private void OpenButton()
{
if (materialPresetTreeView.SelectedNode != null && ((string)materialPresetTreeView.SelectedNode.Tag).EndsWith(".nmt"))
{
path = ((string)materialPresetTreeView.SelectedNode.Tag);
exitStatus = ExitStatus.Opened;
Close();
}
}
/// <summary>
/// Closes the exit and sets the connection to the other exit.
/// </summary>
/// <param name="connectedTo">The exit to be set as a connection.</param>
/// <param name="connStatus">Why the exit is being closed.</param>
public void CloseExit(RoomConnector connectedTo, ExitStatus connStatus = ExitStatus.Connected)
{
isOpen = false;
connStat = connStatus;
if (connectedTo != null)
{
this.connectedTo = connectedTo;
}
}
internal static int Exit(ExitStatus status)
{
if (status == ExitStatus.RuntimeError || status == ExitStatus.ArgumentError)
{
log.Info("Unable to continue. Now exiting OpenTAP CLI.");
}
log.Flush();
return((int)status);
}
public static void SaveProfileProgress(string backendUrl, string session, ExitStatus exitStatus, Profile profileData, bool isPlayerScav)
{
SaveProfileRequest request = new SaveProfileRequest
{
exit = exitStatus.ToString().ToLower(),
profile = profileData,
isPlayerScav = isPlayerScav
};
new Request(session, backendUrl).PutJson("/raid/profile/save", request.ToJson());
}
public async Task <IActionResult> Create([Bind("Id,StatusName")] ExitStatus exitStatus)
{
if (ModelState.IsValid)
{
_context.Add(exitStatus);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(exitStatus));
}
public void CompareToTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status2 = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status3 = new ExitStatus("myExitCode1", "myExitDescription");
ExitStatus status4 = new ExitStatus("myExitCode1", "myExitDescription1");
Assert.AreEqual(0,status.CompareTo(status2));
Assert.AreNotEqual(0,status.CompareTo(status3));
Assert.AreNotEqual(0,status.CompareTo(status4));
Assert.AreEqual(0,status3.CompareTo(status4));
}
public void EqualsTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status2 = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status3 = new ExitStatus("myExitCode1", "myExitDescription");
ExitStatus status4 = new ExitStatus("myExitCode1", "myExitDescription1");
Assert.IsTrue(status.Equals(status2));
Assert.IsFalse(status.Equals(status3));
Assert.IsFalse(status.Equals(status4));
Assert.IsFalse(status3.Equals(status4));
}
public void AndTest()
{
ExitStatus running = ExitStatus.Executing;
ExitStatus runnningAndNull = running.And(null);
Assert.AreEqual(running, runnningAndNull);
ExitStatus completed = ExitStatus.Completed;
running = running.And(completed);
Assert.AreEqual(completed, running);
}
public void EqualsTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status2 = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status3 = new ExitStatus("myExitCode1", "myExitDescription");
ExitStatus status4 = new ExitStatus("myExitCode1", "myExitDescription1");
Assert.IsTrue(status.Equals(status2));
Assert.IsFalse(status.Equals(status3));
Assert.IsFalse(status.Equals(status4));
Assert.IsFalse(status3.Equals(status4));
}
public void CompareToTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status2 = new ExitStatus("myExitCode", "myExitDescription");
ExitStatus status3 = new ExitStatus("myExitCode1", "myExitDescription");
ExitStatus status4 = new ExitStatus("myExitCode1", "myExitDescription1");
Assert.AreEqual(0, status.CompareTo(status2));
Assert.AreNotEqual(0, status.CompareTo(status3));
Assert.AreNotEqual(0, status.CompareTo(status4));
Assert.AreEqual(0, status3.CompareTo(status4));
}
public static void SaveProfileProgress(string backendUrl, string session, ExitStatus exitStatus, Profile profileData, PlayerHealth currentHealth, bool isPlayerScav)
{
SaveProfileRequest request = new SaveProfileRequest
{
exit = exitStatus.ToString().ToLower(),
profile = profileData,
health = currentHealth,
isPlayerScav = isPlayerScav
};
// ToJson() uses an internal converter which prevents loops and do other internal things
new Request(session, backendUrl).PutJson("/raid/profile/save", request.ToJson());
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
internal static int Run(IDictionary <URI, IList <Path> > namenodes, Configuration conf
)
{
long sleeptime = conf.GetLong(DFSConfigKeys.DfsHeartbeatIntervalKey, DFSConfigKeys
.DfsHeartbeatIntervalDefault) * 2000 + conf.GetLong(DFSConfigKeys.DfsNamenodeReplicationIntervalKey
, DFSConfigKeys.DfsNamenodeReplicationIntervalDefault) * 1000;
AtomicInteger retryCount = new AtomicInteger(0);
Log.Info("namenodes = " + namenodes);
IList <NameNodeConnector> connectors = Sharpen.Collections.EmptyList();
try
{
connectors = NameNodeConnector.NewNameNodeConnectors(namenodes, typeof(Org.Apache.Hadoop.Hdfs.Server.Mover.Mover
).Name, MoverIdPath, conf, NameNodeConnector.DefaultMaxIdleIterations);
while (connectors.Count > 0)
{
Sharpen.Collections.Shuffle(connectors);
IEnumerator <NameNodeConnector> iter = connectors.GetEnumerator();
while (iter.HasNext())
{
NameNodeConnector nnc = iter.Next();
Org.Apache.Hadoop.Hdfs.Server.Mover.Mover m = new Org.Apache.Hadoop.Hdfs.Server.Mover.Mover
(nnc, conf, retryCount);
ExitStatus r = m.Run();
if (r == ExitStatus.Success)
{
IOUtils.Cleanup(Log, nnc);
iter.Remove();
}
else
{
if (r != ExitStatus.InProgress)
{
// must be an error statue, return
return(r.GetExitCode());
}
}
}
Sharpen.Thread.Sleep(sleeptime);
}
return(ExitStatus.Success.GetExitCode());
}
finally
{
foreach (NameNodeConnector nnc in connectors)
{
IOUtils.Cleanup(Log, nnc);
}
}
}
private void _read()
{
_user = System.Text.Encoding.GetEncoding("ascii").GetString(m_io.ReadBytes(256));
_inittabId = System.Text.Encoding.GetEncoding("ascii").GetString(m_io.ReadBytes(14));
_device = System.Text.Encoding.GetEncoding("ascii").GetString(m_io.ReadBytes(64));
_pid = m_io.ReadU8be();
_type = ((AixUtmp.EntryType)m_io.ReadS2be());
_timestamp = m_io.ReadS8be();
_exitStatus = new ExitStatus(m_io, this, m_root);
_hostname = System.Text.Encoding.GetEncoding("ascii").GetString(m_io.ReadBytes(256));
_dblWordPad = m_io.ReadS4be();
_reservedA = m_io.ReadBytes(8);
_reservedV = m_io.ReadBytes(24);
}
static void Main(string[] args)
{
Console.CancelKeyPress += (s, e) => {
e.Cancel = true;
cancellationTokenSource.Cancel();
};
Parameters parameters = Parameters.Setup(args);
if (parameters != null)
{
ExitStatus exitStatus = Packer.Run(parameters, cancellationTokenSource, new GZipPacker(), new ConsoleLogger());
Environment.Exit(exitStatus.ToInteger());
}
Environment.Exit(ExitStatus.ERROR.ToInteger());
}
/// <summary>
///
/// </summary>
/// <param name="stepExecution"></param>
/// <param name="exitStatus"></param>
private void HandleUpdateStepExecution(StepExecution stepExecution, ExitStatus exitStatus)
{
try
{
JobRepository.Update(stepExecution);
}
catch (Exception e)
{
stepExecution.BatchStatus = BatchStatus.Unknown;
stepExecution.ExitStatus = exitStatus.And(ExitStatus.Unknown);
stepExecution.AddFailureException(e);
Logger.Error(e,
"Encountered an error saving batch meta data for step {0} in job {1}. This job is now in an unknown state and should not be restarted.",
Name, stepExecution.JobExecution.JobInstance.JobName);
}
}
private void importButton_Click(object sender, EventArgs e)
{
if (vbnFileLabel.Text.Equals(""))
{
DialogResult dialogResult = MessageBox.Show("You are not using a VBN to import.\nDo you want to generate one?", "Warning", MessageBoxButtons.OKCancel);
if (dialogResult == DialogResult.OK)
{
exitStatus = ExitStatus.Opened;
Close();
}
}
else
{
exitStatus = ExitStatus.Opened;
Close();
}
}
/// <summary>
/// Window Button Click Method
/// Handles Button Presses
/// </summary>
/// <param name="sender">Object Which Called This Function</param>
/// <param name="e">The Arguments</param>
protected override void Element_Click(object sender, RoutedEventArgs e)
{
if (e.Source == BaseListWindow.buttonAdd)
{
Add();
}
else if (e.Source == BaseListWindow.buttonDelete)
{
Delete();
}
else if (e.Source == BaseListWindow.buttonEdit)
{
Edit();
}
e.Handled = true;
Exit = ExitStatus.Ok;
}
public ExitException(string message)
: base(message)
{
ExitStatus = ExitStatus.Unknown;
}
/// <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
}
/// <summary>
///
/// </summary>
/// <param name="stepExecution"></param>
/// <param name="e"></param>
/// <param name="exitStatus"></param>
/// <returns></returns>
private ExitStatus HandleExecutionException(StepExecution stepExecution, Exception e, ExitStatus exitStatus)
{
stepExecution.UpgradeStatus(DetermineBatchStatus(e));
ExitStatus returnedExitStatus = exitStatus.And(GetDefaultExitStatusForFailure(e));
stepExecution.AddFailureException(e);
if (stepExecution.BatchStatus == BatchStatus.Stopped)
{
Logger.Info("Encountered interruption executing step {0} in job {1} : {2}",
Name, stepExecution.JobExecution.JobInstance.JobName, e.Message);
if (Logger.IsDebugEnabled)
{
Logger.Debug(e, "Full exception");
}
}
else
{
Logger.Error(e, "Encountered an error executing step {0} in job {1} :", Name,
stepExecution.JobExecution.JobInstance.JobName);
}
return returnedExitStatus;
}
/// <summary>
///
/// </summary>
/// <param name="stepExecution"></param>
/// <param name="exitStatus"></param>
/// <returns></returns>
private ExitStatus HandleUpdateExecutionContext(StepExecution stepExecution, ExitStatus exitStatus)
{
ExitStatus returnedExitStatus = exitStatus;
try
{
JobRepository.UpdateExecutionContext(stepExecution);
}
catch (Exception e)
{
stepExecution.BatchStatus = BatchStatus.Unknown;
returnedExitStatus = exitStatus.And(ExitStatus.Unknown);
stepExecution.AddFailureException(e);
Logger.Error(e,
"Encountered an error saving batch meta data for step {0} in job {1}. This job is now in an unknown state and should not be restarted.",
Name, stepExecution.JobExecution.JobInstance.JobName);
}
stepExecution.EndTime = DateTime.Now;
stepExecution.ExitStatus = returnedExitStatus;
return returnedExitStatus;
}
/// <summary>
/// Default mapping from Exception to ExitStatus. Clients can modify the exit code using a
/// StepExecutionListener.
/// </summary>
/// <param name="ex"></param>
/// <returns></returns>
private ExitStatus GetDefaultExitStatusForFailure(Exception ex)
{
ExitStatus exitStatus;
if (ex is JobInterruptedException || ex.InnerException is JobInterruptedException)
{
exitStatus = ExitStatus.Stopped.AddExitDescription("JobInterruptedException");
}
else if (ex is NoSuchJobException || ex.InnerException is NoSuchJobException)
{
exitStatus = new ExitStatus(ExitCodeMapperConstants.NoSuchJob, ex.GetType().Name);
}
else
{
exitStatus = ExitStatus.Failed.AddExitDescription(ex);
}
return exitStatus;
}
public void GetExitCodeTest()
{
ExitStatus status = new ExitStatus("myExitCode");
Assert.AreEqual("myExitCode", status.ExitCode);
}
public void GetExitDescriptionTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
Assert.AreEqual("myExitDescription", status.ExitDescription);
}
public void ToStringTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
Assert.AreEqual("(exitCode=myExitCode;exitDescription=myExitDescription)", status.ToString());
}
public void GetHashCodeTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
Assert.AreEqual("(exitCode=myExitCode;exitDescription=myExitDescription)".GetHashCode(), status.GetHashCode());
}
public void ReplaceExitCodeTest()
{
ExitStatus status = new ExitStatus("myExitCode", "myExitDescription");
status = status.ReplaceExitCode("myReplacedExitCode");
Assert.AreEqual("myReplacedExitCode", status.ExitCode);
}
public void Apply(StepContribution contribution)
{
_readSkipCount += contribution.ReadSkipCount;
_writeSkipCount += contribution.WriteSkipCount;
_processSkipCount += contribution.ProcessSkipCount;
FilterCount += contribution.FilterCount;
_readCount += contribution.ReadCount;
_writeCount += contribution.WriteCount;
_exitStatus = _exitStatus.And(contribution.ExitStatus);
}
public ExitException()
{
ExitStatus = ExitStatus.Unknown;
}
/// <summary>
/// @see IFlowExecutor#AddExitStatus .
/// </summary>
/// <param name="code"></param>
public void AddExitStatus(string code)
{
ExitStatus = ExitStatus.And(new ExitStatus(code));
}
/// <summary>
/// Custom constructor using JobExecution.
/// </summary>
/// <param name="original"></param>
public JobExecution(JobExecution original)
{
JobParameters = original.JobParameters;
JobInstance = original.JobInstance;
_stepExecutions = original._stepExecutions;
_status = original.Status;
StartTime = original.StartTime;
CreateTime = original.CreateTime;
EndTime = original.EndTime;
LastUpdated = original.LastUpdated;
_exitStatus = original.ExitStatus;
_executionContext = original.ExecutionContext;
_failureExceptions = original.FailureExceptions;
_jobConfigurationName = original.JobConfigurationName;
Id = original.Id;
Version = original.Version;
}
/// <summary>
///
/// </summary>
/// <param name="stepExecution"></param>
/// <param name="exitStatus"></param>
private void HandleUpdateStepExecution(StepExecution stepExecution, ExitStatus exitStatus)
{
try
{
JobRepository.Update(stepExecution);
}
catch (Exception e)
{
stepExecution.BatchStatus = BatchStatus.Unknown;
stepExecution.ExitStatus = exitStatus.And(ExitStatus.Unknown);
stepExecution.AddFailureException(e);
Logger.Error(e,
"Encountered an error saving batch meta data for step {0} in job {1}. This job is now in an unknown state and should not be restarted.",
Name, stepExecution.JobExecution.JobInstance.JobName);
}
}
public void IsNonDefaultExitStatusTest()
{
ExitStatus stopped = ExitStatus.Stopped;
Assert.IsTrue(ExitStatus.IsNonDefaultExitStatus(stopped));
ExitStatus custom = new ExitStatus("myExitCode");
Assert.IsFalse(ExitStatus.IsNonDefaultExitStatus(custom));
}
/// <summary>
///
/// </summary>
/// <param name="stepExecution"></param>
/// <param name="exitStatus"></param>
/// <returns></returns>
private ExitStatus HandleListener(StepExecution stepExecution, ExitStatus exitStatus)
{
ExitStatus returnedExitStatus = exitStatus;
try
{
// Update the step execution to the latest known value so the
// listeners can act on it
returnedExitStatus = returnedExitStatus.And(stepExecution.ExitStatus);
stepExecution.ExitStatus = returnedExitStatus;
Logger.Trace("_stepExecutionListener.AfterStep CALL");
returnedExitStatus = returnedExitStatus.And(_stepExecutionListener.AfterStep(stepExecution));
}
catch (Exception e)
{
Logger.Error(e, "Exception in afterStep callback in step {0} in job {1}", Name,
stepExecution.JobExecution.JobInstance.JobName);
}
return returnedExitStatus;
}
public ExitException(string message, ExitStatus status, Exception inner)
: base(message, inner)
{
ExitStatus = status;
}
/// <summary>
/// @see IFlowExecutor#UpdateJobExecutionStatus .
/// </summary>
/// <param name="status"></param>
public void UpdateJobExecutionStatus(FlowExecutionStatus status)
{
_execution.Status = FindBatchStatus(status);
ExitStatus = ExitStatus.And(new ExitStatus(status.Name));
_execution.ExitStatus = ExitStatus;
}
public ExitException(string message, ExitStatus status)
: base(message)
{
ExitStatus = status;
}
static void Exit(ExitStatus status)
{
Environment.Exit((int)status);
}
/// <summary>
/// @see IStepExecutionListener#BeforeStep.
/// </summary>
/// <param name="stepExecution"></param>
public override void BeforeStep(StepExecution stepExecution)
{
_execution = stepExecution;
_scriptExitStatus = _execution.ExitStatus;
}
