private void OnStartInstanceCommand() { try { if (!UserPromptUtils.YesNoPrompt( String.Format(Resources.CloudExplorerGceStartInstanceConfirmationPrompt, Instance.Name), String.Format(Resources.CloudExplorerGceStartInstanceConfirmationPromptCaption, Instance.Name))) { Debug.WriteLine($"The user cancelled starting instance {Instance.Name}."); return; } var operation = _owner.DataSource.StartInstance(Instance); UpdateInstanceState(operation); } catch (DataSourceException ex) { GcpOutputWindow.Activate(); GcpOutputWindow.OutputLine(String.Format(Resources.CloudExplorerGceFailedToStartInstanceMessage, Instance.Name, ex.Message)); } catch (OAuthException ex) { ShowOAuthErrorDialog(ex); } }
/// <summary> /// Return a list of projects. Returns empty list if no item is found. /// </summary> private async Task <IList <Project> > GetProjectsAsync() { ResourceManagerDataSource resourceManager = DataSourceFactories.CreateResourceManagerDataSource(); if (resourceManager == null) { return(new List <Project>()); } IsReady = false; try { var projects = await resourceManager.GetSortedActiveProjectsAsync(); if (!projects.Any()) { UserPromptUtils.OkPrompt( message: Resources.CsrNoProjectMessage, title: Resources.CsrConnectSectionTitle); } return(projects); } finally { IsReady = true; } }
private bool Validate() { if (String.IsNullOrEmpty(UserName)) { UserPromptUtils.ErrorPrompt( Resources.AddWindowsCredentialValidationEmptyUser, Resources.AddWindowsCredentialValidationErrorTtitle); return(false); } var invalidChars = UserName.Intersect(UserNameInvalidChars).ToArray(); if (invalidChars.Length > 0) { UserPromptUtils.ErrorPrompt( String.Format(Resources.AddWindowsCredentialValidationInvalidChars, new string(invalidChars)), Resources.AddWindowsCredentialValidationErrorTtitle); return(false); } if (ManualPassword && String.IsNullOrEmpty(Password)) { UserPromptUtils.ErrorPrompt( Resources.AddWindowsCredentialValidationEmptyPassword, Resources.AddWindowsCredentialValidationErrorTtitle); return(false); } // Valid entry. return(true); }
/// <summary> /// This method will enable the list of services given. /// </summary> /// <param name="serviceNames">The list of services to enable.</param> /// <returns>A task that will be completed once the operation finishes.</returns> public async Task EnableServicesAsync(IEnumerable <string> serviceNames) { ServiceManagementDataSource dataSource = _dataSource.Value; if (dataSource == null) { return; } try { await ProgressDialogWindow.PromptUser( dataSource.EnableAllServicesAsync(serviceNames), new ProgressDialogWindow.Options { Title = Resources.ApiManagerEnableServicesTitle, Message = Resources.ApiManagerEnableServicesProgressMessage, IsCancellable = false }); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: Resources.ApiManagerEnableServicesErrorMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); } }
/// <summary> /// Prompts the user about deleting the subscription, then calls the datasource to delete it. /// </summary> internal async void OnDeleteSubscriptionCommand() { IsLoading = true; try { bool doDelete = UserPromptUtils.ActionPrompt( string.Format(Resources.PubSubDeleteSubscriptionWindowMessage, _subscriptionItem.Name), Resources.PubSubDeleteSubscriptionWindowHeader, actionCaption: Resources.UiDeleteButtonCaption); if (doDelete) { try { await DataSource.DeleteSubscriptionAsync(_subscriptionItem.FullName); EventsReporterWrapper.ReportEvent(PubSubSubscriptionDeletedEvent.Create(CommandStatus.Success)); } catch (DataSourceException e) { Debug.Write(e.Message, "Delete Subscription"); EventsReporterWrapper.ReportEvent(PubSubSubscriptionDeletedEvent.Create(CommandStatus.Failure)); UserPromptUtils.ErrorPrompt( Resources.PubSubDeleteSubscriptionErrorMessage, Resources.PubSubDeleteSubscriptionErrorHeader, e.Message); } await _owner.Refresh(); } } finally { IsLoading = false; } }
private void UploadFiles(IEnumerable <string> files) { try { CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var uploadOperationsQueue = _fileOperationsEngine.StartUploadOperations( files, bucket: Bucket.Name, bucketPath: _currentState.CurrentPath, cancellationToken: cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserUploadingProgressCaption, message: Resources.GcsFileBrowserUploadingProgressMessage, progressMessage: Resources.GcsFileBrowserUploadingOverallProgressMessage, operations: uploadOperationsQueue.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartUploadEvent.Create(CommandStatus.Success)); } catch (IOException ex) { UserPromptUtils.ErrorPrompt( message: Resources.GcsFileProgressDialogFailedToEnumerateFiles, title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartUploadEvent.Create(CommandStatus.Failure)); } UpdateCurrentState(); }
/// <summary> /// Prompts the user about deleting the subscription, then calls the datasource to delete it. /// </summary> private async void OnDeleteSubscriptionCommand() { IsLoading = true; try { try { bool doDelete = UserPromptUtils.ActionPrompt( string.Format(Resources.PubSubDeleteSubscriptionWindowMessage, _subscriptionItem.Name), Resources.PubSubDeleteSubscriptionWindowHeader, actionCaption: Resources.UiDeleteButtonCaption); if (doDelete) { await DataSource.DeleteSubscriptionAsync(_subscriptionItem.FullName); } } catch (DataSourceException e) { Debug.Write(e.Message, "Delete Subscription"); UserPromptUtils.ErrorPrompt( Resources.PubSubDeleteSubscriptionErrorMessage, Resources.PubSubDeleteSubscriptionErrorHeader); } await _owner.Refresh(); } finally { IsLoading = false; } }
private static void ShowOAuthErrorDialog(OAuthException ex) { Debug.WriteLine($"Failed to fetch oauth credentials: {ex.Message}"); UserPromptUtils.OkPrompt( String.Format(Resources.CloudExplorerGceFailedToGetOauthCredentialsMessage, CredentialsStore.Default.CurrentAccount.AccountName), Resources.CloudExplorerGceFailedToGetOauthCredentialsCaption); }
private void OnStartInstanceCommand() { try { if (!UserPromptUtils.ActionPrompt( String.Format(Resources.CloudExplorerGceStartInstanceConfirmationPrompt, Instance.Name), String.Format(Resources.CloudExplorerGceStartInstanceConfirmationPromptCaption, Instance.Name), actionCaption: Resources.UiStartButtonCaption)) { Debug.WriteLine($"The user cancelled starting instance {Instance.Name}."); return; } var operation = _owner.DataSource.StartInstance(Instance); UpdateInstanceState(operation); EventsReporterWrapper.ReportEvent(StartGceInstanceEvent.Create(CommandStatus.Success)); } catch (DataSourceException ex) { GcpOutputWindow.Activate(); GcpOutputWindow.OutputLine(String.Format(Resources.CloudExplorerGceFailedToStartInstanceMessage, Instance.Name, ex.Message)); EventsReporterWrapper.ReportEvent(StartGceInstanceEvent.Create(CommandStatus.Failure)); } }
/// <summary> /// Prompts the user for a new subscription, and creates it. /// </summary> internal async void OnNewSubscriptionCommand() { IsLoading = true; try { Subscription subscription = NewSubscriptionUserPrompt(Item.FullName); if (subscription != null) { try { await DataSource.NewSubscriptionAsync(subscription); EventsReporterWrapper.ReportEvent(PubSubSubscriptionCreatedEvent.Create(CommandStatus.Success)); await Refresh(); } catch (DataSourceException e) { Debug.Write(e.Message, "New Subscription"); EventsReporterWrapper.ReportEvent(PubSubSubscriptionCreatedEvent.Create(CommandStatus.Failure)); Owner.Refresh(); UserPromptUtils.ErrorPrompt( Resources.PubSubNewSubscriptionErrorMessage, Resources.PubSubNewSubscriptionErrorHeader, e.Message); } } } finally { IsLoading = false; } }
/// <summary> /// Prompts the user for a new subscription, and creates it. /// </summary> private async void OnNewSubscriptionCommand() { IsLoading = true; try { try { Subscription subscription = NewSubscriptionWindow.PromptUser(TopicItem.FullName); if (subscription != null) { await DataSource.NewSubscriptionAsync(subscription); } } catch (DataSourceException e) { Debug.Write(e.Message, "New Subscription"); UserPromptUtils.ErrorPrompt( Resources.PubSubNewSubscriptionErrorMessage, Resources.PubSubNewSubscriptionErrorHeader); } await Refresh(); } finally { IsLoading = false; } }
private bool GetAllProcessesList() { var dte = Shell.Package.GetGlobalService(typeof(DTE)) as DTE; var debugger = dte.Debugger as Debugger2; var transport = debugger.Transports.Item("Default"); // Show engine types EngineTypes = new List <string>(); EngineTypes.Add(Resources.AttachDebuggerAutomaticallyDetectEngineTypeItemName); foreach (var engineType in transport.Engines) { var engine = engineType as Engine; if (engine == null) { Debug.WriteLine("engine is null, might be a code bug."); continue; } EngineTypes.Add(engine.Name); } SelectedEngine = s_detectEngineTypeItemName; Processes processes = debugger.GetProcesses(transport, Context.PublicIp); _allProcesses = new List <ProcessItem>(); foreach (var process in processes) // Linq does not work on COM list { var pro2 = process as Process2; _allProcesses.Add(new ProcessItem(pro2)); } if (_allProcesses.Count == 0) { UserPromptUtils.ErrorPrompt( message: Resources.AttachDebuggerListProcessEmptyResultErrorMessage, title: Resources.UiDefaultPromptTitle); return(false); } if (!String.IsNullOrWhiteSpace(AttachDebuggerSettings.Current.DefaultDebuggeeProcessName)) { var matching = _allProcesses .Where(x => x.Name.ToLowerInvariant() == AttachDebuggerSettings.Current.DefaultDebuggeeProcessName.ToLowerInvariant()); if (!matching.Any()) { ResetDefaultSelection(); } else if (matching.Count() == 1) { Processes = matching; SelectedProcess = matching.First(); SelectedEngine = AttachDebuggerSettings.Current.DefaultDebuggerEngineType; return(true); } } Processes = _allProcesses; SelectedProcess = Processes.FirstOrDefault(); return(true); }
/// <summary> /// This method will check that all given services are enabled and if not will prompt the user to enable the /// necessary services. /// </summary> /// <param name="serviceNames">The services to check.</param> /// <param name="prompt">The prompt to use in the prompt dialog to ask the user for permission to enable the services.</param> /// <returns>A task that will be true if all services where enabled, false if the user cancelled or if the operation failed.</returns> public async Task <bool> EnsureAllServicesEnabledAsync( IEnumerable <string> serviceNames, string prompt) { ServiceManagementDataSource dataSource = _dataSource.Value; if (dataSource == null) { return(false); } try { // Check all services in parallel. IList <string> servicesToEnable = (await dataSource.CheckServicesStatusAsync(serviceNames)) .Where(x => !x.Enabled) .Select(x => x.Name) .ToList(); if (servicesToEnable.Count == 0) { Debug.WriteLine("All the services are already enabled."); return(true); } // Need to enable the services, prompt the user. Debug.WriteLine($"Need to enable the services: {string.Join(",", servicesToEnable)}."); if (!UserPromptUtils.ActionPrompt( prompt: prompt, title: Resources.ApiManagerEnableServicesTitle, actionCaption: Resources.UiEnableButtonCaption)) { return(false); } // Enable all services in parallel. await ProgressDialogWindow.PromptUser( dataSource.EnableAllServicesAsync(servicesToEnable), new ProgressDialogWindow.Options { Title = Resources.ApiManagerEnableServicesTitle, Message = Resources.ApiManagerEnableServicesProgressMessage, IsCancellable = false }); return(true); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: Resources.ApiManagerEnableServicesErrorMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); return(false); } }
private bool ValidateInput() { int replicas = 0; if (!int.TryParse(Replicas, out replicas)) { UserPromptUtils.ErrorPrompt(Resources.GkePublishInvalidReplicasMessage, Resources.UiInvalidValueTitle); return(false); } return(true); }
private void OnCopyCommand() { try { Clipboard.SetText(Password); } catch { Debug.WriteLine("Failed to copy the string to the clipboard."); UserPromptUtils.ErrorPrompt(Resources.ShowPasswordCopyFailedMessage, Resources.ShowPasswordCopyFailedTitle); } }
/// <summary> /// Ensures that the opt-in dialog is shown to the user. /// </summary> public static void EnsureAnalyticsOptIn() { var settings = GoogleCloudExtensionPackage.Instance.AnalyticsSettings; if (!settings.DialogShown) { Debug.WriteLine("Showing the opt-in dialog."); settings.OptIn = UserPromptUtils.YesNoPrompt(Resources.AnalyticsPromptMessage, Resources.AnalyticsPromptTitle); settings.DialogShown = true; settings.SaveSettingsToStorage(); } }
private async void OnRenameFolderCommand() { var newLeafName = NamePromptWindow.PromptUser(new NamePromptWindow.Options { InitialName = SelectedItem.LeafName, Title = Resources.GcsFileBrowserRenameFolderTitle }); if (newLeafName == null) { return; } try { IsLoading = true; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var renameDirectoryOperations = await _fileOperationsEngine.StartDirectoryRenameOperationsAsync( bucket : Bucket.Name, parentName : CurrentState.CurrentPath, oldLeafName : SelectedItem.LeafName, newLeafName : newLeafName, cancellationToken : cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserRenamingFilesCaption, message: Resources.GcsFileBrowserRenamingFilesMessage, progressMessage: Resources.GcsFileBrowserRenamingFilesProgressMessage, operations: renameDirectoryOperations.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartRenameDirectoryEvent.Create(CommandStatus.Success)); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: string.Format(Resources.GcsFileBrowserRenameFailedMessage, SelectedItem.LeafName), title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartRenameDirectoryEvent.Create(CommandStatus.Failure)); } finally { IsLoading = false; } UpdateCurrentState(); }
private void OnDeleteCredentialsCommand() { if (!UserPromptUtils.ActionPrompt( String.Format(Resources.ManageWindowsCredentialsDeleteCredentialsPromptMessage, SelectedCredentials.User), Resources.ManageWindowsCredentialsDeleteCredentialsPromptTitle, message: Resources.UiOperationCannotBeUndone, actionCaption: Resources.UiDeleteButtonCaption)) { return; } WindowsCredentialsStore.Default.DeleteCredentialsForInstance(_instance, SelectedCredentials); CredentialsList = WindowsCredentialsStore.Default.GetCredentialsForInstance(_instance); }
private static void OpenCurrentVersionProjectPrompt(string assemblyName, string assemblyVersion) { if (UserPromptUtils.ActionPrompt( prompt: String.Format(Resources.LogsViewerPleaseOpenProjectPrompt, assemblyName, assemblyVersion), title: Resources.uiDefaultPromptTitle, message: Resources.LogsViewerAskToOpenProjectMessage)) { ShellUtils.OpenProject(); } else { throw new FileNotFoundException(null); } }
private async void OnRenameFileCommand() { var choosenName = NamePromptWindow.PromptUser(new NamePromptWindow.Options { InitialName = SelectedItem.LeafName, Title = Resources.GcsFileBrowserRenameFileTitle }); if (choosenName == null) { return; } try { IsLoading = true; var newName = GcsPathUtils.Combine(CurrentState.CurrentPath, choosenName); Debug.WriteLine($"Renaming {SelectedItem.BlobName} to {newName}"); await ProgressDialogWindow.PromptUser( _dataSource.MoveFileAsync( bucket: Bucket.Name, sourceName: SelectedItem.BlobName, destName: newName), new ProgressDialogWindow.Options { Message = Resources.GcsFileBrowserRenamingProgressMessage, Title = Resources.UiDefaultPromptTitle, IsCancellable = false }); EventsReporterWrapper.ReportEvent(GcsFileBrowserRenameFileEvent.Create(CommandStatus.Success)); } catch (DataSourceException ex) { UserPromptUtils.ErrorPrompt( message: string.Format(Resources.GcsFileBrowserRenameFailedMessage, SelectedItem.LeafName), title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserRenameFileEvent.Create(CommandStatus.Failure)); } finally { IsLoading = false; } UpdateCurrentState(); }
private async void OnDownloadCommand() { FBD dialog = new FBD(); dialog.Description = Resources.GcsFileBrowserFolderSelectionMessage; dialog.ShowNewFolderButton = true; var result = dialog.ShowDialog(); if (result == System.Windows.Forms.DialogResult.Cancel) { return; } var downloadRoot = dialog.SelectedPath; try { IsLoading = true; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); var downloadOperationsQueue = await _fileOperationsEngine.StartDownloadOperationsAsync( SelectedItems.Select(x => new GcsUtils.GcsItemRef(x.Bucket, x.BlobName)), downloadRoot, cancellationTokenSource.Token); GcsFileProgressDialogWindow.PromptUser( caption: Resources.GcsFileBrowserDownloadingProgressCaption, message: Resources.GcsFileBrowserDownloadingProgressMessage, progressMessage: Resources.GcsFileBrowserDownloadingOverallProgressMessage, operations: downloadOperationsQueue.Operations, cancellationTokenSource: cancellationTokenSource); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartDownloadEvent.Create(CommandStatus.Success)); } catch (IOException ex) { UserPromptUtils.ErrorPrompt( message: Resources.GcsFileBrowserFailedToCreateDirMessage, title: Resources.UiErrorCaption, errorDetails: ex.Message); EventsReporterWrapper.ReportEvent(GcsFileBrowserStartDownloadEvent.Create(CommandStatus.Failure)); return; } finally { IsLoading = false; } }
/// <summary> /// Starts the attaching remote debugger wizard. /// </summary> /// <param name="gceInstance">A GCE windows VM <seealso cref="Instance"/> object.</param> public static void PromptUser(Instance gceInstance) { if (String.IsNullOrWhiteSpace(gceInstance.GetPublicIpAddress())) { UserPromptUtils.OkPrompt( message: StringResources.AttachDebuggerAddPublicIpAddressMessage, title: StringResources.UiDefaultPromptTitle); return; } var dialog = new AttachDebuggerWindow(gceInstance); EventsReporterWrapper.ReportEvent(RemoteDebuggerWindowOpenEvent.Create()); dialog.ShowModal(); }
private async Task <IEnumerable <string> > ListAllLocationsAsync() { try { IEnumerable <string> result = (await _dataSource.GetFlexLocationsAsync()).OrderBy(x => x); SelectedLocation = DefaultRegionName; return(result); } catch (DataSourceException ex) { UserPromptUtils.ExceptionPrompt(ex); _owner.Close(); return(Enumerable.Empty <string>()); } }
/// <summary> /// Repeatedly make list log entries request till it gets desired number of logs or it reaches end. /// _nextPageToken is used to control if it is getting first page or continuous page. /// /// On complex filters, scanning through logs take time. The server returns empty results /// with a next page token. Continue to send request till some logs are found. /// </summary> /// <param name="cancellationToken">A cancellation token. The caller can monitor the cancellation event.</param> /// <param name="autoReload">Indicate if the request comes from autoReload event.</param> private async Task LoadLogsAsync(CancellationToken cancellationToken, bool autoReload = false) { if (_logs.Count >= MaxLogEntriesCount) { UserPromptUtils.ErrorPrompt( message: Resources.LogViewerResultSetTooLargeMessage, title: Resources.UiDefaultPromptTitle); _cancellationTokenSource?.Cancel(); return; } try { var startTimestamp = DateTime.Now; var order = DateTimePickerModel.IsDescendingOrder ? "timestamp desc" : "timestamp asc"; int count = 0; while (count < DefaultPageSize && !cancellationToken.IsCancellationRequested) { Debug.WriteLine($"LoadLogs, count={count}, firstPage={_nextPageToken == null}"); // Here, it does not do pageSize: _defaultPageSize - count, // Because this is requried to use same page size for getting next page. var results = await _dataSource.Value.ListLogEntriesAsync(_filter, order, pageSize : DefaultPageSize, nextPageToken : _nextPageToken, cancelToken : cancellationToken); _nextPageToken = results.NextPageToken; if (results?.LogEntries != null) { count += results.LogEntries.Count; AddLogs(results.LogEntries, autoReload); } if (String.IsNullOrWhiteSpace(_nextPageToken)) { _nextPageToken = null; break; } } EventsReporterWrapper.ReportEvent(LogsViewerLogsLoadedEvent.Create(CommandStatus.Success, DateTime.Now - startTimestamp)); } catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex)) { EventsReporterWrapper.ReportEvent(LogsViewerLogsLoadedEvent.Create(CommandStatus.Failure)); throw; } }
/// <summary> /// Validates the input. Prompts the user on validation errors. /// </summary> /// <returns>Returns true if validation succeded, false if the user had to be prompted</returns> private bool ValidateInput() { var results = PubSubNameValidationRule.Validate(TopicName, Resources.NewTopicWindowNameFieldName); var details = String.Join("\n", results.Select(result => result.Message)); if (!String.IsNullOrEmpty(details)) { string message = String.Format(Resources.PubSubNewTopicNameInvalidMessage, TopicName); UserPromptUtils.ErrorPrompt(message, Resources.PubSubNewTopicNameInvalidTitle, details); return(false); } else { return(true); } }
private void OnDeleteAccountCommand() { Debug.WriteLine($"Attempting to delete account: {CurrentAccountName}"); if (!UserPromptUtils.ActionPrompt( String.Format(Resources.ManageAccountsDeleteAccountPromptMessage, CurrentAccountName), Resources.ManageAccountsDeleteAccountPromptTitle, actionCaption: Resources.UiDeleteButtonCaption)) { Debug.WriteLine($"The user cancelled the deletion of the account."); return; } AccountsManager.DeleteAccount(CurrentUserAccount.UserAccount); // Refreshing everything. UserAccountsList = LoadUserCredentialsViewModel(); }
private bool Validate() { if (String.IsNullOrEmpty(Name)) { UserPromptUtils.ErrorPrompt(Resources.NamePromptEmptyNameMessage, Resources.UiErrorCaption); return(false); } if (Name.Contains('/')) { UserPromptUtils.ErrorPrompt(Resources.NamePromptInvalidCharsMessage, Resources.UiErrorCaption); return(false); } return(true); }
private async Task <WindowsInstanceCredentials> CreateOrResetCredentials(string user) { try { Debug.WriteLine("The user requested the password to be generated."); if (!UserPromptUtils.ActionPrompt( prompt: String.Format(Resources.ResetPasswordConfirmationPromptMessage, user, _instance.Name), title: Resources.ResetPasswordConfirmationPromptTitle, message: Resources.UiOperationCannotBeUndone, actionCaption: Resources.UiResetButtonCaption, isWarning: true)) { Debug.WriteLine("The user cancelled resetting the password."); return(null); } Debug.WriteLine($"Resetting the password for the user {user}"); // Check that gcloud is in the right state to invoke the reset credentials method. if (!await VerifyGCloudDependencies()) { Debug.WriteLine("Missing gcloud dependencies for resetting password."); return(null); } var context = new GCloudContext { CredentialsPath = CredentialsStore.Default.CurrentAccountPath, ProjectId = CredentialsStore.Default.CurrentProjectId, AppName = GoogleCloudExtensionPackage.ApplicationName, AppVersion = GoogleCloudExtensionPackage.ApplicationVersion, }; return(await GCloudWrapper.ResetWindowsCredentialsAsync( instanceName : _instance.Name, zoneName : _instance.GetZoneName(), userName : user, context : context)); } catch (GCloudException ex) { UserPromptUtils.ErrorPrompt( message: String.Format(Resources.ResetPasswordFailedPromptMessage, _instance.Name), title: Resources.ResetPasswordConfirmationPromptTitle, errorDetails: ex.Message); return(null); } }
/// <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> private void OnGenerateConfiguration(object sender, EventArgs e) { ErrorHandlerUtils.HandleExceptions(() => { var selectedProject = SolutionHelper.CurrentSolution.SelectedProject; Debug.WriteLine($"Generating configuration for project: {selectedProject.FullPath}"); var configurationStatus = AppEngineFlexDeployment.CheckProjectConfiguration(selectedProject); // If the app.yaml already exists allow the user to skip its generation to preserve the existing file. if (!configurationStatus.HasAppYaml || UserPromptUtils.ActionPrompt( prompt: Resources.GenerateConfigurationAppYamlOverwriteMessage, title: Resources.GenerateConfigurationOverwritePromptTitle, actionCaption: Resources.UiOverwriteButtonCaption, cancelCaption: Resources.UiSkipFileButtonCaption)) { Debug.WriteLine($"Generating app.yaml for {selectedProject.FullPath}"); if (!AppEngineFlexDeployment.GenerateAppYaml(selectedProject)) { UserPromptUtils.ErrorPrompt( String.Format(Resources.GenerateConfigurationFileGenerationErrorMessage, AppEngineFlexDeployment.AppYamlName), Resources.GenerateConfigurationFileGeneratinErrorTitle); return; } GcpOutputWindow.OutputLine(Resources.GenerateConfigurationAppYamlGeneratedMessage); } // If the Dockerfile already exists allow the user to skip its generation to preserve the existing file. if (!configurationStatus.HasDockerfile || UserPromptUtils.ActionPrompt( prompt: Resources.GenerateConfigurationDockerfileOverwriteMessage, title: Resources.GenerateConfigurationOverwritePromptTitle, actionCaption: Resources.UiOverwriteButtonCaption, cancelCaption: Resources.UiSkipFileButtonCaption)) { Debug.WriteLine($"Generating Dockerfile for {selectedProject.FullPath}"); if (!AppEngineFlexDeployment.GenerateDockerfile(selectedProject)) { UserPromptUtils.ErrorPrompt( String.Format(Resources.GenerateConfigurationFileGenerationErrorMessage, AppEngineFlexDeployment.DockerfileName), Resources.GenerateConfigurationFileGeneratinErrorTitle); return; } GcpOutputWindow.OutputLine(Resources.GenerateConfigurationDockerfileGeneratedMessage); } }); }
private bool ValidateInput() { if (String.IsNullOrEmpty(Version)) { UserPromptUtils.ErrorPrompt(Resources.FlexPublishEmptyVersionMessage, Resources.UiInvalidValueTitle); return(false); } if (!GcpPublishStepsUtils.IsValidName(Version)) { UserPromptUtils.ErrorPrompt( String.Format(Resources.FlexPublishInvalidVersionMessage, Version), Resources.UiInvalidValueTitle); return(false); } return(true); }