private static CommandState GetToolbarCommandStateWhenRunningInstanceRequired(
IProjectModelNode node)
{
return(node is IProjectModelInstanceNode vmNode && vmNode.IsRunning
? CommandState.Enabled
: CommandState.Disabled);
}
private void CreateReport(IProjectModelNode contextNode)
{
var dialog = this.serviceProvider.GetService <CreateReportDialog>();
if (contextNode is IProjectModelProjectNode projectNode)
{
dialog.SelectProjectId(projectNode.Project.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();
}
public IPersistentSettingsCollection <ConnectionSettingsBase> GetConnectionSettings(
IProjectModelNode node)
{
if (node is IProjectModelProjectNode projectNode)
{
return(this.repository.GetProjectSettings(projectNode.Project.ProjectId)
.ToPersistentSettingsCollection(s => this.repository.SetProjectSettings(s)));
}
else if (node is IProjectModelZoneNode 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 IProjectModelInstanceNode 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(IProjectModelNode node)
{
if (node is IProjectModelInstanceNode vmNode)
{
this.instanceNameLabel.Text = vmNode.Instance.Name;
}
else
{
// We cannot handle other types or node, so ignore.
}
return(Task.CompletedTask);
}
protected void OnProjectExplorerNodeSelected(IProjectModelNode 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 Task SetActiveNodeAsync(
IProjectModelNode node,
CancellationToken token)
{
if (node is IProjectModelInstanceNode instanceNode)
{
return(SetActiveNodeAsync(instanceNode.Instance, token));
}
else if (node is IProjectModelZoneNode zoneNode)
{
return(SetActiveNodeAsync(zoneNode.Zone, token));
}
else if (node is IProjectModelProjectNode projectNode)
{
return(SetActiveNodeAsync(projectNode.Project, token));
}
else
{
return(SetActiveNodeAsync((ResourceLocator)null, token));
}
}
public void OpenLogs(IProjectModelNode node)
{
if (node is IProjectModelInstanceNode vmNode)
{
OpenLogs(
vmNode.Instance.ProjectId,
"resource.type=\"gce_instance\"\n" +
$"resource.labels.instance_id=\"{vmNode.InstanceId}\"");
}
else if (node is IProjectModelZoneNode zoneNode)
{
OpenLogs(
zoneNode.Zone.ProjectId,
"resource.type=\"gce_instance\"\n" +
$"resource.labels.zone=\"{zoneNode.Zone.Name}\"");
}
else if (node is IProjectModelProjectNode projectNode)
{
OpenLogs(
projectNode.Project.ProjectId,
"resource.type=\"gce_instance\"");
}
}
protected override async Task SwitchToNodeAsync(IProjectModelNode node)
{
Debug.Assert(!InvokeRequired, "running on UI thread");
await this.viewModel.SwitchToModelAsync(node)
.ConfigureAwait(true);
}
public static async Task <PackageInventoryModel> LoadAsync(
IInventoryService inventoryService,
PackageInventoryType inventoryType,
IProjectModelNode node,
CancellationToken token)
{
IEnumerable <GuestOsInfo> inventory;
try
{
if (node is IProjectModelInstanceNode vmNode)
{
var info = await inventoryService.GetInstanceInventoryAsync(
vmNode.Instance,
token)
.ConfigureAwait(false);
inventory = info != null
? new GuestOsInfo[] { info }
: Enumerable.Empty <GuestOsInfo>();
}
else if (node is IProjectModelZoneNode zoneNode)
{
inventory = await inventoryService.ListZoneInventoryAsync(
new ZoneLocator(zoneNode.Zone.ProjectId, zoneNode.Zone.Name),
OperatingSystems.Windows,
token)
.ConfigureAwait(false);
}
else if (node is IProjectModelProjectNode projectNode)
{
inventory = await inventoryService.ListProjectInventoryAsync(
projectNode.Project.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.
//
ApplicationTraceSources.Default.TraceWarning(
"Failed to load OS inventory data: {0}", e);
inventory = Enumerable.Empty <GuestOsInfo>();
}
return(PackageInventoryModel.FromInventory(
node.DisplayName,
inventoryType,
inventory));
}
//---------------------------------------------------------------------
// Overridables.
//
// NB. These methods should be abstract, but the forms designer does not like
// abstract base classes for forms.
//---------------------------------------------------------------------
protected virtual Task SwitchToNodeAsync(IProjectModelNode node)
{
throw new NotImplementedException();
}
private static CommandState GetContextMenuCommandStateWhenRunningWindowsInstanceRequired(IProjectModelNode node)
{
if (node is IProjectModelInstanceNode vmNode && vmNode.IsWindowsInstance())
{
return(vmNode.IsRunning
? CommandState.Enabled
: CommandState.Disabled);
}
private static CommandState GetContextMenuCommandStateWhenRunningInstanceRequired(IProjectModelNode node)
{
if (node is IProjectModelInstanceNode vmNode)
{
return(vmNode.IsRunning
? CommandState.Enabled
: CommandState.Disabled);
}
else
{
return(CommandState.Unavailable);
}
}
//---------------------------------------------------------------------
// IConnectionSettingsService.
//---------------------------------------------------------------------
public bool IsConnectionSettingsAvailable(IProjectModelNode node)
{
return(node is IProjectModelProjectNode ||
node is IProjectModelZoneNode ||
node is IProjectModelInstanceNode);
}
internal ActiveProjectChangedEvent(IProjectModelNode activeNode)
{
this.ActiveNode = activeNode;
}
