/// <summary>Add the command async result for a command.
/// </summary>
/// <param name="commandId">The commandId.</param>
/// <param name="commandAsyncResult">The command async result.</param>
public void Add(Guid commandId, CommandAsyncResult commandAsyncResult)
{
if (!_commandAsyncResultDict.TryAdd(commandId, commandAsyncResult))
{
throw new Exception(string.Format("Command with id '{0}' is already exist.", commandId));
}
}
/// <summary>Add the command async result for a command.
/// </summary>
/// <param name="commandId">The commandId.</param>
/// <param name="commandAsyncResult">The command async result.</param>
public void Add(Guid commandId, CommandAsyncResult commandAsyncResult)
{
if (!_commandAsyncResultDict.TryAdd(commandId, commandAsyncResult))
{
throw new Exception(string.Format("Command with id '{0}' is already exist.", commandId));
}
}
public void BytesReceivedTest()
{
var target = new CommandAsyncResult();
var expected = new Random().Next();
target.BytesReceived = expected;
Assert.AreEqual(expected, target.BytesReceived);
}
public void BytesSentTest()
{
var target = new CommandAsyncResult();
int expected = new Random().Next();
target.BytesSent = expected;
Assert.AreEqual(expected, target.BytesSent);
}
public void BytesReceivedTest()
{
var target = new CommandAsyncResult();
var expected = new Random().Next();
target.BytesReceived = expected;
Assert.AreEqual(expected, target.BytesReceived);
}
public void BytesSentTest()
{
var target = new CommandAsyncResult();
int expected = new Random().Next();
target.BytesSent = expected;
Assert.AreEqual(expected, target.BytesSent);
}
private void SshCommandAsyncCallback(IAsyncResult r)
{
CommandAsyncResult car = r as CommandAsyncResult;
KeyValuePair <SshCommand, Stopwatch> cas = (KeyValuePair <SshCommand, Stopwatch>)car.AsyncState;
if (car.IsCompleted)
{
cas.Value.Stop();
Debug("Completed execution of {0} with {1} bytes received in {2} ms.", cas.Key.CommandText, car.BytesReceived, cas.Value.ElapsedMilliseconds);
}
}
public void BytesReceivedTest()
{
SshCommand command = null; // TODO: Initialize to an appropriate value
CommandAsyncResult target = new CommandAsyncResult(command); // TODO: Initialize to an appropriate value
int expected = 0; // TODO: Initialize to an appropriate value
int actual;
target.BytesReceived = expected;
actual = target.BytesReceived;
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
public List <Tuple <string, ProcessExecuteStatus, string, string> > ExecuteMany(List <Tuple <string, string> > commands)
{
CallerInformation caller = this.Here();
if (!this.IsConnected)
{
throw new InvalidOperationException("The SSH session is not connected.");
}
List <Tuple <string, ProcessExecuteStatus, string, string> > results = new List <Tuple <string, ProcessExecuteStatus, string, string> >(commands.Count);
object results_lock = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
Parallel.ForEach(commands, new ParallelOptions()
{
MaxDegreeOfParallelism = 20
}, (_c, state) =>
{
string process_output = string.Empty;
string process_error = string.Empty;
SshCommand cmd = this.SshClient.CreateCommand(_c.Item1 + " " + _c.Item2);
Stopwatch cs = new Stopwatch();
cs.Start();
CommandAsyncResult result = cmd.BeginExecute(new AsyncCallback(SshCommandAsyncCallback), new KeyValuePair <SshCommand, Stopwatch>(cmd, cs)) as CommandAsyncResult;
cmd.EndExecute(result);
KeyValuePair <SshCommand, Stopwatch> s = (KeyValuePair <SshCommand, Stopwatch>)result.AsyncState;
process_output = s.Key.Result.Trim();
process_error = s.Key.Error.Trim();
if (s.Value.IsRunning)
{
s.Value.Stop();
}
if (process_output != string.Empty)
{
lock (results_lock)
{
results.Add(new Tuple <string, ProcessExecuteStatus, string, string>(_c.Item1, ProcessExecuteStatus.Completed, process_output, process_error));
}
Debug(caller, "Execute {0} completed with {1} {2}.", s.Key.Result.Length, cmd.CommandText, process_output, process_error);
}
else
{
lock (results_lock)
{
results.Add(new Tuple <string, ProcessExecuteStatus, string, string>(_c.Item1, ProcessExecuteStatus.Error, process_output, process_error));
}
Debug(caller, "Execute {0} did not complete successfully: {1} {2}.", s.Key.Result.Length, cmd.CommandText, process_output, process_error);
}
});
return(results);
}
/// <summary>Send the given command to command queue, and block the current thread until the command was handled or timeout.
/// </summary>
/// <param name="command">The command to send.</param>
/// <returns>The command execution result.</returns>
/// <exception cref="ArgumentNullException">Throwed when the command is null.</exception>
/// <exception cref="CommandQueueNotFoundException">Throwed when the command queue cannot be routed.</exception>
/// <exception cref="CommandTimeoutException">Throwed when the command execution timeout.</exception>
/// <exception cref="CommandExecutionException">Throwed when the command execution has any error.</exception>
public CommandAsyncResult Execute(ICommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
var commandQueue = _commandQueueRouter.Route(command);
if (commandQueue == null)
{
throw new CommandQueueNotFoundException(command.GetType());
}
var waitHandle = new ManualResetEvent(false);
var commandAsyncResult = new CommandAsyncResult(waitHandle);
_commandAsyncResultManager.Add(command.Id, commandAsyncResult);
commandQueue.Enqueue(command);
waitHandle.WaitOne(command.MillisecondsTimeout);
_commandAsyncResultManager.Remove(command.Id);
if (!commandAsyncResult.IsCompleted)
{
throw new CommandTimeoutException(command.Id, command.GetType());
}
if (commandAsyncResult.ErrorInfo == null)
{
return(commandAsyncResult);
}
var errorInfo = commandAsyncResult.ErrorInfo;
if (errorInfo.ErrorMessage != null && errorInfo.Exception != null)
{
throw new CommandExecutionException(command.Id, command.GetType(), errorInfo.ErrorMessage, errorInfo.Exception);
}
if (errorInfo.ErrorMessage != null)
{
throw new CommandExecutionException(command.Id, command.GetType(), errorInfo.ErrorMessage);
}
if (errorInfo.Exception != null)
{
throw new CommandExecutionException(command.Id, command.GetType(), errorInfo.Exception);
}
return(commandAsyncResult);
}
/// <summary>Send the given command to command queue, and block the current thread until the command was handled or timeout.
/// </summary>
/// <param name="command">The command to send.</param>
/// <returns>The command execution result.</returns>
/// <exception cref="ArgumentNullException">Throwed when the command is null.</exception>
/// <exception cref="CommandQueueNotFoundException">Throwed when the command queue cannot be routed.</exception>
/// <exception cref="CommandTimeoutException">Throwed when the command execution timeout.</exception>
/// <exception cref="CommandExecutionException">Throwed when the command execution has any error.</exception>
public CommandAsyncResult Execute(ICommand command)
{
if (command == null)
{
throw new ArgumentNullException("command");
}
var commandQueue = _commandQueueRouter.Route(command);
if (commandQueue == null)
{
throw new CommandQueueNotFoundException(command.GetType());
}
var waitHandle = new ManualResetEvent(false);
var commandAsyncResult = new CommandAsyncResult(waitHandle);
_commandAsyncResultManager.Add(command.Id, commandAsyncResult);
commandQueue.Enqueue(command);
waitHandle.WaitOne(command.MillisecondsTimeout);
_commandAsyncResultManager.Remove(command.Id);
if (!commandAsyncResult.IsCompleted)
{
throw new CommandTimeoutException(command.Id, command.GetType());
}
if (commandAsyncResult.ErrorInfo == null)
{
return commandAsyncResult;
}
var errorInfo = commandAsyncResult.ErrorInfo;
if (errorInfo.ErrorMessage != null && errorInfo.Exception != null)
{
throw new CommandExecutionException(command.Id, command.GetType(), errorInfo.ErrorMessage, errorInfo.Exception);
}
if (errorInfo.ErrorMessage != null)
{
throw new CommandExecutionException(command.Id, command.GetType(), errorInfo.ErrorMessage);
}
if (errorInfo.Exception != null)
{
throw new CommandExecutionException(command.Id, command.GetType(), errorInfo.Exception);
}
return commandAsyncResult;
}
IAsyncResult BeginExecuteCommand(string command, bool consumeStream, AsyncCallback callback = null, object state = null)
{
var data = Encoding.UTF8.GetBytes(command);
if (data.Length > byte.MaxValue)
{
throw new ArgumentException("Command too long");
}
var buffer = new byte[data.Length + 1];
buffer[0] = (byte)data.Length;
Array.Copy(data, 0, buffer, 1, data.Length);
var ar = new CommandAsyncResult(this, callback, state)
{
Buffer = buffer,
ConsumeStream = consumeStream,
};
//try to re-use an existing stream
lock (lock_obj) {
if (reusableStream != null)
{
ar.Stream = reusableStream;
//if we're going to consume the stream, don't leave it around for others to re-use
if (consumeStream)
{
reusableStream = null;
}
}
}
if (ar.Stream != null)
{
ExecuteCommand_BeginWriteCommand(ar);
}
else
{
BeginConnectStream(ExecuteCommand_ConnectedCommandStream, ar).AsyncWaitHandle.WaitOne(3000);
}
return(ar);
}
public override Dictionary <AuditFileInfo, string> ReadFilesAsText(List <AuditFileInfo> files)
{
CallerInformation here = this.Here();
Dictionary <AuditFileInfo, string> results = new Dictionary <AuditFileInfo, string>(files.Count);
object results_lock = new object();
Stopwatch sw = new Stopwatch();
sw.Start();
Parallel.ForEach(files, new ParallelOptions()
{
MaxDegreeOfParallelism = 20
}, (_f, state) =>
{
SshCommand cmd = this.SshClient.CreateCommand("cat " + _f.FullName);
Stopwatch cs = new Stopwatch();
cs.Start();
CommandAsyncResult result = cmd.BeginExecute(new AsyncCallback(SshCommandAsyncCallback), new KeyValuePair <SshCommand, Stopwatch> (cmd, cs)) as CommandAsyncResult;
cmd.EndExecute(result);
KeyValuePair <SshCommand, Stopwatch> s = (KeyValuePair <SshCommand, Stopwatch>)result.AsyncState;
if (s.Key.Result != string.Empty)
{
lock (results_lock)
{
results.Add(_f, s.Key.Result);
}
if (s.Value.IsRunning)
{
s.Value.Stop();
}
Debug(here, "Read {0} chars from {1}.", s.Key.Result.Length, _f.FullName);
Progress("Read environment files", files.Count, 3, s.Value.Elapsed);
}
else
{
Error(here, "Could not read {0} as text. Command returned: {1}", _f.FullName, s.Key.Error);
}
s.Key.Dispose();
cs = null;
});
sw.Stop();
Success("Read text for {0} out of {1} files in {2} ms.", results.Count(r => r.Value.Length > 0), results.Count(), sw.ElapsedMilliseconds);
return(results);
}
void ExecuteCommand_BeginWriteCommand(CommandAsyncResult r)
{
r.Stream.BeginWrite(r.Buffer, 0, r.Buffer.Length, ExecuteCommand_WroteCommand, r);
}
