public void BeforeEach()
{
_vsStatusbarMock = new Mock <IVsStatusbar>();
var serviceProvierMock = new Mock <SVsServiceProvider>();
serviceProvierMock.Setup(sp => sp.GetService(typeof(SVsStatusbar))).Returns(_vsStatusbarMock.Object);
_objectUnderTest = new StatusbarHelper(serviceProvierMock.ToLazy());
}
public override async void Publish()
{
var context = new Context
{
CredentialsPath = CredentialsStore.Default.CurrentAccountPath,
ProjectId = CredentialsStore.Default.CurrentProjectId,
AppName = GoogleCloudExtensionPackage.ApplicationName,
AppVersion = GoogleCloudExtensionPackage.ApplicationVersion,
};
var options = new NetCoreDeployment.DeploymentOptions
{
Version = Version,
Promote = Promote,
Context = context
};
var project = _publishDialog.Project;
GcpOutputWindow.Activate();
GcpOutputWindow.Clear();
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishStepStartMessage, project.Name));
_publishDialog.FinishFlow();
NetCorePublishResult result;
using (var frozen = StatusbarHelper.Freeze())
using (var animationShown = StatusbarHelper.ShowDeployAnimation())
using (var progress = StatusbarHelper.ShowProgressBar(Resources.FlexPublishProgressMessage))
using (var deployingOperation = ShellUtils.SetShellUIBusy())
{
result = await NetCoreDeployment.PublishProjectAsync(
project.FullPath,
options,
progress,
GcpOutputWindow.OutputLine);
}
if (result != null)
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishSuccessMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishSuccessStatusMessage);
var url = result.GetDeploymentUrl();
GcpOutputWindow.OutputLine(String.Format(Resources.PublishUrlMessage, url));
if (OpenWebsite)
{
Process.Start(url);
}
}
else
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
}
}
public override async void Publish()
{
var project = _publishDialog.Project;
try
{
ShellUtils.SaveAllFiles();
GcpOutputWindow.Activate();
GcpOutputWindow.Clear();
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishStepStartMessage, project.Name));
_publishDialog.FinishFlow();
bool result;
using (var frozen = StatusbarHelper.Freeze())
using (var animationShown = StatusbarHelper.ShowDeployAnimation())
using (var progress = StatusbarHelper.ShowProgressBar(String.Format(Resources.GcePublishProgressMessage, SelectedInstance.Name)))
using (var deployingOperation = ShellUtils.SetShellUIBusy())
{
result = await WindowsVmDeployment.PublishProjectAsync(
project.FullPath,
SelectedInstance,
SelectedCredentials,
progress,
(l) => GcpOutputWindow.OutputLine(l));
}
if (result)
{
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishSuccessMessage, project.Name, SelectedInstance.Name));
StatusbarHelper.SetText(Resources.PublishSuccessStatusMessage);
var url = SelectedInstance.GetDestinationAppUri();
GcpOutputWindow.OutputLine(String.Format(Resources.PublishUrlMessage, url));
if (OpenWebsite)
{
Process.Start(url);
}
}
else
{
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
}
}
catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex))
{
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
}
}
public override async void Publish()
{
if (!ValidateInput())
{
Debug.WriteLine("Invalid input cancelled the operation.");
return;
}
var project = _publishDialog.Project;
try
{
ShellUtils.SaveAllFiles();
var context = new GCloudContext
{
CredentialsPath = CredentialsStore.Default.CurrentAccountPath,
ProjectId = CredentialsStore.Default.CurrentProjectId,
AppName = GoogleCloudExtensionPackage.ApplicationName,
AppVersion = GoogleCloudExtensionPackage.ApplicationVersion,
};
var options = new AppEngineFlexDeployment.DeploymentOptions
{
Version = Version,
Promote = Promote,
Context = context
};
GcpOutputWindow.Activate();
GcpOutputWindow.Clear();
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishStepStartMessage, project.Name));
_publishDialog.FinishFlow();
AppEngineFlexDeploymentResult result;
using (var frozen = StatusbarHelper.Freeze())
using (var animationShown = StatusbarHelper.ShowDeployAnimation())
using (var progress = StatusbarHelper.ShowProgressBar(Resources.FlexPublishProgressMessage))
using (var deployingOperation = ShellUtils.SetShellUIBusy())
{
result = await AppEngineFlexDeployment.PublishProjectAsync(
project.FullPath,
options,
progress,
GcpOutputWindow.OutputLine);
}
if (result != null)
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishSuccessMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishSuccessStatusMessage);
var url = result.GetDeploymentUrl();
GcpOutputWindow.OutputLine(String.Format(Resources.PublishUrlMessage, url));
if (OpenWebsite)
{
Process.Start(url);
}
}
else
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
}
}
catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex))
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
}
}
/// <summary>
/// Start the publish operation.
/// </summary>
public override async void Publish()
{
if (!ValidateInput())
{
Debug.WriteLine("Invalid input cancelled the operation.");
return;
}
var project = _publishDialog.Project;
try
{
var verifyGCloudTask = VerifyGCloudDependencies();
_publishDialog.TrackTask(verifyGCloudTask);
if (!await verifyGCloudTask)
{
Debug.WriteLine("Aborting deployment, no kubectl was found.");
return;
}
var gcloudContext = new GCloudContext
{
CredentialsPath = CredentialsStore.Default.CurrentAccountPath,
ProjectId = CredentialsStore.Default.CurrentProjectId,
AppName = GoogleCloudExtensionPackage.ApplicationName,
AppVersion = GoogleCloudExtensionPackage.ApplicationVersion,
};
var kubectlContextTask = GCloudWrapper.GetKubectlContextForClusterAsync(
cluster: SelectedCluster.Name,
zone: SelectedCluster.Zone,
context: gcloudContext);
_publishDialog.TrackTask(kubectlContextTask);
using (var kubectlContext = await kubectlContextTask)
{
var deploymentExistsTask = KubectlWrapper.DeploymentExistsAsync(DeploymentName, kubectlContext);
_publishDialog.TrackTask(deploymentExistsTask);
if (await deploymentExistsTask)
{
if (!UserPromptUtils.ActionPrompt(
String.Format(Resources.GkePublishDeploymentAlreadyExistsMessage, DeploymentName),
Resources.GkePublishDeploymentAlreadyExistsTitle,
actionCaption: Resources.UiUpdateButtonCaption))
{
return;
}
}
var options = new GkeDeployment.DeploymentOptions
{
Cluster = SelectedCluster.Name,
Zone = SelectedCluster.Zone,
DeploymentName = DeploymentName,
DeploymentVersion = DeploymentVersion,
ExposeService = ExposeService,
GCloudContext = gcloudContext,
KubectlContext = kubectlContext,
Replicas = int.Parse(Replicas),
WaitingForServiceIpCallback = () => GcpOutputWindow.OutputLine(Resources.GkePublishWaitingForServiceIpMessage)
};
GcpOutputWindow.Activate();
GcpOutputWindow.Clear();
GcpOutputWindow.OutputLine(String.Format(Resources.GkePublishDeployingToGkeMessage, project.Name));
_publishDialog.FinishFlow();
GkeDeploymentResult result;
using (var frozen = StatusbarHelper.Freeze())
using (var animationShown = StatusbarHelper.ShowDeployAnimation())
using (var progress = StatusbarHelper.ShowProgressBar(Resources.GkePublishDeploymentStatusMessage))
using (var deployingOperation = ShellUtils.SetShellUIBusy())
{
result = await GkeDeployment.PublishProjectAsync(
project.FullPath,
options,
progress,
GcpOutputWindow.OutputLine);
}
if (result != null)
{
GcpOutputWindow.OutputLine(String.Format(Resources.GkePublishDeploymentSuccessMessage, project.Name));
if (result.DeploymentUpdated)
{
GcpOutputWindow.OutputLine(String.Format(Resources.GkePublishDeploymentUpdatedMessage, options.DeploymentName));
}
if (result.DeploymentScaled)
{
GcpOutputWindow.OutputLine(String.Format(Resources.GkePublishDeploymentScaledMessage, options.DeploymentName, options.Replicas));
}
if (result.WasExposed)
{
if (result.ServiceIpAddress != null)
{
GcpOutputWindow.OutputLine(
String.Format(Resources.GkePublishServiceIpMessage, DeploymentName, result.ServiceIpAddress));
}
else
{
GcpOutputWindow.OutputLine(Resources.GkePublishServiceIpTimeoutMessage);
}
}
StatusbarHelper.SetText(Resources.PublishSuccessStatusMessage);
if (OpenWebsite && result.WasExposed && result.ServiceIpAddress != null)
{
Process.Start($"http://{result.ServiceIpAddress}");
}
}
else
{
GcpOutputWindow.OutputLine(String.Format(Resources.GkePublishDeploymentFailureMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
}
}
}
catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex))
{
GcpOutputWindow.OutputLine(String.Format(Resources.GkePublishDeploymentFailureMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
_publishDialog.FinishFlow();
}
}
public override async void Publish()
{
if (!ValidateInput())
{
Debug.WriteLine("Invalid input cancelled the operation.");
return;
}
var project = _publishDialog.Project;
try
{
var verifyGcloudTask = GCloudWrapperUtils.VerifyGCloudDependencies("beta");
_publishDialog.TrackTask(verifyGcloudTask);
if (!await verifyGcloudTask)
{
Debug.WriteLine("Gcloud dependencies not met, aborting publish operation.");
return;
}
ShellUtils.SaveAllFiles();
var context = new GCloudContext
{
CredentialsPath = CredentialsStore.Default.CurrentAccountPath,
ProjectId = CredentialsStore.Default.CurrentProjectId,
AppName = GoogleCloudExtensionPackage.ApplicationName,
AppVersion = GoogleCloudExtensionPackage.ApplicationVersion,
};
var options = new AppEngineFlexDeployment.DeploymentOptions
{
Version = Version,
Promote = Promote,
Context = context
};
GcpOutputWindow.Activate();
GcpOutputWindow.Clear();
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishStepStartMessage, project.Name));
_publishDialog.FinishFlow();
TimeSpan deploymentDuration;
AppEngineFlexDeploymentResult result;
using (StatusbarHelper.Freeze())
using (StatusbarHelper.ShowDeployAnimation())
using (var progress = StatusbarHelper.ShowProgressBar(Resources.FlexPublishProgressMessage))
using (ShellUtils.SetShellUIBusy())
{
var startDeploymentTime = DateTime.Now;
result = await AppEngineFlexDeployment.PublishProjectAsync(
project,
options,
progress,
VsVersionUtils.ToolsPathProvider,
GcpOutputWindow.OutputLine);
deploymentDuration = DateTime.Now - startDeploymentTime;
}
if (result != null)
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishSuccessMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishSuccessStatusMessage);
var url = result.GetDeploymentUrl();
GcpOutputWindow.OutputLine(String.Format(Resources.PublishUrlMessage, url));
if (OpenWebsite)
{
Process.Start(url);
}
EventsReporterWrapper.ReportEvent(GaeDeployedEvent.Create(CommandStatus.Success, deploymentDuration));
}
else
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
EventsReporterWrapper.ReportEvent(GaeDeployedEvent.Create(CommandStatus.Failure));
}
}
catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex))
{
GcpOutputWindow.OutputLine(String.Format(Resources.FlexPublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
EventsReporterWrapper.ReportEvent(GaeDeployedEvent.Create(CommandStatus.Failure));
}
}
public override async void Publish()
{
var project = _publishDialog.Project;
try
{
ShellUtils.SaveAllFiles();
GcpOutputWindow.Activate();
GcpOutputWindow.Clear();
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishStepStartMessage, project.Name));
_publishDialog.FinishFlow();
TimeSpan deploymentDuration;
bool result;
using (var frozen = StatusbarHelper.Freeze())
using (var animationShown = StatusbarHelper.ShowDeployAnimation())
using (var progress = StatusbarHelper.ShowProgressBar(String.Format(Resources.GcePublishProgressMessage, SelectedInstance.Name)))
using (var deployingOperation = ShellUtils.SetShellUIBusy())
{
var startDeploymentTime = DateTime.Now;
result = await WindowsVmDeployment.PublishProjectAsync(
project,
SelectedInstance,
SelectedCredentials,
progress,
VsVersionUtils.ToolsPathProvider,
GcpOutputWindow.OutputLine);
deploymentDuration = DateTime.Now - startDeploymentTime;
}
if (result)
{
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishSuccessMessage, project.Name, SelectedInstance.Name));
StatusbarHelper.SetText(Resources.PublishSuccessStatusMessage);
var url = SelectedInstance.GetDestinationAppUri();
GcpOutputWindow.OutputLine(String.Format(Resources.PublishUrlMessage, url));
if (OpenWebsite)
{
Process.Start(url);
}
EventsReporterWrapper.ReportEvent(GceDeployedEvent.Create(CommandStatus.Success, deploymentDuration));
}
else
{
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
EventsReporterWrapper.ReportEvent(GceDeployedEvent.Create(CommandStatus.Failure));
}
}
catch (Exception ex) when(!ErrorHandlerUtils.IsCriticalException(ex))
{
GcpOutputWindow.OutputLine(String.Format(Resources.GcePublishFailedMessage, project.Name));
StatusbarHelper.SetText(Resources.PublishFailureStatusMessage);
EventsReporterWrapper.ReportEvent(GceDeployedEvent.Create(CommandStatus.Failure));
}
}
