public async Task WhenSetClientConnectionEncryptionLevelSetToLow_ThenConnectionSucceeds(
[WindowsInstance(InitializeScript = @"
& reg add ""HKLM\SOFTWARE\Policies\Microsoft\Windows NT\Terminal Services"" /t REG_DWORD /v MinEncryptionLevel /d 1 /f | Out-Default
")] InstanceRequest testInstance,
[Credential] CredentialRequest credential)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(
testInstance.Locator,
await credential.GetCredentialAsync()))
{
var session = await Connect(tunnel, testInstance.Locator);
AwaitEvent <RemoteDesktopConnectionSuceededEvent>();
Assert.IsNull(this.ExceptionShown);
RemoteDesktopWindowClosedEvent expectedEvent = null;
this.serviceProvider.GetService <IEventService>()
.BindHandler <RemoteDesktopWindowClosedEvent>(e =>
{
expectedEvent = e;
});
Delay(TimeSpan.FromSeconds(5));
session.Close();
Assert.IsNotNull(expectedEvent);
}
}
public async Task WhenServerClosesConnectionMultipleHttpRequests_ThenRelayEnds(
[LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(vm.InstanceReference);
for (int i = 0; i < 3; i++)
{
byte[] request = new ASCIIEncoding().GetBytes(
$"GET /?_={i} HTTP/1.1\r\nHost:www\r\nConnection: keep-alive\r\n\r\n");
await stream.WriteAsync(request, 0, request.Length, this.tokenSource.Token);
byte[] buffer = new byte[stream.MinReadSize];
var response = new HttpResponseAccumulator();
int bytesRead;
while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, this.tokenSource.Token)) > 0)
{
response.Accumulate(buffer, 0, bytesRead);
if (response.IsComplete)
{
TraceSources.Compute.TraceVerbose("Got full response");
break;
}
}
Assert.AreEqual(response.ExpectedBytes, response.TotalBytesRead);
}
await stream.CloseAsync(this.tokenSource.Token);
}
public async Task WhenCredentialsInvalid_ThenErrorIsShownAndWindowIsClosed(
[WindowsInstance] InstanceRequest testInstance,
[Credential] CredentialRequest credential)
{
await testInstance.AwaitReady();
using (var tunnel = RdpTunnel.Create(
testInstance.Locator,
await credential.GetCredentialAsync()))
{
var rdpService = new RemoteDesktopService(this.serviceProvider);
var session = rdpService.Connect(
testInstance.Locator,
"localhost",
(ushort)tunnel.LocalPort,
new VmInstanceConnectionSettings()
{
Username = "******",
Password = SecureStringExtensions.FromClearText("wrong"),
AuthenticationLevel = RdpAuthenticationLevel.NoServerAuthentication,
UserAuthenticationBehavior = RdpUserAuthenticationBehavior.AbortOnFailure,
DesktopSize = RdpDesktopSize.ClientSize
});
AwaitEvent <RemoteDesktopConnectionFailedEvent>();
Assert.IsNotNull(this.ExceptionShown);
Assert.IsInstanceOf(typeof(RdpDisconnectedException), this.ExceptionShown);
Assert.AreEqual(2055, ((RdpDisconnectedException)this.ExceptionShown).DisconnectReason);
}
}
public async Task WhenUsingExistingKey_ThenAddMetadataSucceeds(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var key = Guid.NewGuid().ToString();
await this.instancesResource.AddMetadataAsync(
testInstance.InstanceReference,
key,
"value to be overridden",
CancellationToken.None);
var value = "metadata value";
await this.instancesResource.AddMetadataAsync(
testInstance.InstanceReference,
key,
value,
CancellationToken.None);
var instance = await this.instancesResource.Get(
testInstance.InstanceReference.ProjectId,
testInstance.InstanceReference.Zone,
testInstance.InstanceReference.Name)
.ExecuteAsync(CancellationToken.None)
.ConfigureAwait(false);
Assert.AreEqual(
value,
instance.Metadata.Items.First(i => i.Key == key).Value);
}
public async Task WhenServerClosesConnectionAfterSingleHttpRequest_ThenRelayEnds(
[LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(vm.InstanceReference);
byte[] request = new ASCIIEncoding().GetBytes(
"GET / HTTP/1.0\r\n\r\n");
await stream.WriteAsync(request, 0, request.Length, this.tokenSource.Token);
byte[] buffer = new byte[stream.MinReadSize];
var response = new HttpResponseAccumulator();
int bytesRead;
while ((bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, this.tokenSource.Token)) > 0)
{
response.Accumulate(buffer, 0, bytesRead);
}
await stream.CloseAsync(this.tokenSource.Token);
Assert.AreEqual(response.ExpectedBytes, response.TotalBytesRead);
}
public async Task WhenConnectingWithInvalidAccessToken_ThenReadingFailsWithUnauthorizedException
([LinuxInstance(InitializeScript = InstallApache)] InstanceRequest vm)
{
await vm.AwaitReady();
// NB. Fiddler might cause this test to fail.
byte[] request = new ASCIIEncoding().GetBytes(
"GET / HTTP/1.0\r\n\r\n");
var stream = new SshRelayStream(
new IapTunnelingEndpoint(
GoogleCredential.FromAccessToken("invalid"),
vm.Locator,
80,
IapTunnelingEndpoint.DefaultNetworkInterface,
TestProject.UserAgent));
await stream.WriteAsync(request, 0, request.Length, CancellationToken.None);
AssertEx.ThrowsAggregateException <UnauthorizedException>(() =>
{
byte[] buffer = new byte[64 * 1024];
stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None).Wait();
});
}
public async Task DoDeregisterService(string serviceName, string groupName, Instance instance)
{
var request = new InstanceRequest(namespaceId, serviceName, groupName, NamingRemoteConstants.DE_REGISTER_INSTANCE, instance);
await RequestToServer <CommonResponse>(request).ConfigureAwait(false);
_redoService.RemoveInstanceForRedo(serviceName, groupName);
}
public async Task DeregisterService(string serviceName, string groupName, Instance instance)
{
_logger?.LogInformation("[DEREGISTER-SERVICE] {0} deregistering service {1} with instance {2}", namespaceId, serviceName, instance);
var request = new InstanceRequest(namespaceId, serviceName, groupName, NamingRemoteConstants.DE_REGISTER_INSTANCE, instance);
await RequestToServer <CommonResponse>(request);
namingGrpcConnectionEventListener.RemoveInstanceForRedo(serviceName, groupName, instance);
}
public bool RemoveInstance(string instanceId)
{
var request = new InstanceRequest
{
Id = instanceId
};
var response = _messageBus.Request <InstanceRequest, InstanceResponse>(InstanceRequest.ChannelDelete, request);
return(response.IsSuccess);
}
public async Task WhenSwitchingToStoppedInstanceNode_ThenControlsAreDisabled(
[WindowsInstance] InstanceRequest testInstance)
{
var node = await CreateNode(testInstance, false);
await this.viewModel.SwitchToModelAsync(node);
Assert.IsFalse(this.viewModel.IsEnableTailingButtonEnabled);
Assert.IsFalse(this.viewModel.IsOutputBoxEnabled);
}
public bool StopInstance(string instanceId)
{
var request = new InstanceRequest
{
Id = instanceId
};
var response = _messageBus.RequestWait <InstanceRequest, InstanceResponse>(InstanceRequest.ChannelStop, request);
return(response.IsSuccess);
}
public static UIScreen ReplayScreen(Action <List <XMLMenu.CacheInstruction> > cacheTentative, Action cacheConfirm) =>
new LazyUIScreen(() => SaveData.p.ReplayData.Count.Range().Select(i =>
new CacheNavigateUINode(cacheTentative, () =>
SaveData.p.ReplayData.TryN(i)?.metadata.Record.AsDisplay(true, true) ?? generic_deleted,
new FuncNode(() => {
cacheConfirm();
return(InstanceRequest.ViewReplay(SaveData.p.ReplayData.TryN(i)));
}, replay_view),
new ConfirmFuncNode(() => SaveData.p.TryDeleteReplay(i), delete, true)
).With(monospaceClass).With(small2Class)
).ToArray());
public async Task WhenSwitchingToRunningInstanceNode_ThenOutputIsPopulated(
[WindowsInstance] InstanceRequest testInstance)
{
var node = await CreateNode(testInstance, true);
await this.viewModel.SwitchToModelAsync(node);
Assert.IsTrue(this.viewModel.IsEnableTailingButtonEnabled);
Assert.IsTrue(this.viewModel.IsOutputBoxEnabled);
StringAssert.Contains("Instance setup finished", this.viewModel.Output);
}
public async Task WhenBlocked_ThenEnableHasNoImpactOnTailing(
[WindowsInstance] InstanceRequest testInstance)
{
var node = await CreateNode(testInstance, true);
await this.viewModel.SwitchToModelAsync(node);
this.viewModel.IsTailBlocked = true;
this.viewModel.IsTailEnabled = true;
Assert.IsNull(this.viewModel.TailCancellationTokenSource, "not tailing yet");
}
public async Task WhenSwitchingToStoppedInstanceNode_ThenControlsAreDisabled(
[WindowsInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential)
{
var viewModel = CreateViewModel(await credential.GetCredentialAsync());
var node = await CreateNode(testInstance, false);
await viewModel.SwitchToModelAsync(node);
Assert.IsFalse(viewModel.IsEnableTailingButtonEnabled);
Assert.IsFalse(viewModel.IsOutputBoxEnabled);
StringAssert.Contains(SerialOutputViewModel.DefaultWindowTitle, viewModel.WindowTitle);
}
private void OperateAWSServer(InstanceRequest instanceRequest, ILambdaContext context, ref bool actionSucceeded, ref string actionMessage)
{
try
{
serverOperationsHelper.InstanceRequestObj = instanceRequest;
serverOperationsHelper.updateInstanceIdFromName();
instanceRequest = serverOperationsHelper.ServerOperation(ref actionSucceeded, ref actionMessage);
}
catch (Exception ex)
{
context.Logger.LogLine($"StartServerIntentProcessor::OperateAWSServer => {ex.Message}");
context.Logger.LogLine($"StartServerIntentProcessor::OperateAWSServer => {ex.StackTrace}");
}
}
private void TryInferSlots(InstanceRequest instanceRequest, InstanceRequest previousRequest)
{
if (previousRequest != null)
{
if (string.IsNullOrEmpty(instanceRequest.InstanceName) && !string.IsNullOrEmpty(previousRequest.InstanceName))
{
instanceRequest.InstanceName = previousRequest.InstanceName;
}
if (string.IsNullOrEmpty(instanceRequest.InstanceAction) && !string.IsNullOrEmpty(previousRequest.InstanceAction))
{
instanceRequest.InstanceAction = previousRequest.InstanceAction;
}
}
}
public async Task WhenLoadAsyncCompletes_ThenOutputContainsExistingData(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var model = await SerialOutputModel.LoadAsync(
new ComputeEngineAdapter(Defaults.GetCredential()),
await testInstance.GetInstanceAsync(),
SerialPortStream.ConsolePort,
CancellationToken.None);
Assert.IsFalse(string.IsNullOrWhiteSpace(model.Output));
StringAssert.Contains("Instance setup finished", model.Output);
}
public async Task WhenBlocked_ThenEnableHasNoImpactOnTailing(
[WindowsInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential)
{
var viewModel = CreateViewModel(await credential.GetCredentialAsync());
var node = await CreateNode(testInstance, true);
await viewModel.SwitchToModelAsync(node);
viewModel.IsTailBlocked = true;
viewModel.IsTailEnabled = true;
Assert.IsNull(viewModel.TailCancellationTokenSource, "not tailing yet");
}
public async Task WhenServerNotListening_ThenReadReturnsZero(
[LinuxInstance] InstanceRequest vm)
{
await vm.AwaitReady();
var stream = ConnectToWebServer(vm.InstanceReference);
byte[] request = new ASCIIEncoding().GetBytes(
$"GET / HTTP/1.1\r\nHost:www\r\nConnection: keep-alive\r\n\r\n");
await stream.WriteAsync(request, 0, request.Length, CancellationToken.None);
byte[] buffer = new byte[stream.MinReadSize];
Assert.AreEqual(0, stream.ReadAsync(buffer, 0, buffer.Length, CancellationToken.None).Result);
}
public async Task WhenInstanceCreated_ThenListLogEntriesReturnsInsertEvent(
[LinuxInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var loggingService = new LoggingService(new BaseClientService.Initializer
{
HttpClientInitializer = Defaults.GetCredential()
});
var startDate = DateTime.UtcNow.AddDays(-30);
var endDate = DateTime.UtcNow;
var request = new ListLogEntriesRequest()
{
ResourceNames = new[]
{
"projects/" + Defaults.ProjectId
},
Filter = $"resource.type=\"gce_instance\" " +
$"AND protoPayload.methodName:{InsertInstanceEvent.Method} " +
$"AND timestamp > {startDate:yyyy-MM-dd}",
PageSize = 1000,
OrderBy = "timestamp desc"
};
var events = new List <EventBase>();
var instanceBuilder = new InstanceSetHistoryBuilder(startDate, endDate);
// Creating the VM might be quicker than the logs become available.
for (int retry = 0; retry < 4 && !events.Any(); retry++)
{
await loggingService.Entries.ListEventsAsync(
request,
events.Add,
new Apis.Util.ExponentialBackOff());
if (!events.Any())
{
await Task.Delay(20 * 1000);
}
}
var insertEvent = events.OfType <InsertInstanceEvent>()
.First(e => e.InstanceReference == instanceRef);
Assert.IsNotNull(insertEvent);
}
public async Task WhenSendingMessagesToEchoServer_MessagesAreReceivedVerbatim(
[LinuxInstance(InitializeScript = InstallEchoServer)] InstanceRequest vm,
[Credential] CredentialRequest credential,
[Values(
1,
(int)DataMessage.MaxDataLength - 1,
(int)DataMessage.MaxDataLength,
(int)DataMessage.MaxDataLength + 1,
(int)DataMessage.MaxDataLength * 10)] int length,
[Values(1, 3)] int count)
{
var message = new byte[length];
FillArray(message);
await vm.AwaitReady();
var stream = ConnectToEchoServer(
vm.Locator,
await credential.GetCredentialAsync());
for (int i = 0; i < count; i++)
{
await stream.WriteAsync(message, 0, message.Length, this.tokenSource.Token);
var response = new byte[length];
int totalBytesRead = 0;
while (true)
{
var bytesRead = await stream.ReadAsync(
response,
totalBytesRead,
response.Length - totalBytesRead,
this.tokenSource.Token);
totalBytesRead += bytesRead;
if (bytesRead == 0 || totalBytesRead >= length)
{
break;
}
}
Assert.AreEqual(length, totalBytesRead);
Assert.AreEqual(message, response);
}
await stream.CloseAsync(this.tokenSource.Token);
}
public async Task WhenUserDoesntExist_ThenResetPasswordCreatesNewUser(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******" + Guid.NewGuid().ToString().Substring(20);
var credentials = await this.instancesResource.ResetWindowsUserAsync(
testInstance.Locator,
username,
CancellationToken.None);
Assert.AreEqual(username, credentials.UserName);
Assert.IsEmpty(credentials.Domain);
Assert.IsNotEmpty(credentials.Password);
}
public async Task WhenUserNotInRole_ThenGetInstanceAsyncThrowsResourceAccessDeniedException(
[LinuxInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.IapTunnelUser)] CredentialRequest credential)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var adapter = new ComputeEngineAdapter(await credential.GetCredentialAsync());
AssertEx.ThrowsAggregateException <ResourceAccessDeniedException>(
() => adapter.GetInstanceAsync(
testInstance.Locator,
CancellationToken.None).Wait());
}
public async Task TestResetPasswordForNonexistingUserSucceeds(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
var username = "******" + Guid.NewGuid().ToString().Substring(20);
var credentials = await this.instancesResource.ResetWindowsUserAsync(
testInstance.InstanceReference,
username,
CancellationToken.None);
Assert.AreEqual(username, credentials.UserName);
Assert.IsEmpty(credentials.Domain);
Assert.IsNotEmpty(credentials.Password);
}
public async Task WhenInstanceExistsAndIsListening_ThenProbeSucceeds(
[WindowsInstance] InstanceRequest testInstance)
{
await testInstance.AwaitReady();
using (var stream = new SshRelayStream(
new IapTunnelingEndpoint(
Defaults.GetCredential(),
testInstance.InstanceReference,
3389,
IapTunnelingEndpoint.DefaultNetworkInterface)))
{
await stream.TestConnectionAsync(TimeSpan.FromSeconds(10));
}
}
public async Task WhenInstanceCreated_ThenListLogEntriesReturnsInsertEvent(
[LinuxInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.LogsViewer)] CredentialRequest credential)
{
await testInstance.AwaitReady();
var instanceRef = await testInstance.GetInstanceAsync();
var startDate = DateTime.UtcNow.AddDays(-30);
var endDate = DateTime.UtcNow;
var adapter = new AuditLogAdapter(await credential.GetCredentialAsync());
var request = new ListLogEntriesRequest()
{
ResourceNames = new[]
{
"projects/" + TestProject.ProjectId
},
Filter = $"resource.type=\"gce_instance\" " +
$"AND protoPayload.methodName:{InsertInstanceEvent.Method} " +
$"AND timestamp > {startDate:yyyy-MM-dd}",
PageSize = 1000,
OrderBy = "timestamp desc"
};
var events = new List <EventBase>();
var instanceBuilder = new InstanceSetHistoryBuilder(startDate, endDate);
// Creating the VM might be quicker than the logs become available.
for (int retry = 0; retry < 4 && !events.Any(); retry++)
{
await adapter.ListEventsAsync(
request,
events.Add,
new Apis.Util.ExponentialBackOff(),
CancellationToken.None);
if (!events.Any())
{
await Task.Delay(20 * 1000);
}
}
var insertEvent = events.OfType <InsertInstanceEvent>()
.First(e => e.InstanceReference == instanceRef);
Assert.IsNotNull(insertEvent);
}
public virtual async Task <ActionResult> Update([FromRoute] int id, [FromBody] InstanceRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _instanceService.UpdateEntityByIdAsync(request, id);
if (!result)
{
return(StatusCode(500));
}
return(NoContent());
}
public virtual async Task <ActionResult <SampleDto> > Create([FromBody] InstanceRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var dto = await _instanceService.CreateEntityAsync(request);
if (dto == null)
{
return(StatusCode(500));
}
return(Ok(dto));
}
public async Task WhenSwitchingToRunningInstanceNode_ThenOutputIsPopulated(
[WindowsInstance] InstanceRequest testInstance,
[Credential(Role = PredefinedRole.ComputeViewer)] CredentialRequest credential)
{
var viewModel = CreateViewModel(await credential.GetCredentialAsync());
var node = await CreateNode(testInstance, true);
await viewModel.SwitchToModelAsync(node);
Assert.IsTrue(viewModel.IsEnableTailingButtonEnabled);
Assert.IsTrue(viewModel.IsOutputBoxEnabled);
StringAssert.Contains("Instance setup finished", viewModel.Output);
StringAssert.Contains(SerialOutputViewModel.DefaultWindowTitle, viewModel.WindowTitle);
StringAssert.Contains(testInstance.Locator.Name, viewModel.WindowTitle);
}
