protected override void Open(SshConnectionService connService)
{
if (_isDisposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
// Create console handler.
_consoleHandler = new ConsoleHandler("powershell");
_consoleHandler.ConsoleTitle = string.Format("{0} - channel {1}",
connService.Client.Connection.ToString(), this.ServerChannel);
_consoleHandler.InjectionDllFileName = SshWinConsoleChannel.InjectionDllFileName;
_consoleHandler.ConsoleWindowResized += new EventHandler <EventArgs>(
_consoleHandler_ConsoleWindowResized);
_consoleHandler.ConsoleBufferResized += new EventHandler <EventArgs>(
_consoleHandler_ConsoleBufferResized);
_consoleHandler.ConsoleNewData += new EventHandler <EventArgs>(_consoleHandler_ConsoleNewData);
_consoleHandler.ConsoleBufferChanged += new EventHandler <EventArgs>(
_consoleHandler_ConnsoleBufferChanged);
_consoleHandler.ConsoleCursorPositionChanged += new EventHandler <EventArgs>(
_consoleHandler_ConsoleCursorPositionChanged);
base.Open(connService);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncUsesPreferredUsername()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
settings.SshUsername.StringValue = "bob";
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.authorizedKeyService.Verify(s => s.AuthorizeKeyAsync(
It.Is <InstanceLocator>(l => l == SampleLocator),
It.IsAny <ISshKey>(),
It.IsAny <TimeSpan>(),
It.Is <string>(user => user == "bob"),
It.IsAny <AuthorizeKeyMethods>(),
It.IsAny <CancellationToken>()), Times.Once);
}
public void WhenKeyAuthorizationFails_ThenActivateOrConnectInstanceAsyncActivatesSessionThrowsSshKeyPushFailedException()
{
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(
InstanceConnectionSettings
.CreateNew(SampleLocator.ProjectId, SampleLocator.Name)
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
this.authorizedKeyService.Setup(a => a.AuthorizeKeyAsync(
It.IsAny <InstanceLocator>(),
It.IsAny <ISshKey>(),
It.IsAny <TimeSpan>(),
It.IsAny <string>(),
It.IsAny <AuthorizeKeyMethods>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(new SshKeyPushFailedException("mock", HelpTopics.ManagingOsLogin));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
AssertEx.ThrowsAggregateException <SshKeyPushFailedException>(
() => service.ActivateOrConnectInstanceAsync(vmNode.Object).Wait());
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncUsesConnectionTimeout()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
settings.SshConnectionTimeout.IntValue = (int)TimeSpan.FromSeconds(123).TotalSeconds;
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.tunnelBrokerService.Verify(s => s.ConnectAsync(
It.Is <TunnelDestination>(d => d.RemotePort == 2222),
It.IsAny <ISshRelayPolicy>(),
It.Is <TimeSpan>(t => t == TimeSpan.FromSeconds(123))), Times.Once);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncUsesKeyValidityFromSettings()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
settings.SshUsername.StringValue = "bob";
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var sshSettingsRepository = this.serviceRegistry.GetService <SshSettingsRepository>();
var sshSettings = sshSettingsRepository.GetSettings();
sshSettings.PublicKeyValidity.IntValue = (int)TimeSpan.FromDays(4).TotalSeconds;
sshSettingsRepository.SetSettings(sshSettings);
var vmNode = new Mock <IProjectExplorerInstanceNode>();
vmNode.SetupGet(n => n.Instance).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.authorizedKeyService.Verify(s => s.AuthorizeKeyAsync(
It.Is <InstanceLocator>(l => l == SampleLocator),
It.IsAny <ISshKey>(),
It.Is <TimeSpan>(validity => validity == TimeSpan.FromDays(4)),
It.IsAny <string>(),
It.IsAny <AuthorizeKeyMethods>(),
It.IsAny <CancellationToken>()), Times.Once);
}
public async Task WhenSessionExists_ThenActivateOrConnectInstanceAsyncActivatesSession()
{
this.serviceRegistry.AddMock <IConnectionSettingsService>();
this.sessionBroker.Setup(b => b.TryActivate(
It.Is <InstanceLocator>(l => l == SampleLocator)))
.Returns(true);
var vmNode = CreateInstanceNodeMock();
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
sessionBroker.Verify(b => b.TryActivate(
It.Is <InstanceLocator>(l => l == SampleLocator)), Times.Once);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncCreatesRsaKey()
{
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectModelNode>()))
.Returns(
InstanceConnectionSettings
.CreateNew(SampleLocator.ProjectId, SampleLocator.Name)
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = CreateInstanceNodeMock();
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.keyStore.Verify(k => k.CreateRsaKey(
It.Is <string>(name => name == "IAPDESKTOP_" + SampleEmail),
It.Is <CngKeyUsages>(u => u == CngKeyUsages.Signing),
It.Is <bool>(create => create),
It.IsAny <IWin32Window>()), Times.Once);
}
public async Task WhenNoSessionExists_ThenActivateOrConnectInstanceAsyncConnectsToConfiguredPort()
{
var settings = InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name);
settings.SshPort.IntValue = 2222;
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectModelNode>()))
.Returns(settings
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = CreateInstanceNodeMock();
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.tunnelBrokerService.Verify(s => s.ConnectAsync(
It.Is <TunnelDestination>(d => d.RemotePort == 2222),
It.IsAny <ISshRelayPolicy>(),
It.IsAny <TimeSpan>()), Times.Once);
}
public void WhenTunnelUnauthorized_ThenActivateOrConnectInstanceAsyncActivatesSessionThrowsConnectionFailedException()
{
var settingsService = this.serviceRegistry.AddMock <IConnectionSettingsService>();
settingsService.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectExplorerNode>()))
.Returns(
InstanceConnectionSettings
.CreateNew(SampleLocator.ProjectId, SampleLocator.Name)
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
this.tunnelBrokerService.Setup(s => s.ConnectAsync(
It.IsAny <TunnelDestination>(),
It.IsAny <ISshRelayPolicy>(),
It.IsAny <TimeSpan>())).ThrowsAsync(new UnauthorizedException("mock"));
var vmNode = new Mock <IProjectExplorerVmInstanceNode>();
vmNode.SetupGet(n => n.Reference).Returns(SampleLocator);
var service = new SshConnectionService(this.serviceRegistry);
AssertEx.ThrowsAggregateException <ConnectionFailedException>(
() => service.ActivateOrConnectInstanceAsync(vmNode.Object).Wait());
}
public async Task WhenSessionExists_ThenConnectInstanceAsyncCreatesNewSessionSession()
{
this.serviceRegistry.AddMock <IConnectionSettingsService>();
this.sessionBroker.Setup(b => b.TryActivate(
It.Is <InstanceLocator>(l => l == SampleLocator)))
.Returns(false);
this.serviceRegistry.AddMock <IConnectionSettingsService>()
.Setup(s => s.GetConnectionSettings(It.IsAny <IProjectModelNode>()))
.Returns(
InstanceConnectionSettings.CreateNew(SampleLocator.ProjectId, SampleLocator.Name)
.ToPersistentSettingsCollection(s => Assert.Fail("should not be called")));
var vmNode = CreateInstanceNodeMock();
var service = new SshConnectionService(this.serviceRegistry);
await service.ActivateOrConnectInstanceAsync(vmNode.Object);
this.tunnelBrokerService.Verify(s => s.ConnectAsync(
It.Is <TunnelDestination>(d => d.RemotePort == 22),
It.IsAny <ISshRelayPolicy>(),
It.IsAny <TimeSpan>()), Times.Once);
}
