public bool RunCommand(XTMFCommand command, ref string error)
{
lock (_SessionLock)
{
if (command.Do(ref error))
{
HasChanged = true;
if (_InCombinedContext)
{
var list = _CombinedCommands;
list.Add(command);
}
else
{
if (command.CanUndo())
{
_UndoStack.Add(command);
}
CommandExecuted?.Invoke(this, new EventArgs());
}
// if we do something new, redo no long is available
_RedoStack.Clear();
return(true);
}
return(false);
}
}
public CommandResult Execute(string fileName, string args)
{
lock (_executingLock)
{
if (isDisposed)
{
throw new ObjectDisposedException(nameof(HestExecutor));
}
//记录开始时间
DateTime start = DateTime.Now;
//开始进程
commandProcedure = BasicBooter.CommandProcedureManager.OpenCommand(fileName, args);
commandProcedure.OutputReceived += OnOutputReceived;
//触发事件
CommandExecuting?.Invoke(this, new CommandExecutingEventArgs(fileName, args));
var cmdResult = commandProcedure.Execute();
commandProcedure.Dispose();
//记录结束时间
DateTime end = DateTime.Now;
//构造结果对象
var result = new CommandResult(cmdResult.ExitCode, cmdResult.Output);
//触发结束事件
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(fileName, args, result, end - start));
//返回结果
return(result);
};
}
/// <summary>
/// 无锁的执行..不建议覆写
/// </summary>
/// <param name="fileName"></param>
/// <param name="args"></param>
/// <returns></returns>
protected virtual Result ExecuteWithoutLock(string fileName, string args)
{
if (disposedValue)
{
throw new ObjectDisposedException(nameof(CommandExecutor));
}
int exitCode;
ProcessStartInfo pStartInfo;
outputBuilder.Clear();
pStartInfo = GetStartInfo(fileName, args);
DateTime start = DateTime.Now;
currentProcess = Process.Start(pStartInfo);
OnProcessStarted(currentProcess);
try
{
CommandExecuting?.Invoke(this, new CommandExecutingEventArgs(fileName, args));
ExecutingSource?.Invoke(this, new CommandExecutingEventArgs(fileName, args));
}
catch { }
currentProcess.WaitForExit();
DateTime end = DateTime.Now;
exitCode = currentProcess.ExitCode;
OnProcessExited(currentProcess);
currentProcess = null;
var result = new Result(outputBuilder.Result, exitCode);
try
{
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(fileName, args, result, end - start));
ExecutedSource?.Invoke(this, new CommandExecutedEventArgs(fileName, args, result, end - start));
}
catch { }
return result;
}
private void ExecuteCommand(IInfiniteCanvasCommand command)
{
_undoCommands.Push(command);
_redoCommands.Clear();
command.Execute();
CommandExecuted?.Invoke(this, EventArgs.Empty);
}
public override void Execute(object parameter)
{
base.Execute(parameter);
CommandExecuted?.Invoke(new MediaCommandExecutedEventArgs()
{
Parameter = parameter
});
}
private async Task ExecuteAndDispatchNext(CommandBase command)
{
await command.ExecuteAsync().ConfigureAwait(false);
CommandExecuted?.Invoke(this, new CommandRunnerEvent(command));
DispatchNext();
}
public void InvokeCommand(CmdlineCommand command, string args)
{
// We don't want to block this call because it causes issues if some sync operation that shuts down server is also called.
// For example, mode switch or instance shutdown calls are stopping server,
// which results in serviceHost.Close() timeout, since server would be still waiting for InvokeCommand to finish.
Task.Run(async() =>
{
await Task.Delay(100);
syncContext.Post(_ => CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(command, args)), null);
});
}
/// <summary>
///
/// </summary>
/// <param name="journalRecord"></param>
/// <param name="isLocal"></param>
/// <param name="events"></param>
private void NotifyCommandExecuted(JournalRecord journalRecord, bool isLocal, IEnumerable <Event> events)
{
try
{
CommandExecuted.Invoke(journalRecord, isLocal, events);
}
catch
{
// Don't let external code crash the engine
}
}
private void NotifyCommandExecuted(JournalRecord journalRecord, bool isLocal, IEnumerable <Event> events)
{
try
{
CommandExecuted.Invoke(journalRecord, isLocal, events);
}
catch (Exception exception)
{
_logger.LogError(exception, "Exception thrown in CommandExecuted handler.");
}
}
public void OnCommandExecuted(ICommandContext context, Task <IResult> task)
{
IResult result = task.Result;
if (result is null)
{
return;
}
CommandExecuted?.Invoke(new Optional <CommandInfo>(), context, result);
}
private void CommandExecutionLoop()
{
int commandNumber = 0;
foreach (ICommand command in commands)
{
ExecuteCommand(command);
commandNumber++;
CommandExecuted?.Invoke(commandNumber);
}
}
/// <summary>
/// 执行命令
/// </summary>
/// <param name="fileName"></param>
/// <param name="args"></param>
/// <returns></returns>
public ICommandResult Execute(string fileName, string args)
{
lock (_executingLock)
{
if (isDisposed)
{
throw new ObjectDisposedException(nameof(HestExecutor));
}
//输出构造器
outputBuilder.Clear();
//记录开始时间
DateTime start = DateTime.Now;
//开始进程
currentProcess = Process.Start(GetStartInfo(fileName, args));
//监听
currentProcess.OutputDataReceived += (s, e) =>
{
outputBuilder.AppendOut(e.Data);
OutputReceived?.Invoke(this, new OutputReceivedEventArgs(e, false));
};
currentProcess.ErrorDataReceived += (s, e) =>
{
outputBuilder.AppendError(e.Data);
OutputReceived?.Invoke(this, new OutputReceivedEventArgs(e, true));
};
currentProcess.BeginOutputReadLine();
currentProcess.BeginErrorReadLine();
//触发事件
CommandExecuting?.Invoke(this, new CommandExecutingEventArgs(fileName, args));
//等待进程结束
currentProcess.WaitForExit();
currentProcess.CancelErrorRead();
currentProcess.CancelOutputRead();
//记录结束时间
DateTime end = DateTime.Now;
//构造结果对象
var result = new HestExecutorResult()
{
ExitCode = currentProcess.ExitCode, Output = outputBuilder.Result
};
//触发结束事件
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(fileName, args, result, end - start));
//返回结果
return(result);
};
}
public void ExecuteCombinedCommands(string name, Action combinedCommandContext)
{
lock (_SessionLock)
{
_InCombinedContext = true;
var list = _CombinedCommands = new List <XTMFCommand>();
combinedCommandContext();
// only add to the undo list if a command was added successfully
if (list.Count > 0)
{
// create a command to undo everything in a single shot [do is empty]
_UndoStack.Add(XTMFCommand.CreateCommand(name, (ref string error) => { return(true); },
(ref string error) =>
{
foreach (var command in ((IEnumerable <XTMFCommand>)list).Reverse())
{
if (command.CanUndo())
{
if (!command.Undo(ref error))
{
return(false);
}
}
}
return(true);
},
(ref string error) =>
{
foreach (var command in list)
{
if (command.CanUndo())
{
if (!command.Redo(ref error))
{
return(false);
}
}
}
return(true);
}));
CommandExecuted?.Invoke(this, new EventArgs());
}
_InCombinedContext = false;
_CombinedCommands = null;
}
}
/// <summary>
/// Actual command execution
/// </summary>
public object Execute(Command command)
{
EnsureNotDisposed();
EnsureAuthorized(command);
FireExecutingEvent(command);
lock (_commandSequenceLock)
{
var ctx = ExecutionContext.Begin();
bool exceptionThrown = false;
_executionTimer.Restart();
_config.Isolation.Commands.Apply(ref command);
ulong lastEntryId = (_config.PersistenceMode == PersistenceMode.Journaling)
? _journalAppender.Append(command)
: 0;
try
{
return(_kernel.ExecuteCommand(command));
}
catch (Exception ex)
{
exceptionThrown = true;
if (_config.PersistenceMode == PersistenceMode.Journaling)
{
_journalAppender.AppendRollbackMarker();
}
if (!(ex is CommandAbortedException))
{
Rollback();
ex = new CommandFailedException("Command failed with rollback, see inner exception for details", ex);
}
throw ex;
}
finally
{
_synchronizer.Exit();
if (!exceptionThrown)
{
var args = new CommandExecutedEventArgs(lastEntryId, command, ctx.Timestamp, _executionTimer.Elapsed, ctx.Events);
CommandExecuted.Invoke(this, args);
}
ExecutionContext.Current = null;
}
}
}
public void Execute(Command cmd)
{
if (cmd is null)
{
throw new ArgumentNullException(nameof(cmd));
}
if (BeginExecute(cmd) == false)
{
return;
}
CommandExecutedEventArg cmmdExecutedEventArg =
new CommandExecutedEventArg(cmd.UpdateEntity.Entity);
try
{
var history = _historyRepositoryFactory.GetRepository(cmd);
IEntityRepository entityRepository = _entityRepositoryFactory.GetRepository(cmd);
var lastUpdatedEntity = entityRepository.LastUpdated;
if (lastUpdatedEntity != null)
{
CheckData(cmd, entityRepository, lastUpdatedEntity);
}
if (history != null)
{
history.Record(lastUpdatedEntity, cmd.UpdateEntity.Entity);
}
entityRepository.Save();
cmd.UpdateEntity.Entity.LastUpdateDateTime = cmd.CurrentUpdateDateTime;
cmd.UpdateEntity.Entity.LastUpdatedUser = cmd.CurrentUpdateUser;
}
catch (Exception exp)
when(exp is DataUpdateConflictException || exp is ReferenceObsoleteException)
{
cmmdExecutedEventArg.IsSuccess = false;
cmmdExecutedEventArg.ErrorMessage = exp.Message;
}
CommandExecuted?.Invoke(this, cmmdExecutedEventArg);
}
/// <summary>Executes the supplied command</summary>
/// <param name="command">The command to execute.</param>
/// <param name="context">The context passed to the command</param>
public virtual void Execute(CommandBase <CommandContext> command, CommandContext context)
{
var args = new CommandProcessEventArgs {
Command = command, Context = context
};
if (CommandExecuting != null)
{
CommandExecuting.Invoke(this, args);
}
logger.Info(args.Command.Name + " processing " + args.Context);
using (var tx = persister.Repository.BeginTransaction())
{
try
{
args.Command.Process(args.Context);
Utility.FindEmpty(args.Context.Content);
tx.Commit();
if (CommandExecuted != null)
{
CommandExecuted.Invoke(this, args);
}
}
catch (StopExecutionException)
{
tx.Rollback();
}
catch (Exception ex)
{
tx.Rollback();
logger.Error(ex);
throw;
}
finally
{
logger.Info(" -> " + args.Context);
}
}
}
/// <summary>
/// Redo the last undone command
/// </summary>
/// <param name="error">The reason why it failed</param>
public bool Redo(ref string error)
{
lock (_SessionLock)
{
if (_RedoStack.TryPop(out var command))
{
if (command != null)
{
if (command.Redo(ref error))
{
HasChanged = true;
_UndoStack.Add(command);
CommandExecuted?.Invoke(this, new EventArgs());
return(true);
}
return(false);
}
}
error = "There was nothing to redo.";
return(false);
}
}
public void InvokeCommand(CmdlineCommand command, string args)
{
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(command, args));
}
/**********************************************************************/
#region Private Methods
private void CommandExecute(object parameter)
=> CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(parameter));
/// <summary>
/// The trigger function for <see cref="CommandExecuted"/> event.
/// </summary>
/// <param name="commandText">The <see cref="FbCommand.CommandText"/> of the executed SQL command.</param>
/// <param name="dataReader">The <see cref="FbDataReader"/> instance with the returned data. If the
/// command executed is not meant to return data (ex: UPDATE, INSERT...) this parameter must be
/// setled to <b>null</b>.</param>
/// <param name="rowsAffected">The rows that were affected by the executed SQL command. If the executed
/// command is not meant to return this kind of information (ex: SELECT) this parameter must
/// be setled to <b>-1</b>.</param>
private void OnCommandExecuted(FbDataReader dataReader, string commandText, SqlStatementType statementType, int rowsAffected)
{
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(dataReader, commandText, statementType, rowsAffected));
}
protected virtual void OnCommandExecuted()
{
CommandExecuted?.Invoke(this, EventArgs.Empty);
}
public void OnCommandExecuted()
{
CommandExecuted?.Invoke(this);
}
protected void RaiseCommandExecuted()
{
CommandExecuted?.Invoke(this, EventArgs.Empty);
}
private void OnCommandExecuted(DbCommand command)
{
CommandExecuted?.Invoke(this, command);
}
protected virtual void OnCommandExecuted(string msg)
{
CommandExecuted?.Invoke(this, new CommandEventArgs {
Message = msg
});
}
/// <summary>
/// Raise the command executed event.
/// </summary>
/// <param name="command">The command that was executed.</param>
internal void RaiseCommandExecuted(SmtpCommand command)
{
CommandExecuted?.Invoke(this, new SmtpCommandEventArgs(this, command));
}
private void FireOnCommandExecuted()
{
CommandExecuted?.Invoke(this, EventArgs.Empty);
}
protected void FireExecutedEvent(IDbCommand command, IDataConnection connection, IDbConnection conn)
{
CommandExecuted?.Invoke(this, new CommandExecutingEventArgs(command, connection, conn));
}
public void RaiseCommandExecuted(DbCommand command, int?rowsAffected)
{
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(command, rowsAffected));
}
/// <summary>
/// Raises a command executed event.
/// </summary>
/// <param name="eventArgs">Holds data generated during command execution</param>
protected void RaiseCommandExecutedEvent(CommandExecutedArgs eventArgs)
{
CommandExecuted?.Invoke(eventArgs);
}