internal ShellStream(Session session, string terminalName, uint columns, uint rows, uint width, uint height, int maxLines, PrivateKeyAgent forwardedPrivateKeyAgent, params KeyValuePair<TerminalModes, uint>[] terminalModeValues) { this._encoding = new Renci.SshNet.Common.ASCIIEncoding(); this._session = session; this._incoming = new Queue<byte>(); this._outgoing = new Queue<byte>(); this._channel = this._session.CreateChannel<ChannelSession>(); this._channel.DataReceived += new EventHandler<ChannelDataEventArgs>(Channel_DataReceived); this._channel.Closed += new EventHandler<ChannelEventArgs>(Channel_Closed); this._session.Disconnected += new EventHandler<EventArgs>(Session_Disconnected); this._session.ErrorOccured += new EventHandler<ExceptionEventArgs>(Session_ErrorOccured); this.forwardedPrivateKeyAgent = forwardedPrivateKeyAgent; this._channel.Open(); if (this.forwardedPrivateKeyAgent != null) { if (this._channel.SendPrivateKeyAgentForwardingRequest()) { this._session.RegisterMessage("SSH_MSG_CHANNEL_OPEN"); this._session.ChannelOpenReceived += OnChannelOpen; } } this._channel.SendPseudoTerminalRequest(terminalName, columns, rows, width, height, terminalModeValues); this._channel.SendShellRequest(); }
private void Arrange() { var random = new Random(); _localChannelNumber = (uint)random.Next(0, int.MaxValue); _localWindowSize = (uint)random.Next(0, int.MaxValue); _localPacketSize = (uint)random.Next(0, int.MaxValue); _remoteChannelNumber = (uint)random.Next(0, int.MaxValue); _remoteWindowSize = (uint)random.Next(0, int.MaxValue); _remotePacketSize = (uint)random.Next(0, int.MaxValue); _channelClosedRegister = new List<ChannelEventArgs>(); _channelExceptionRegister = new List<ExceptionEventArgs>(); _initialSessionSemaphoreCount = random.Next(10, 20); _sessionSemaphore = new SemaphoreLight(_initialSessionSemaphoreCount); _sessionMock = new Mock<ISession>(MockBehavior.Strict); _connectionInfoMock = new Mock<IConnectionInfo>(MockBehavior.Strict); _sequence = new MockSequence(); _sessionMock.InSequence(_sequence).Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object); _connectionInfoMock.InSequence(_sequence).Setup(p => p.RetryAttempts).Returns(1); _sessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore); _sessionMock.InSequence(_sequence) .Setup( p => p.SendMessage( It.Is<ChannelOpenMessage>( m => m.LocalChannelNumber == _localChannelNumber && m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize && m.Info is SessionChannelOpenInfo))); _sessionMock.InSequence(_sequence) .Setup(p => p.WaitOnHandle(It.IsNotNull<WaitHandle>())) .Callback<WaitHandle>( w => { _sessionMock.Raise( s => s.ChannelOpenConfirmationReceived += null, new MessageEventArgs<ChannelOpenConfirmationMessage>( new ChannelOpenConfirmationMessage( _localChannelNumber, _remoteWindowSize, _remotePacketSize, _remoteChannelNumber))); w.WaitOne(); }); _sessionMock.Setup(p => p.IsConnected).Returns(false); _channel = new ChannelSession(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize); _channel.Closed += (sender, args) => _channelClosedRegister.Add(args); _channel.Exception += (sender, args) => _channelExceptionRegister.Add(args); _channel.Open(); _sessionMock.Raise( p => p.ChannelEofReceived += null, new MessageEventArgs<ChannelEofMessage>(new ChannelEofMessage(_localChannelNumber))); _sessionMock.Raise( p => p.ChannelCloseReceived += null, new MessageEventArgs<ChannelCloseMessage>(new ChannelCloseMessage(_localChannelNumber))); }
/// <summary> /// Connects subsystem on SSH channel. /// </summary> public void Connect() { this._channel = this._session.CreateClientChannel<ChannelSession>(); this._session.ErrorOccured += Session_ErrorOccured; this._session.Disconnected += Session_Disconnected; this._channel.DataReceived += Channel_DataReceived; this._channel.Closed += Channel_Closed; this._channel.Open(); this._channel.SendSubsystemRequest(_subsystemName); this.OnChannelOpen(); }
internal ShellStream(Session session, string terminalName, uint columns, uint rows, uint width, uint height, int maxLines, IDictionary<TerminalModes, uint> terminalModeValues) { this._encoding = session.ConnectionInfo.Encoding; this._session = session; this._incoming = new Queue<byte>(); this._outgoing = new Queue<byte>(); this._channel = this._session.CreateChannel<ChannelSession>(); this._channel.DataReceived += new EventHandler<ChannelDataEventArgs>(Channel_DataReceived); this._channel.Closed += new EventHandler<ChannelEventArgs>(Channel_Closed); this._session.Disconnected += new EventHandler<EventArgs>(Session_Disconnected); this._session.ErrorOccured += new EventHandler<ExceptionEventArgs>(Session_ErrorOccured); this._channel.Open(); this._channel.SendPseudoTerminalRequest(terminalName, columns, rows, width, height, terminalModeValues); this._channel.SendShellRequest(); }
private void Arrange() { var random = new Random(); _localChannelNumber = (uint)random.Next(0, int.MaxValue); _localWindowSize = (uint)random.Next(2000, 3000); _localPacketSize = (uint)random.Next(1000, 2000); _initialSessionSemaphoreCount = random.Next(10, 20); _sessionSemaphore = new SemaphoreLight(_initialSessionSemaphoreCount); _channelClosedRegister = new List<ChannelEventArgs>(); _channelExceptionRegister = new List<ExceptionEventArgs>(); _waitOnConfirmationException = new SystemException(); _sessionMock = new Mock<ISession>(MockBehavior.Strict); _connectionInfoMock = new Mock<IConnectionInfo>(MockBehavior.Strict); var sequence = new MockSequence(); _sessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object); _connectionInfoMock.InSequence(sequence).Setup(p => p.RetryAttempts).Returns(2); _sessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore); _sessionMock.InSequence(sequence) .Setup( p => p.SendMessage( It.Is<ChannelOpenMessage>( m => m.LocalChannelNumber == _localChannelNumber && m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize && m.Info is SessionChannelOpenInfo))); _sessionMock.InSequence(sequence) .Setup(p => p.WaitOnHandle(It.IsNotNull<WaitHandle>())) .Throws(_waitOnConfirmationException); _channel = new ChannelSession(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize); _channel.Closed += (sender, args) => _channelClosedRegister.Add(args); _channel.Exception += (sender, args) => _channelExceptionRegister.Add(args); }
/// <summary> /// Releases the unmanaged resources used by the <see cref="T:System.IO.Stream"/> and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { base.Dispose(disposing); if (this._channel != null) { this._channel.Dispose(); this._channel = null; } if (this._dataReceived != null) { this._dataReceived.Dispose(); this._dataReceived = null; } if (this._session != null) { this._session.Disconnected -= new EventHandler<EventArgs>(Session_Disconnected); this._session.ErrorOccured -= new EventHandler<ExceptionEventArgs>(Session_ErrorOccured); } }
partial void SendData(ChannelSession channel, string command) { channel.SendData(System.Text.Encoding.Default.GetBytes(command)); }
private void InternalUpload(ChannelSession channel, Stream input, FileInfo fileInfo, string filename) { this.InternalSetTimestamp(channel, input, fileInfo.LastWriteTimeUtc, fileInfo.LastAccessTimeUtc); using (var source = fileInfo.OpenRead()) { this.InternalUpload(channel, input, source, filename); } }
private void SendData(ChannelSession channel, byte[] buffer) { channel.SendData(buffer); }
partial void SendData(ChannelSession channel, string command);
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged ResourceMessages.</param> protected virtual void Dispose(bool disposing) { // Check to see if Dispose has already been called. if (!this._isDisposed) { // If disposing equals true, dispose all managed // and unmanaged ResourceMessages. if (disposing) { this._session.Disconnected -= Session_Disconnected; this._session.ErrorOccured -= Session_ErrorOccured; // Dispose managed ResourceMessages. if (this.OutputStream != null) { this.OutputStream.Dispose(); this.OutputStream = null; } // Dispose managed ResourceMessages. if (this.ExtendedOutputStream != null) { this.ExtendedOutputStream.Dispose(); this.ExtendedOutputStream = null; } // Dispose managed ResourceMessages. if (this._sessionErrorOccuredWaitHandle != null) { this._sessionErrorOccuredWaitHandle.Dispose(); this._sessionErrorOccuredWaitHandle = null; } // Dispose managed ResourceMessages. if (this._channel != null) { this._channel.DataReceived -= Channel_DataReceived; this._channel.ExtendedDataReceived -= Channel_ExtendedDataReceived; this._channel.RequestReceived -= Channel_RequestReceived; this._channel.Closed -= Channel_Closed; this._channel.Dispose(); this._channel = null; } } // Note disposing has been done. this._isDisposed = true; } }
/// <summary> /// Waits for the pending asynchronous command execution to complete. /// </summary> /// <param name="asyncResult">The reference to the pending asynchronous request to finish.</param> /// <returns></returns> public string EndExecute(IAsyncResult asyncResult) { if (this._asyncResult == asyncResult && this._asyncResult != null) { lock (this._endExecuteLock) { if (this._asyncResult != null) { // Make sure that operation completed if not wait for it to finish this.WaitHandle(this._asyncResult.AsyncWaitHandle); this._channel.Close(); this._channel = null; this._asyncResult = null; return this.Result; } } } throw new ArgumentException("Either the IAsyncResult object did not come from the corresponding async method on this type, or EndExecute was called multiple times with the same IAsyncResult."); }
/// <summary> /// Releases the unmanaged resources used by the <see cref="T:System.IO.Stream"/> and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { base.Dispose(disposing); if (this._channel != null) { this._channel.Dispose(); this._channel = null; } if (this._dataReceived != null) { this._dataReceived.Dispose(); this._dataReceived = null; } if (this._session != null) { this._session.Disconnected -= Session_Disconnected; this._session.ErrorOccured -= Session_ErrorOccured; } }
/// <summary> /// Starts this shell. /// </summary> /// <exception cref="SshException">Shell is started.</exception> public void Start() { if (this.IsStarted) { throw new SshException("Shell is started."); } if (this.Starting != null) { this.Starting(this, new EventArgs()); } this._channel = this._session.CreateChannel<ChannelSession>(); this._channel.DataReceived += Channel_DataReceived; this._channel.ExtendedDataReceived += Channel_ExtendedDataReceived; this._channel.Closed += Channel_Closed; this._session.Disconnected += Session_Disconnected; this._session.ErrorOccured += Session_ErrorOccured; this._channel.Open(); // TODO: Terminal mode is ignored as this functionality will be obsolete this._channel.SendPseudoTerminalRequest(this._terminalName, this._columns, this._rows, this._width, this._height); this._channel.SendShellRequest(); this._channelClosedWaitHandle = new AutoResetEvent(false); // Start input stream listener this._dataReaderTaskCompleted = new ManualResetEvent(false); this.ExecuteThread(() => { try { var buffer = new byte[this._bufferSize]; while (this._channel.IsOpen) { var asyncResult = this._input.ReadAsync(buffer, 0, buffer.Length); bool waitingFinished = true; while (!waitingFinished) { // Is it possible to WaitAny() on a Task and a WaitHandle? //EventWaitHandle.WaitAny(new WaitHandle[] { asyncResult.AsyncWaitHandle, this._channelClosedWaitHandle }); // this is a workaround: waitingFinished = asyncResult.Wait(100); if (!waitingFinished) { waitingFinished = this._channelClosedWaitHandle.WaitOne(100); } } if (asyncResult.IsCompleted) { // If input stream is closed and disposed already dont finish reading the stream if (this._input == null) return; var read = asyncResult.Result; if (read > 0) { this._channel.SendData(buffer.Take(read).ToArray()); } continue; } else break; } } catch (Exception exp) { this.RaiseError(new ExceptionEventArgs(exp)); } finally { this._dataReaderTaskCompleted.Set(); } }); this.IsStarted = true; if (this.Started != null) { this.Started(this, new EventArgs()); } }
/// <summary> /// Releases the unmanaged resources used by the <see cref="T:System.IO.Stream"/> and optionally releases the managed resources. /// </summary> /// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param> protected override void Dispose(bool disposing) { base.Dispose(disposing); lock (this._incoming) { Monitor.Pulse(this._incoming); } if (this._channel != null) { this._channel.Dispose(); this._channel = null; } }
private void SendConfirmation(ChannelSession channel) { this.SendData(channel, new byte[] { 0 }); }
private void SendConfirmation(ChannelSession channel, byte errorCode, string message) { this.SendData(channel, new byte[] { errorCode }); this.SendData(channel, string.Format("{0}\n", message)); }
private void CreateChannel() { this._channel = this._session.CreateChannel<ChannelSession>(); this._channel.DataReceived += Channel_DataReceived; this._channel.ExtendedDataReceived += Channel_ExtendedDataReceived; this._channel.RequestReceived += Channel_RequestReceived; this._channel.Closed += Channel_Closed; // Dispose of streams if already exists if (this.OutputStream != null) { this.OutputStream.Dispose(); this.OutputStream = null; } if (this.ExtendedOutputStream != null) { this.ExtendedOutputStream.Dispose(); this.ExtendedOutputStream = null; } // Initialize output streams and StringBuilders this.OutputStream = new PipeStream(); this.ExtendedOutputStream = new PipeStream(); this._result = null; this._error = null; }
private void SendData(ChannelSession channel, byte[] buffer, int length) { if (length == buffer.Length) { channel.SendData(buffer); } else { channel.SendData(buffer.Take(length).ToArray()); } }
/// <summary> /// Starts this shell. /// </summary> /// <exception cref="SshException">Shell is started.</exception> public void Start() { if (this.IsStarted) { throw new SshException("Shell is started."); } if (this.Starting != null) { this.Starting(this, new EventArgs()); } this._channel = this._session.CreateClientChannel<ChannelSession>(); this._channel.DataReceived += Channel_DataReceived; this._channel.ExtendedDataReceived += Channel_ExtendedDataReceived; this._channel.Closed += Channel_Closed; this._session.Disconnected += Session_Disconnected; this._session.ErrorOccured += Session_ErrorOccured; this._channel.Open(); this._channel.SendPseudoTerminalRequest(this._terminalName, this._columns, this._rows, this._width, this._height, this._terminalModes); this._channel.SendShellRequest(); this._channelClosedWaitHandle = new AutoResetEvent(false); // Start input stream listener this._dataReaderTaskCompleted = new ManualResetEvent(false); this.ExecuteThread(() => { try { var buffer = new byte[this._bufferSize]; while (this._channel.IsOpen) { var asyncResult = this._input.BeginRead(buffer, 0, buffer.Length, delegate(IAsyncResult result) { // If input stream is closed and disposed already dont finish reading the stream if (this._input == null) return; var read = this._input.EndRead(result); if (read > 0) { this._channel.SendData(buffer.Take(read).ToArray()); } }, null); EventWaitHandle.WaitAny(new WaitHandle[] { asyncResult.AsyncWaitHandle, this._channelClosedWaitHandle }); if (asyncResult.IsCompleted) continue; break; } } catch (Exception exp) { this.RaiseError(new ExceptionEventArgs(exp)); } finally { this._dataReaderTaskCompleted.Set(); } }); this.IsStarted = true; if (this.Started != null) { this.Started(this, new EventArgs()); } }
private void InternalDownload(ChannelSession channel, Stream input, FileSystemInfo fileSystemInfo) { DateTime modifiedTime = DateTime.Now; DateTime accessedTime = DateTime.Now; var startDirectoryFullName = fileSystemInfo.FullName; var currentDirectoryFullName = startDirectoryFullName; var directoryCounter = 0; while (true) { var message = ReadString(input); if (message == "E") { this.SendConfirmation(channel); // Send reply directoryCounter--; currentDirectoryFullName = new DirectoryInfo(currentDirectoryFullName).Parent.FullName; if (directoryCounter == 0) break; continue; } var match = _directoryInfoRe.Match(message); if (match.Success) { this.SendConfirmation(channel); // Send reply // Read directory var mode = long.Parse(match.Result("${mode}")); var filename = match.Result("${filename}"); DirectoryInfo newDirectoryInfo; if (directoryCounter > 0) { newDirectoryInfo = Directory.CreateDirectory(string.Format("{0}{1}{2}", currentDirectoryFullName, Path.DirectorySeparatorChar, filename)); newDirectoryInfo.LastAccessTime = accessedTime; newDirectoryInfo.LastWriteTime = modifiedTime; } else { // Dont create directory for first level newDirectoryInfo = fileSystemInfo as DirectoryInfo; } directoryCounter++; currentDirectoryFullName = newDirectoryInfo.FullName; continue; } match = _fileInfoRe.Match(message); if (match.Success) { // Read file this.SendConfirmation(channel); // Send reply var mode = match.Result("${mode}"); var length = long.Parse(match.Result("${length}")); var fileName = match.Result("${filename}"); var fileInfo = fileSystemInfo as FileInfo; if (fileInfo == null) fileInfo = new FileInfo(string.Format("{0}{1}{2}", currentDirectoryFullName, Path.DirectorySeparatorChar, fileName)); using (var output = fileInfo.OpenWrite()) { this.InternalDownload(channel, input, output, fileName, length); } fileInfo.LastAccessTime = accessedTime; fileInfo.LastWriteTime = modifiedTime; if (directoryCounter == 0) break; continue; } match = _timestampRe.Match(message); if (match.Success) { // Read timestamp this.SendConfirmation(channel); // Send reply var mtime = long.Parse(match.Result("${mtime}")); var atime = long.Parse(match.Result("${atime}")); var zeroTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); modifiedTime = zeroTime.AddSeconds(mtime); accessedTime = zeroTime.AddSeconds(atime); continue; } this.SendConfirmation(channel, 1, string.Format("\"{0}\" is not valid protocol message.", message)); } }
private void Channel_Closed(object sender, ChannelEventArgs e) { if (this.Stopping != null) { // Handle event on different thread this.ExecuteThread(() => this.Stopping(this, new EventArgs())); } if (this._channel.IsOpen) { this._channel.SendEof(); this._channel.Close(); } this._channelClosedWaitHandle.Set(); this._input.Dispose(); this._input = null; this._dataReaderTaskCompleted.WaitOne(this._session.ConnectionInfo.Timeout); this._dataReaderTaskCompleted.Dispose(); this._dataReaderTaskCompleted = null; this._channel.DataReceived -= Channel_DataReceived; this._channel.ExtendedDataReceived -= Channel_ExtendedDataReceived; this._channel.Closed -= Channel_Closed; this._session.Disconnected -= Session_Disconnected; this._session.ErrorOccured -= Session_ErrorOccured; if (this.Stopped != null) { // Handle event on different thread this.ExecuteThread(() => this.Stopped(this, new EventArgs())); } this._channel = null; }
private void InternalUpload(ChannelSession channel, PipeStream input, DirectoryInfo directoryInfo, string directoryName) { this.InternalSetTimestamp(channel, input, directoryInfo.LastWriteTimeUtc, directoryInfo.LastAccessTimeUtc); this.SendData(channel, string.Format("D0755 0 {0}\n", directoryName)); this.CheckReturnCode(input); // Upload files var files = directoryInfo.GetFiles(); foreach (var file in files) { this.InternalUpload(channel, input, file, file.Name); } // Upload directories var directories = directoryInfo.GetDirectories(); foreach (var directory in directories) { this.InternalUpload(channel, input, directory, directory.Name); } this.SendData(channel, "E\n"); this.CheckReturnCode(input); }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged ResourceMessages.</param> protected virtual void Dispose(bool disposing) { // Check to see if Dispose has already been called. if (!this._disposed) { // If disposing equals true, dispose all managed // and unmanaged ResourceMessages. if (disposing) { if (this._channelClosedWaitHandle != null) { this._channelClosedWaitHandle.Dispose(); this._channelClosedWaitHandle = null; } if (this._channel != null) { this._channel.Dispose(); this._channel = null; } if (this._dataReaderTaskCompleted != null) { this._dataReaderTaskCompleted.Dispose(); this._dataReaderTaskCompleted = null; } } // Note disposing has been done. this._disposed = true; } }
private void InternalDownload(ChannelSession channel, Stream input, Stream output, string filename, long length) { var buffer = new byte[Math.Min(length, this.BufferSize)]; var needToRead = length; do { var read = input.Read(buffer, 0, (int)Math.Min(needToRead, this.BufferSize)); output.Write(buffer, 0, read); this.RaiseDownloadingEvent(filename, length, length - needToRead); needToRead -= read; } while (needToRead > 0); output.Flush(); // Raise one more time when file downloaded this.RaiseDownloadingEvent(filename, length, length - needToRead); // Send confirmation byte after last data byte was read this.SendConfirmation(channel); this.CheckReturnCode(input); }
private void InternalSetTimestamp(ChannelSession channel, Stream input, DateTime lastWriteTime, DateTime lastAccessime) { var zeroTime = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc); var modificationSeconds = (long)(lastWriteTime - zeroTime).TotalSeconds; var accessSeconds = (long)(lastAccessime - zeroTime).TotalSeconds; this.SendData(channel, string.Format("T{0} 0 {1} 0\n", modificationSeconds, accessSeconds)); this.CheckReturnCode(input); }
public void Connect() { this._channel = this._session.CreateChannel<ChannelSession>(); this._session.ErrorOccured += Session_ErrorOccured; this._session.Disconnected += Session_Disconnected; this._channel.DataReceived += Channel_DataReceived; this._channel.Open(); this._channel.SendSubsystemRequest("sftp"); this.SendMessage(new SftpInitRequest(3)); this.WaitHandle(this._sftpVersionConfirmed, this._operationTimeout); this.ProtocolVersion = 3; // Resolve current directory this.WorkingDirectory = this.RequestRealPath(".").Keys.First(); }
private void InternalUpload(ChannelSession channel, Stream input, Stream source, string filename) { var length = source.Length; this.SendData(channel, string.Format("C0644 {0} {1}\n", length, filename)); var buffer = new byte[this.BufferSize]; var read = source.Read(buffer, 0, buffer.Length); long totalRead = 0; while (read > 0) { this.SendData(channel, buffer, read); totalRead += read; this.RaiseUploadingEvent(filename, length, totalRead); read = source.Read(buffer, 0, buffer.Length); } this.SendConfirmation(channel); this.CheckReturnCode(input); }
/// <summary> /// Releases unmanaged and - optionally - managed resources /// </summary> /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param> protected virtual void Dispose(bool disposing) { // Check to see if Dispose has already been called. if (!this._isDisposed) { if (this._channel != null) { this._channel.DataReceived -= Channel_DataReceived; this._channel.Dispose(); this._channel = null; } this._session.ErrorOccured -= Session_ErrorOccured; this._session.Disconnected -= Session_Disconnected; // If disposing equals true, dispose all managed // and unmanaged resources. if (disposing) { // Dispose managed resources. if (this._errorOccuredWaitHandle != null) { this._errorOccuredWaitHandle.Dispose(); this._errorOccuredWaitHandle = null; } } // Note disposing has been done. _isDisposed = true; } }
private void Arrange() { var random = new Random(); _localChannelNumber = (uint) random.Next(0, int.MaxValue); _localWindowSize = (uint) random.Next(2000, 3000); _localPacketSize = (uint) random.Next(1000, 2000); _initialSessionSemaphoreCount = random.Next(10, 20); _sessionSemaphore = new SemaphoreLight(_initialSessionSemaphoreCount); _channelClosedRegister = new List<ChannelEventArgs>(); _channelExceptionRegister = new List<ExceptionEventArgs>(); _actualException = null; _failureReasonCode = (uint)random.Next(0, int.MaxValue); _failureDescription = random.Next().ToString(CultureInfo.InvariantCulture); _failureLanguage = random.Next().ToString(CultureInfo.InvariantCulture); _sessionMock = new Mock<ISession>(MockBehavior.Strict); _connectionInfoMock = new Mock<IConnectionInfo>(MockBehavior.Strict); var sequence = new MockSequence(); _sessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object); _connectionInfoMock.InSequence(sequence).Setup(p => p.RetryAttempts).Returns(1); _sessionMock.Setup(p => p.SessionSemaphore).Returns(_sessionSemaphore); _sessionMock.InSequence(sequence) .Setup( p => p.SendMessage( It.Is<ChannelOpenMessage>( m => m.LocalChannelNumber == _localChannelNumber && m.InitialWindowSize == _localWindowSize && m.MaximumPacketSize == _localPacketSize && m.Info is SessionChannelOpenInfo))); _sessionMock.InSequence(sequence) .Setup(p => p.WaitOnHandle(It.IsNotNull<WaitHandle>())) .Callback<WaitHandle>( w => { _sessionMock.Raise( s => s.ChannelOpenFailureReceived += null, new MessageEventArgs<ChannelOpenFailureMessage>( new ChannelOpenFailureMessage( _localChannelNumber, _failureDescription, _failureReasonCode, _failureLanguage ))); w.WaitOne(); }); _sessionMock.InSequence(sequence).Setup(p => p.ConnectionInfo).Returns(_connectionInfoMock.Object); _connectionInfoMock.InSequence(sequence).Setup(p => p.RetryAttempts).Returns(1); _channel = new ChannelSession(_sessionMock.Object, _localChannelNumber, _localWindowSize, _localPacketSize); _channel.Closed += (sender, args) => _channelClosedRegister.Add(args); _channel.Exception += (sender, args) => _channelExceptionRegister.Add(args); }