//---------------------------------------------------------------------
// Commands.
//---------------------------------------------------------------------
private async void GenerateCredentials(IProjectExplorerNode node)
{
try
{
if (node is IProjectExplorerVmInstanceNode vmNode)
{
await this.serviceProvider.GetService <ICredentialsService>()
.GenerateCredentialsAsync(
this.window,
vmNode.Reference,
vmNode.SettingsEditor)
.ConfigureAwait(true);
}
}
catch (Exception e) when(e.IsCancellation())
{
// Ignore.
}
catch (Exception e)
{
this.serviceProvider
.GetService <IExceptionDialog>()
.Show(this.window, "Generating credentials failed", e);
}
}
private void CreateReport(IProjectExplorerNode contextNode)
{
var dialog = this.serviceProvider.GetService <CreateReportDialog>();
if (contextNode is IProjectExplorerProjectNode projectNode)
{
dialog.SelectProjectId(projectNode.ProjectId);
}
var mainForm = this.serviceProvider.GetService <IMainForm>();
if (dialog.ShowDialog(mainForm.Window) == DialogResult.Cancel ||
!dialog.SelectedProjectIds.Any())
{
return;
}
var projectIds = dialog.SelectedProjectIds;
var builder = new AuditLogReportBuilder(
this.serviceProvider.GetService <IAuditLogAdapter>(),
this.serviceProvider.GetService <IComputeEngineAdapter>(),
projectIds,
dialog.SelectedStartDate);
var view = new ReportPaneView(
ReportViewModel.CreateReportName(projectIds),
builder,
serviceProvider);
view.ShowOrActivate(
mainForm.MainPanel,
WeifenLuo.WinFormsUI.Docking.DockState.Document);
}
private void CreateReport(IProjectExplorerNode contextNode)
{
var dialog = this.serviceProvider.GetService <CreateReportDialog>();
if (contextNode is IProjectExplorerProjectNode projectNode)
{
dialog.SelectProjectId(projectNode.ProjectId);
}
var mainForm = this.serviceProvider.GetService <IMainForm>();
if (dialog.ShowDialog(mainForm.Window) == DialogResult.Cancel ||
!dialog.SelectedProjectIds.Any())
{
return;
}
var projectIds = dialog.SelectedProjectIds;
var builder = new ReportBuilder(
this.serviceProvider.GetService <IAuditLogAdapter>(),
this.serviceProvider.GetService <IAuditLogStorageSinkAdapter>(),
this.serviceProvider.GetService <IComputeEngineAdapter>(),
AuditLogSources.Api | AuditLogSources.StorageExport,
projectIds,
dialog.SelectedStartDate);
var view = new ReportPaneView(
ReportViewModel.CreateReportName(projectIds),
builder,
serviceProvider);
view.ShowWindow();
}
private static CommandState GetToolbarCommandStateWhenRunningInstanceRequired(
IProjectExplorerNode node)
{
return(node is IProjectExplorerVmInstanceNode vmNode && vmNode.IsRunning
? CommandState.Enabled
: CommandState.Disabled);
}
private static CommandState GetContextMenuCommandStateWhenRunningInstanceRequired(
IProjectExplorerNode node)
{
if (node is IProjectExplorerVmInstanceNode vmNode && !vmNode.IsWindowsInstance)
{
return(vmNode.IsRunning
? CommandState.Enabled
: CommandState.Disabled);
}
public IPersistentSettingsCollection <ConnectionSettingsBase> GetConnectionSettings(
IProjectExplorerNode node)
{
if (node is IProjectExplorerProjectNode projectNode)
{
return(this.repository.GetProjectSettings(projectNode.Project.ProjectId)
.ToPersistentSettingsCollection(s => this.repository.SetProjectSettings(s)));
}
else if (node is IProjectExplorerZoneNode zoneNode)
{
var projectSettings = this.repository.GetProjectSettings(
zoneNode.Zone.ProjectId);
var zoneSettings = this.repository.GetZoneSettings(
zoneNode.Zone.ProjectId,
zoneNode.Zone.Name);
// Apply overlay to get effective settings.
return(projectSettings
.OverlayBy(zoneSettings)
.ToPersistentSettingsCollection(s => this.repository.SetZoneSettings(s)));
}
else if (node is IProjectExplorerInstanceNode vmNode)
{
var projectSettings = this.repository.GetProjectSettings(
vmNode.Instance.ProjectId);
var zoneSettings = this.repository.GetZoneSettings(
vmNode.Instance.ProjectId,
vmNode.Instance.Zone);
var instanceSettings = this.repository.GetVmInstanceSettings(
vmNode.Instance.ProjectId,
vmNode.Instance.Name);
var supportsRdp = vmNode.IsRdpSupported();
var supportsSsh = vmNode.IsSshSupported();
// Apply overlay to get effective settings.
return(projectSettings
.OverlayBy(zoneSettings)
.OverlayBy(instanceSettings)
// Save back to same repository.
.ToPersistentSettingsCollection(s => this.repository.SetVmInstanceSettings(s))
// Hide any settings that are not applicable to the operating system.
.ToFilteredSettingsCollection((coll, setting) => supportsRdp
? coll.IsRdpSetting(setting)
: supportsSsh?coll.IsSshSetting(setting) : false));
}
else
{
throw new ArgumentException("Unsupported node type: " + node.GetType().Name);
}
}
//---------------------------------------------------------------------
// ProjectExplorerTrackingToolWindow.
//---------------------------------------------------------------------
protected override Task SwitchToNodeAsync(IProjectExplorerNode node)
{
if (node is IProjectExplorerInstanceNode vmNode)
{
this.instanceNameLabel.Text = vmNode.Instance.Name;
}
else
{
// We cannot handle other types or node, so ignore.
}
return(Task.CompletedTask);
}
protected void OnProjectExplorerNodeSelected(IProjectExplorerNode node)
{
using (ApplicationTraceSources.Default.TraceMethod().WithParameters(node, this.IsUserVisible))
{
if (!this.IsUserVisible)
{
// The window is currently not visible to the user, so
// do not bother updating it immediately.
this.ignoredNode = node;
ApplicationTraceSources.Default.TraceVerbose(
"Ignoring switch to {0} because window is not visible", node);
return;
}
else
{
this.ignoredNode = null;
}
SwitchToNodeAsync(node)
.ContinueWith(t =>
{
try
{
t.Wait();
}
catch (Exception e)
{
this.exceptionDialog.Show(this, "Loading data failed", e);
}
},
CancellationToken.None,
TaskContinuationOptions.None,
// Continue on UI thread.
// Note that there's a bug in the CLR that can cause
// TaskScheduler.FromCurrentSynchronizationContext() to become null.
// Therefore, use a task scheduler object captured previously.
// Cf. https://stackoverflow.com/questions/4659257/
this.taskScheduler);
}
}
public ConnectionSettingsBase GetConnectionSettings(IProjectExplorerNode node)
{
if (node is IProjectExplorerProjectNode projectNode)
{
return(this.repository.GetProjectSettings(projectNode.ProjectId));
}
else if (node is IProjectExplorerZoneNode zoneNode)
{
var projectSettings = this.repository.GetProjectSettings(
zoneNode.ProjectId);
var zoneSettings = this.repository.GetZoneSettings(
zoneNode.ProjectId,
zoneNode.ZoneId);
// Apply overlay to get effective settings.
return(projectSettings
.OverlayBy(zoneSettings));
}
else if (node is IProjectExplorerVmInstanceNode vmNode)
{
var projectSettings = this.repository.GetProjectSettings(
vmNode.ProjectId);
var zoneSettings = this.repository.GetZoneSettings(
vmNode.ProjectId,
vmNode.ZoneId);
var instanceSettings = this.repository.GetVmInstanceSettings(
vmNode.ProjectId,
vmNode.InstanceName);
// Apply overlay to get effective settings.
return(projectSettings
.OverlayBy(zoneSettings)
.OverlayBy(instanceSettings));
}
else
{
throw new ArgumentException("Unsupported node type: " + node.GetType().Name);
}
}
public ConnectionSettingsEditor GetConnectionSettingsEditor(IProjectExplorerNode node)
{
if (node is IProjectExplorerProjectNode projectNode)
{
return(GetProjectConnectionSettingsEditor(projectNode.ProjectId));
}
else if (node is IProjectExplorerZoneNode zoneNode)
{
return(GetZoneConnectionSettingsEditor(zoneNode.ProjectId, zoneNode.ZoneId));
}
else if (node is IProjectExplorerVmInstanceNode vmNode)
{
return(GetVmInstanceConnectionSettingsEditor(
vmNode.ProjectId,
vmNode.ZoneId,
vmNode.InstanceName));
}
else
{
throw new ArgumentException("Unsupported node type: " + node.GetType().Name);
}
}
private async void Connect(IProjectExplorerNode node)
{
try
{
if (node is IProjectExplorerVmInstanceNode vmNode)
{
await this.serviceProvider
.GetService <IapRdpConnectionService>()
.ActivateOrConnectInstanceAsync(vmNode)
.ConfigureAwait(true);
}
}
catch (Exception e) when(e.IsCancellation())
{
// Ignore.
}
catch (Exception e)
{
this.serviceProvider
.GetService <IExceptionDialog>()
.Show(this.window, "Connecting to VM instance failed", e);
}
}
public void OpenLogs(IProjectExplorerNode node)
{
if (node is IProjectExplorerVmInstanceNode vmNode)
{
OpenLogs(
vmNode.ProjectId,
"resource.type=\"gce_instance\"\n" +
$"resource.labels.instance_id=\"{vmNode.InstanceId}\"");
}
else if (node is IProjectExplorerZoneNode zoneNode)
{
OpenLogs(
zoneNode.ProjectId,
"resource.type=\"gce_instance\"\n" +
$"resource.labels.zone=\"{zoneNode.ZoneId}\"");
}
else if (node is IProjectExplorerProjectNode projectNode)
{
OpenLogs(
projectNode.ProjectId,
"resource.type=\"gce_instance\"");
}
}
//---------------------------------------------------------------------
// IConnectionSettingsService.
//---------------------------------------------------------------------
public bool IsConnectionSettingsAvailable(IProjectExplorerNode node)
{
return(node is IProjectExplorerProjectNode ||
node is IProjectExplorerZoneNode ||
(node is IProjectExplorerVmInstanceNode vmNode && vmNode.IsWindowsInstance));
}
//---------------------------------------------------------------------
// Overridables.
//
// NB. These methods should be abstract, but the forms designer does not like
// abstract base classes for forms.
//---------------------------------------------------------------------
protected virtual Task SwitchToNodeAsync(IProjectExplorerNode node)
{
throw new NotImplementedException();
}
public ProjectExplorerNodeSelectedEvent(IProjectExplorerNode selectedNode)
{
this.SelectedNode = selectedNode;
}
internal ProjectExplorerNodeSelectedEvent(IProjectExplorerNode selectedNode)
{
this.SelectedNode = selectedNode;
}
public static async Task <PackageInventoryModel> LoadAsync(
IInventoryService inventoryService,
PackageInventoryType inventoryType,
IProjectExplorerNode node,
CancellationToken token)
{
IEnumerable <GuestOsInfo> inventory;
try
{
if (node is IProjectExplorerVmInstanceNode vmNode)
{
var info = await inventoryService.GetInstanceInventoryAsync(
vmNode.Reference,
token)
.ConfigureAwait(false);
inventory = info != null
? new GuestOsInfo[] { info }
: Enumerable.Empty <GuestOsInfo>();
}
else if (node is IProjectExplorerZoneNode zoneNode)
{
inventory = await inventoryService.ListZoneInventoryAsync(
new ZoneLocator(zoneNode.ProjectId, zoneNode.ZoneId),
OperatingSystems.Windows,
token)
.ConfigureAwait(false);
}
else if (node is IProjectExplorerProjectNode projectNode)
{
inventory = await inventoryService.ListProjectInventoryAsync(
projectNode.ProjectId,
OperatingSystems.Windows,
token)
.ConfigureAwait(false);
}
else
{
// Unknown/unsupported node.
return(null);
}
}
catch (Exception e) when(e.Unwrap() is GoogleApiException apiEx &&
apiEx.IsConstraintViolation())
{
//
// Reading OS inventory data can fail because of a
// `compute.disableGuestAttributesAccess` constraint.
//
TraceSources.IapDesktop.TraceWarning(
"Failed to load OS inventory data: {0}", e);
inventory = Enumerable.Empty <GuestOsInfo>();
}
return(PackageInventoryModel.FromInventory(
node.DisplayName,
inventoryType,
inventory));
}
//---------------------------------------------------------------------
// IConnectionSettingsService.
//---------------------------------------------------------------------
public bool IsConnectionSettingsAvailable(IProjectExplorerNode node)
{
return(node is IProjectExplorerProjectNode ||
node is IProjectExplorerZoneNode ||
node is IProjectExplorerInstanceNode);
}
//---------------------------------------------------------------------
// ProjectExplorerTrackingToolWindow.
//---------------------------------------------------------------------
protected override async Task SwitchToNodeAsync(IProjectExplorerNode node)
{
Debug.Assert(!InvokeRequired, "running on UI thread");
await this.viewModel.SwitchToModelAsync(node)
.ConfigureAwait(true);
}
private static CommandState GetContextMenuCommandStateWhenRunningInstanceRequired(IProjectExplorerNode node)
{
if (node is IProjectExplorerInstanceNode vmNode)
{
return(vmNode.IsRunning
? CommandState.Enabled
: CommandState.Disabled);
}
else
{
return(CommandState.Unavailable);
}
}
