/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="token"></param>
public static async Task InitializeAsync(IGoogleCloudExtensionPackage package, CancellationToken token)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (await package.GetServiceAsync(typeof(IMenuCommandService)) is OleMenuCommandService commandService)
{
await package.JoinableTaskFactory.SwitchToMainThreadAsync(token);
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(OnDeployCommand, menuCommandID);
menuItem.BeforeQueryStatus += OnBeforeQueryStatus;
commandService.AddCommand(menuItem);
}
// <summary>
// This function is the callback used to execute the command when the menu item is clicked.
// See the constructor to see how the menu item is associated with this function using
// OleMenuCommandService service and MenuCommand class.
// </summary>
// <param name="sender">Event sender.</param>
// <param name="e">Event args.</param>
async void OnDeployCommand(object sender, EventArgs e)
{
await GoogleCloudExtensionPackage.Instance.JoinableTaskFactory.SwitchToMainThreadAsync();
IParsedDteProject project = SolutionHelper.CurrentSolution.StartupProject.ParsedProject;
PublishDialogWindow.PromptUser(project);
}
void OnBeforeQueryStatus(object sender, EventArgs e)
{
#pragma warning disable VSTHRD109 // Switch instead of assert in async methods
ThreadHelper.ThrowIfNotOnUIThread();
#pragma warning restore VSTHRD109 // Switch instead of assert in async methods
if (!(sender is OleMenuCommand menuCommand))
{
return;
}
menuCommand.Visible = true;
IParsedDteProject startupProject = SolutionHelper.CurrentSolution.StartupProject?.ParsedProject;
if (startupProject == null)
{
menuCommand.Enabled = false;
menuCommand.Text = Resources.PublishDialogGenericMenuHeader;
}
else
{
menuCommand.Enabled =
PublishDialogWindow.CanPublish(startupProject) && !ShellUtils.Default.IsBusy();
menuCommand.Text = string.Format(Resources.PublishDialogProjectMenuHeader, startupProject.Name);
}
}
}
/// <summary>
/// Initializes a new instance of <seealso cref="ErrorReportingDetailViewModel"/> class.
/// </summary>
public ErrorReportingDetailViewModel()
{
_package = GoogleCloudExtensionPackage.Instance;
IsVisibleUnbound = true;
OnGotoSourceCommand = new ProtectedCommand <StackFrame>(frame => ErrorFrameToSourceLine(GroupItem, frame));
OnBackToOverViewCommand = new ProtectedAsyncCommand(async() => await ShowErrorReportingToolWindow());
OnAutoReloadCommand = new ProtectedCommand(() => ErrorHandlerUtils.HandleExceptionsAsync(UpdateGroupAndEventAsync));
_datasource = new Lazy <IStackdriverErrorReportingDataSource>(CreateDataSource);
CredentialsStore.Default.CurrentProjectIdChanged += OnCurrentProjectChanged;
}
/// <summary>
/// Create a new instance of <seealso cref="ErrorReportingViewModel"/> class.
/// </summary>
public ErrorReportingViewModel()
{
IsVisibleUnbound = true;
_package = GoogleCloudExtensionPackage.Instance;
_dataSourceLazy = new Lazy <IStackdriverErrorReportingDataSource>(CreateDataSource);
_groupStatsCollection = new ObservableCollection <ErrorGroupItem>();
GroupStatsView = new ListCollectionView(_groupStatsCollection);
SelectedTimeRangeItem = TimeRangeItemList.Last();
OnGotoDetailCommand = new ProtectedAsyncCommand <ErrorGroupItem>(NavigateToDetailWindowAsync);
OnAutoReloadCommand = new ProtectedCommand(Reload);
CredentialsStore.Default.CurrentProjectIdChanged += (sender, e) => OnProjectIdChanged();
}
/// <summary>
/// Ensures that the opt-in dialog is shown to the user.
/// </summary>
public static void EnsureAnalyticsOptIn()
{
IGoogleCloudExtensionPackage package = GoogleCloudExtensionPackage.Instance;
AnalyticsOptions settings = package.GeneralSettings;
if (!settings.DialogShown)
{
Debug.WriteLine("Showing the opt-in dialog.");
settings.OptIn = package.UserPromptService.PromptUser(new AnalyticsOptInWindowContent());
settings.DialogShown = true;
settings.SaveSettingsToStorage();
}
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="token"></param>
public static async Task InitializeAsync(IGoogleCloudExtensionPackage package, CancellationToken token)
{
package.ThrowIfNull(nameof(package));
if (await package.GetServiceAsync(typeof(IMenuCommandService)) is IMenuCommandService commandService)
{
await package.JoinableTaskFactory.SwitchToMainThreadAsync(token);
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(OnGenerateConfiguration, menuCommandID);
menuItem.BeforeQueryStatus += OnBeforeQueryStatus;
commandService.AddCommand(menuItem);
}
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="token">The token to cancel adding the command.</param>
public static async Task InitializeAsync(IGoogleCloudExtensionPackage package, CancellationToken token)
{
package.ThrowIfNull(nameof(package));
if (await package.GetServiceAsync(typeof(IMenuCommandService)) is IMenuCommandService commandService)
{
await package.JoinableTaskFactory.SwitchToMainThreadAsync(token);
var menuItem = new OleMenuCommand(
(sender, e) => package.JoinableTaskFactory.Run(ToolWindowCommandUtils.AddToolWindowAsync <LogsViewerToolWindow>),
MenuCommandID);
menuItem.BeforeQueryStatus += ToolWindowCommandUtils.EnableMenuItemOnValidProjectId;
commandService.AddCommand(menuItem);
}
}
public static void InitializeAssembly(TestContext context)
{
// This fixes some odd unit test errors loading Microsoft.VisualStudio.Utilities
// see: https://ci.appveyor.com/project/GoogleCloudPlatform/google-cloud-visualstudio/build/2.0.0-dev.135/tests
new Mock <ISettingsManager>().Setup(m => m.GetSubset(It.IsAny <string>()))
.Returns(Mock.Of <ISettingsSubset>());
EventsReporterWrapper.DisableReporting();
s_packageToRestore = GoogleCloudExtensionPackage.Instance;
GoogleCloudExtensionPackage.Instance = null;
// Enable pack URIs.
Assert.AreEqual(new Application {
ShutdownMode = ShutdownMode.OnExplicitShutdown
}, Application.Current);
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="token">The cancellation token.</param>
public static async Task InitializeAsync(IGoogleCloudExtensionPackage package, CancellationToken token)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
if (await package.GetServiceAsync(typeof(IMenuCommandService)) is OleMenuCommandService commandService)
{
await package.JoinableTaskFactory.SwitchToMainThreadAsync(token);
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new MenuCommand(ShowToolWindow, menuCommandID);
commandService.AddCommand(menuItem);
}
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="token">The cancellation token.</param>
public static async Task InitializeAsync(IGoogleCloudExtensionPackage package, CancellationToken token)
{
object menuCommandService = await package.GetServiceAsync(typeof(IMenuCommandService));
await package.JoinableTaskFactory.SwitchToMainThreadAsync(token);
if (menuCommandService is OleMenuCommandService commandService)
{
var menuCommandID = new CommandID(s_commandSet, CommandId);
var menuItem = new MenuCommand(ShowToolWindow, menuCommandID);
commandService.AddCommand(menuItem);
}
// <summary>
// Shows the tool window when the menu item is clicked.
// </summary>
// <param name="sender">The event sender.</param>
// <param name="e">The event args.</param>
void ShowToolWindow(object sender, EventArgs e)
{
EventsReporterWrapper.EnsureAnalyticsOptIn();
ErrorHandlerUtils.HandleExceptionsAsync(ShowToolWindowAsync);
}
async Task ShowToolWindowAsync()
{
// Get the instance number 0 of this tool window. This window is single instance so this instance
// is actually the only one.
// The last flag is set to true so that if the tool window does not exists it will be created.
var window = package.FindToolWindow <CloudExplorerToolWindow>(true);
if (window?.Frame == null)
{
throw new NotSupportedException("Cannot create tool window");
}
await package.JoinableTaskFactory.SwitchToMainThreadAsync();
var windowFrame = (IVsWindowFrame)window.Frame;
Microsoft.VisualStudio.ErrorHandler.ThrowOnFailure(windowFrame.Show());
}
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override void Initialize()
{
base.Initialize();
// An remember the package.
Instance = this;
// Register the command handlers.
CloudExplorerCommand.Initialize(this);
ManageAccountsCommand.Initialize(this);
PublishProjectMainMenuCommand.Initialize(this);
PublishProjectContextMenuCommand.Initialize(this);
LogsViewerToolWindowCommand.Initialize(this);
GenerateConfigurationContextMenuCommand.Initialize(this);
ErrorReportingToolWindowCommand.Initialize(this);
// Activity log utils, to aid in debugging.
ActivityLogUtils.Initialize(this);
ActivityLogUtils.LogInfo("Starting Google Cloud Tools.");
_dteInstance = (DTE)GetService(typeof(DTE));
VsVersion = _dteInstance.Version;
VsEdition = _dteInstance.Edition;
// Update the installation status of the package.
CheckInstallationStatus();
// Ensure the commands UI state is updated when the GCP project changes.
CredentialsStore.Default.Reset += (o, e) => ShellUtils.InvalidateCommandsState();
CredentialsStore.Default.CurrentProjectIdChanged += (o, e) => ShellUtils.InvalidateCommandsState();
// With this setting we allow more concurrent connections from each HttpClient instance created
// in the process. This will allow all GCP API services to have more concurrent connections with
// GCP servers. The first benefit of this is that we can upload more concurrent files to GCS.
ServicePointManager.DefaultConnectionLimit = MaximumConcurrentConnections;
ExportProvider mefExportProvider = GetService <SComponentModel, IComponentModel>().DefaultExportProvider;
_shellUtilsLazy = mefExportProvider.GetExport <IShellUtils>();
_gcpOutputWindowLazy = mefExportProvider.GetExport <IGcpOutputWindow>();
_processService = mefExportProvider.GetExport <IProcessService>();
_statusbarService = mefExportProvider.GetExport <IStatusbarService>();
_userPromptService = mefExportProvider.GetExport <IUserPromptService>();
}
/// <summary>
/// Initializes a new instance of the <see cref="LogsViewerToolWindowCommand"/> class.
/// Adds our command handlers for menu (commands must exist in the command table file)
/// </summary>
/// <param name="package">Owner package, not null.</param>
private LogsViewerToolWindowCommand(IGoogleCloudExtensionPackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
_package = package;
var commandService = ServiceProvider.GetService(typeof(IMenuCommandService)) as IMenuCommandService;
if (commandService != null)
{
var menuItem = new OleMenuCommand(
(sender, e) => ToolWindowCommandUtils.AddToolWindow <LogsViewerToolWindow>(), MenuCommandID);
menuItem.BeforeQueryStatus += ToolWindowCommandUtils.EnableMenuItemOnValidProjectId;
commandService.AddCommand(menuItem);
}
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
/// <param name="token">The token to cancel adding the command.</param>
public static async Task InitializeAsync(IGoogleCloudExtensionPackage package, CancellationToken token)
{
package.ThrowIfNull(nameof(package));
IMenuCommandService commandService =
await package.GetServiceAsync <IMenuCommandService, IMenuCommandService>();
await package.JoinableTaskFactory.SwitchToMainThreadAsync(token);
var menuCommandID = new CommandID(CommandSet, CommandId);
var menuItem = new OleMenuCommand(
async(sender, e) =>
{
await ToolWindowCommandUtils.ShowToolWindowAsync <ErrorReportingToolWindow>();
EventsReporterWrapper.ReportEvent(ErrorsViewerOpenEvent.Create());
},
menuCommandID);
menuItem.BeforeQueryStatus += ToolWindowCommandUtils.EnableMenuItemOnValidProjectId;
commandService.AddCommand(menuItem);
}
/// <summary>
/// Initializes an instance of <seealso cref="LogsViewerViewModel"/> class.
/// </summary>
/// <param name="toolWindowIdNumber"></param>
public LogsViewerViewModel(int toolWindowIdNumber)
{
IsVisibleUnbound = true;
_package = GoogleCloudExtensionPackage.Instance;
_toolWindowIdNumber = toolWindowIdNumber;
RefreshCommand = new ProtectedCommand(OnRefreshCommand);
LogItemCollection = new ListCollectionView(_logs);
LogItemCollection.GroupDescriptions.Add(new PropertyGroupDescription(nameof(LogItem.Date)));
CancelRequestCommand = new ProtectedCommand(CancelRequest);
SimpleTextSearchCommand = new ProtectedCommand(() =>
{
EventsReporterWrapper.ReportEvent(LogsViewerSimpleTextSearchEvent.Create());
AsyncAction = new AsyncProperty(ReloadAsync());
});
FilterSwitchCommand = new ProtectedCommand(SwapFilter);
SubmitAdvancedFilterCommand = new ProtectedCommand(() =>
{
EventsReporterWrapper.ReportEvent(LogsViewerAdvancedFilterEvent.Create());
AsyncAction = new AsyncProperty(ReloadAsync());
});
AdvancedFilterHelpCommand = new ProtectedCommand(ShowAdvancedFilterHelp);
DateTimePickerModel = new DateTimePickerViewModel(
TimeZoneInfo.Local, DateTime.UtcNow, isDescendingOrder: true);
DateTimePickerModel.DateTimeFilterChange += (sender, e) => AsyncAction = new AsyncProperty(ReloadAsync());
ResourceTypeSelector = new ResourceTypeMenuViewModel(() => DataSource);
ResourceTypeSelector.PropertyChanged += (sender, args) =>
{
if (args.PropertyName == null ||
args.PropertyName == nameof(ResourceTypeMenuViewModel.SelectedMenuItem))
{
LogIdList = null;
AsyncAction = new AsyncProperty(ReloadAsync());
}
};
OnDetailTreeNodeFilterCommand = new ProtectedAsyncCommand <ObjectNodeTree>(FilterOnTreeNodeValueAsync);
OnAutoReloadCommand = new ProtectedCommand(AutoReload);
}
/// <summary>
/// Initializes the singleton instance of the command.
/// </summary>
/// <param name="package">Owner package, not null.</param>
public static void Initialize(IGoogleCloudExtensionPackage package)
{
Instance = new LogsViewerToolWindowCommand(package);
}
