private void OnDeploymentTaskFinished(DeploymentInfo deploymentInfo, DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
foreach (IDeploymentPipelineModule deploymentPipelineModule in _modules)
{
deploymentPipelineModule.OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext);
}
}
public ExtractArtifactsDeploymentStep(
ProjectInfo projectInfo,
EnvironmentInfo environmentInfo,
DeploymentInfo deploymentInfo,
string artifactsFilePath,
string targetArtifactsDirPath,
IFileAdapter fileAdapter,
IDirectoryAdapter directoryAdapter,
IZipFileAdapter zipFileAdapter)
{
Guard.NotNull(projectInfo, "projectInfo");
Guard.NotNull(environmentInfo, "environmentInfo");
Guard.NotNull(deploymentInfo, "deploymentInfo");
Guard.NotNullNorEmpty(artifactsFilePath, "artifactsFilePath");
Guard.NotNullNorEmpty(targetArtifactsDirPath, "targetArtifactsDirPath");
Guard.NotNull(fileAdapter, "fileAdapter");
Guard.NotNull(directoryAdapter, "directoryAdapter");
Guard.NotNull(zipFileAdapter, "zipFileAdapter");
_projectInfo = projectInfo;
_environmentInfo = environmentInfo;
_deploymentInfo = deploymentInfo;
_artifactsFilePath = artifactsFilePath;
_targetArtifactsDirPath = targetArtifactsDirPath;
_fileAdapter = fileAdapter;
_directoryAdapter = directoryAdapter;
_zipFileAdapter = zipFileAdapter;
}
public GatherDbScriptsToRunDeploymentStep(
string dbName,
Lazy <string> scriptsDirectoryPathProvider,
string databaseServerMachineName,
string environmentName,
DeploymentInfo deploymentInfo,
IDbVersionProvider dbVersionProvider,
IScriptsToRunSelector scriptsToRunSelector)
{
Guard.NotNullNorEmpty(dbName, "dbName");
Guard.NotNull(scriptsDirectoryPathProvider, "scriptsDirectoryPathProvider");
Guard.NotNullNorEmpty(databaseServerMachineName, "databaseServerMachineName");
Guard.NotNullNorEmpty(environmentName, "environmentName");
Guard.NotNull(deploymentInfo, "deploymentInfo");
Guard.NotNull(dbVersionProvider, "dbVersionProvider");
Guard.NotNull(scriptsToRunSelector, "scriptsToRunWebSelector");
_dbName = dbName;
_scriptsDirectoryPathProvider = scriptsDirectoryPathProvider;
_sqlServerName = databaseServerMachineName;
_environmentName = environmentName;
_deploymentInfo = deploymentInfo;
_dbVersionProvider = dbVersionProvider;
_scriptsToRunSelector = scriptsToRunSelector;
_scriptsToRun = Enumerable.Empty <DbScriptToRun>();
}
public void OnDeploymentTaskFinished_DoNothing_SoDoesNotThrows()
{
DeploymentInfo deploymentInfo = DeploymentInfoGenerator.GetTerminalAppDeploymentInfo();
Assert.DoesNotThrow(
() => _enforceTargetEnvironmentConstraintsModule.OnDeploymentTaskFinished(deploymentInfo, _deploymentTask, _deploymentContext));
}
private bool PrepareProject(ProjectDeploymentData projectDeploymentData, DeploymentContext deploymentContext)
{
DeploymentInfo deploymentInfo = projectDeploymentData.DeploymentInfo;
DeploymentTask deploymentTask = projectDeploymentData.DeploymentTask;
PostDiagnosticMessage(string.Format("Preparing {0} '{1}'.", (deploymentInfo.IsSimulation ? " (simulation)" : ""), deploymentTask.GetType().Name), DiagnosticMessageType.Info);
deploymentTask.DiagnosticMessagePosted += OnDeploymentTaskDiagnosticMessagePosted;
OnDeploymentTaskStarting(deploymentInfo, deploymentTask, deploymentContext);
try
{
deploymentTask.Initialize(deploymentInfo);
deploymentTask.Prepare();
return(true);
}
catch (Exception exc)
{
PostDiagnosticMessage(string.Format("Exception while preparing: {0}", exc.Message), DiagnosticMessageType.Error);
}
finally
{
deploymentTask.DiagnosticMessagePosted -= OnDeploymentTaskDiagnosticMessagePosted;
}
return(false);
}
private void deployBackgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
bool startSeparatorWasLogged = false;
DiagnosticMessagesPoller diagnosticMessagesPoller = null;
try
{
ToggleIndeterminateProgress(true, pic_indeterminateProgress);
var projectDeploymentInfo = (ProjectDeploymentInfo)e.Argument;
Guid deploymentId = Guid.NewGuid();
var deploymentInfo = new DeploymentInfo
{
DeploymentId = deploymentId,
ProjectName = projectDeploymentInfo.ProjectInfo.Name,
ProjectConfigurationName = projectDeploymentInfo.ProjectConfiguration.Name,
ProjectConfigurationBuildId = projectDeploymentInfo.ProjectConfigurationBuild.Id,
TargetEnvironmentName = projectDeploymentInfo.TargetEnvironmentName
};
LogMessage(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", DiagnosticMessageType.Info);
startSeparatorWasLogged = true;
diagnosticMessagesPoller =
new DiagnosticMessagesPoller(
_agentService,
dm => LogMessage(dm.Message, dm.Type));
diagnosticMessagesPoller.Start();
deploymentId = Guid.NewGuid();
_agentService
.Deploy(
deploymentId,
Program.UniqueClientId,
RequesterIdentity,
deploymentInfo);
}
catch (Exception exc)
{
LogMessage("Error: " + exc.Message, DiagnosticMessageType.Error);
}
finally
{
if (diagnosticMessagesPoller != null)
{
diagnosticMessagesPoller.Stop();
}
if (startSeparatorWasLogged)
{
LogMessage("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<", DiagnosticMessageType.Info);
}
ToggleIndeterminateProgress(false, pic_indeterminateProgress);
}
}
public void Setup()
{
_deploymentTask = new DeployExtensionProjectDeploymentTask(
_projectInfoRepository.Object,
_environmentInfoRepository.Object,
_artifactsRepository.Object,
_directoryAdapter.Object,
_fileAdapter.Object,
_zipFileAdapter.Object,
_failoverClusterManager.Object,
_ntServiceManager.Object);
DeploymentInfo di = DeploymentInfoGenerator.GetExtensionProjectDeploymentInfo();
_deploymentTask.Initialize(di);
_environmentInfoRepository
.Setup(x => x.FindByName(It.IsAny <string>()))
.Returns(DeploymentDataGenerator.GetEnvironmentInfo);
_projectInfoRepository
.Setup(x => x.FindByName(DeploymentDataGenerator.GetExtensionProjectInfo().ExtendedProjectName))
.Returns(DeploymentDataGenerator.GetNtServiceProjectInfo);
_projectInfoRepository
.Setup(x => x.FindByName(di.ProjectName))
.Returns(DeploymentDataGenerator.GetExtensionProjectInfo);
}
protected override void ExecuteTask()
{
try
{
IProjectInfoRepository projectInfoRepository = ObjectFactory.Instance.CreateProjectInfoRepository();
ProjectInfo projectInfo = projectInfoRepository.FindByName(ProjectName);
DeploymentTask deploymentTask = projectInfo.CreateDeploymentTask(ObjectFactory.Instance);
IDeploymentPipeline deploymentPipeline =
ObjectFactory.Instance.CreateDeploymentPipeline();
deploymentPipeline.DiagnosticMessagePosted +=
(eventSender, tmpArgs) => Log(Level.Info, tmpArgs.Message);
var deploymentContext = new DeploymentContext(RequesterIdentity);
Guid deploymentId = Guid.NewGuid();
var deploymentInfo =
new DeploymentInfo(
deploymentId,
IsSimulation,
ProjectName,
ConfigurationName,
BuildId,
Environment,
projectInfo.CreateEmptyInputParams());
deploymentPipeline.StartDeployment(deploymentInfo, deploymentTask, deploymentContext);
}
catch (Exception exc)
{
Log(Level.Error, "Error: " + exc);
}
}
private async Task <bool> TriggerStopDeploymentAsync(DeploymentInfo deployment)
{
if (!Tools.Common.CheckDependencies())
{
return(false);
}
var arguments = new List <string>
{
"stop",
projectName,
deployment.Id
};
var processResult = await RunDeploymentLauncherHelperAsync(arguments, true);
if (processResult.ExitCode != 0)
{
if (processResult.Stdout.Count > 0 && processResult.Stdout[0] == "<error:unknown-deployment>")
{
Debug.LogError(
$"Unable to stop deployment {deployment.Name}. Has the deployment been stopped already?");
}
return(false);
}
Debug.Log($"Deployment {deployment.Name} stopped.");
return(true);
}
private List <ProjectDeployment> BuildDefaultProjectDeployments(IEnumerable <ProjectInfo> dependentProjectsToDeploy, string defaultTeamCityProjectConfiguration)
{
var projectDeployments = new List <ProjectDeployment>();
foreach (var projectInfo in dependentProjectsToDeploy)
{
IEnumerable <TeamCityBuildType> teamCityBuildTypes = _temCityRestClient.GetBuildTypes(projectInfo.ArtifactsRepositoryName);
TeamCityBuildType defaultBuildType = teamCityBuildTypes.FirstOrDefault(x => x.Name == defaultTeamCityProjectConfiguration);
if (defaultBuildType == null)
{
throw new DeploymentTaskException(string.Format("TeamCity configuration: [{0}] does not exist for project: [{1}]", defaultTeamCityProjectConfiguration, projectInfo.Name));
}
TeamCityBuild lastSuccessfulBuild = _temCityRestClient.GetLastSuccessfulBuild(defaultBuildType.Id);
if (lastSuccessfulBuild == null)
{
throw new DeploymentTaskException(string.Format("Cannot obtain last successful build for project [{0}], configuration: [{1}], team city build type id: [{2}]", projectInfo.Name, defaultTeamCityProjectConfiguration, defaultBuildType.Id));
}
var deploymentInfo = new DeploymentInfo(_deploymentId, false, projectInfo.Name, defaultTeamCityProjectConfiguration, lastSuccessfulBuild.Id, _targetEnvironment, projectInfo.CreateEmptyInputParams());
projectDeployments.Add(
new ProjectDeployment
{
ProjectInfo = projectInfo,
DeploymentInfo = deploymentInfo,
TeamCityBuild = lastSuccessfulBuild,
});
}
return(projectDeployments);
}
public DeploymentManager(DeploymentInfo deployment, string branch, string version)
{
Deployment = deployment;
Ssh = new SshHelper(deployment.Ssh);
Ssh.StartDirectory = "/usr/local/GrowSense/Index";
Version = version;
Branch = branch;
}
private async Task StartDockerCompose(NodeCredentials credentials, DeploymentInfo composeVersion, CancellationToken ct)
{
using var activity = Extensions.SuperComposeActivitySource.StartActivity("StartDockerCompose");
var cmd = await ComposeCmdPrefix(credentials, composeVersion.ComposeDirectory, composeVersion.ServiceName, ct) + " up -d --remove-orphans";
await proxyClient.RunCommand(credentials, cmd, ct);
}
void Header_Loaded(object sender, RoutedEventArgs e)
{
uiDeploymentInfo.Text = DeploymentInfo.ToString();
//uiBtnLogo.DataContext = this;
SiteMapHelper.SelectWeb1SiteMapAsync(LoadMenuItems);
uiCurrencyExchange.Text = string.Format("1 {0} = {1} {2}", Globals.AppSettings.SecondCurrency, Globals.AppSettings.ExchangeRate, Globals.AppSettings.MainCurrency);
}
// key goal is to create background tracer that is independent of request.
public static void PerformBackgroundDeployment(DeploymentInfo deployInfo, IEnvironment environment, IDeploymentSettingsManager settings, TraceLevel traceLevel, Uri uri)
{
var tracer = traceLevel <= TraceLevel.Off ? NullTracer.Instance : new XmlTracer(environment.TracePath, traceLevel);
var traceFactory = new TracerFactory(() => tracer);
var backgroundTrace = tracer.Step(XmlTracer.BackgroundTrace, new Dictionary <string, string>
{
{ "url", uri.AbsolutePath },
{ "method", "POST" }
});
Task.Run(() =>
{
try
{
// lock related
string lockPath = Path.Combine(environment.SiteRootPath, Constants.LockPath);
string deploymentLockPath = Path.Combine(lockPath, Constants.DeploymentLockFile);
string statusLockPath = Path.Combine(lockPath, Constants.StatusLockFile);
string hooksLockPath = Path.Combine(lockPath, Constants.HooksLockFile);
var statusLock = new LockFile(statusLockPath, traceFactory);
var hooksLock = new LockFile(hooksLockPath, traceFactory);
var deploymentLock = new DeploymentLockFile(deploymentLockPath, traceFactory);
var analytics = new Analytics(settings, new ServerConfiguration(), traceFactory);
var deploymentStatusManager = new DeploymentStatusManager(environment, analytics, statusLock);
var repositoryFactory = new RepositoryFactory(environment, settings, traceFactory);
var siteBuilderFactory = new SiteBuilderFactory(new BuildPropertyProvider(), environment);
var webHooksManager = new WebHooksManager(tracer, environment, hooksLock);
var deploymentManager = new DeploymentManager(siteBuilderFactory, environment, traceFactory, analytics, settings, deploymentStatusManager, deploymentLock, NullLogger.Instance, webHooksManager);
var fetchHandler = new FetchHandler(tracer, deploymentManager, settings, deploymentStatusManager, deploymentLock, environment, null, repositoryFactory, null);
// Perform deployment
var acquired = deploymentLock.TryLockOperation(() =>
{
fetchHandler.PerformDeployment(deployInfo).Wait();
}, TimeSpan.Zero);
if (!acquired)
{
using (tracer.Step("Update pending deployment marker file"))
{
// REVIEW: This makes the assumption that the repository url is the same.
// If it isn't the result would be buggy either way.
FileSystemHelpers.SetLastWriteTimeUtc(fetchHandler._markerFilePath, DateTime.UtcNow);
}
}
}
catch (Exception ex)
{
tracer.TraceError(ex);
}
finally
{
backgroundTrace.Dispose();
}
});
}
public IHttpActionResult PostDeploymentInfo([FromBody] DeploymentInfo DeploymentInfo)
{
if (!_SecRepo.IsAllowed(User.Identity.Name, "create-services"))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
return(Ok(_Repo.PostDeploymentInfo(DeploymentInfo)));
}
public void TryParseDeploymentInfoShouldReturnUnknownPayload()
{
var oneDriveHandler = new OneDriveHandler(Mock.Of <ITracer>(), Mock.Of <IDeploymentStatusManager>(), Mock.Of <IDeploymentSettingsManager>(), Mock.Of <IEnvironment>());
JObject payload = JObject.FromObject(new { });
DeploymentInfo deploymentInfo = null;
DeployAction result = oneDriveHandler.TryParseDeploymentInfo(null, payload, null, out deploymentInfo);
Assert.Equal(DeployAction.UnknownPayload, result);
}
public void TryParseDeploymentInfoShouldReturnProcessDeployment()
{
var oneDriveHandler = new OneDriveHandler(Mock.Of <ITracer>(), Mock.Of <IDeploymentStatusManager>(), Mock.Of <IDeploymentSettingsManager>(), Mock.Of <IEnvironment>());
JObject payload = JObject.FromObject(new { RepositoryUrl = "https://api.onedrive.com", AccessToken = "one-drive-access-token" });
DeploymentInfo deploymentInfo = null;
DeployAction result = oneDriveHandler.TryParseDeploymentInfo(null, payload, null, out deploymentInfo);
Assert.Equal(DeployAction.ProcessDeployment, result);
}
// For continuous integration, we will only build/deploy if fetch new changes
// The immediate goal is to address duplicated /deploy requests from Bitbucket (retry if taken > 20s)
private bool ShouldDeploy(IRepository repository, DeploymentInfo deploymentInfo, string targetBranch)
{
if (deploymentInfo.IsContinuous)
{
ChangeSet changeSet = repository.GetChangeSet(targetBranch);
return(!String.Equals(_status.ActiveDeploymentId, changeSet.Id, StringComparison.OrdinalIgnoreCase));
}
return(true);
}
public void OnDeploymentTaskStarting(DeploymentInfo deploymentInfo, DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
if (deploymentInfo.TargetEnvironmentName == ProductionEnvironmentName &&
deploymentInfo.ProjectConfigurationName != ProductionProjectConfigurationName)
{
throw new InvalidOperationException(string.Format(
"Can't deploy project ('{0}') with non-production configuration ('{1}') to the production environment!",
deploymentInfo.ProjectName,
deploymentInfo.ProjectConfigurationName));
}
}
public void GenericHandlerBranchTest(string url, string repoUrl, string commitId)
{
// Act
var deploymentInfo = new DeploymentInfo();
GenericHandler.SetRepositoryUrl(deploymentInfo, url);
// Assert
Assert.Equal(repoUrl, deploymentInfo.RepositoryUrl);
Assert.Equal(commitId, deploymentInfo.CommitId);
}
private async Task RemoveCompose(NodeCredentials credentials, DeploymentInfo deployment, CancellationToken ct = default)
{
if (!string.IsNullOrEmpty(deployment.ComposePath))
{
var removed = await proxyClient.DeleteFile(credentials, deployment.ComposePath, ct);
if (removed)
{
connectionLog.Info($"Removed old compose file");
}
}
}
public void Prepare_adds_PublishDatabaseDeploymentStep()
{
// arrange
DeploymentInfo deploymentInfo = CreateDeploymentInfo();
_publishDbProjectDeploymentTask.Initialize(deploymentInfo);
// act
_publishDbProjectDeploymentTask.Prepare();
// assert
Assert.IsNotEmpty(_publishDbProjectDeploymentTask.SubTasks.OfType <PublishDatabaseDeploymentStep>().ToList());
}
private async Task <bool> UpdateComposeFile(NodeCredentials credentials, DeploymentInfo composeVersion, CancellationToken ct)
{
using var activity = Extensions.SuperComposeActivitySource.StartActivity("UpdateComposeFile");
var resp = await proxyClient.UpsertFile(credentials, composeVersion.ComposePath, composeVersion.ComposeContent, true, ct);
if (resp.Updated)
{
connectionLog.Info($"docker-compose.yaml has been updated");
}
return(resp.Updated);
}
public void StartDeployment(DeploymentInfo deploymentInfo, DeploymentTask deploymentTask, DeploymentContext deploymentContext, bool deployDependencies)
{
Guard.NotNull(deploymentInfo, "deploymentInfo");
Guard.NotNull(deploymentTask, "deploymentTask");
Guard.NotNull(deploymentContext, "deploymentContext");
PostDiagnosticMessage(string.Format("Starting{0} '{1}'.", (deploymentInfo.IsSimulation ? " (simulation)" : ""), deploymentTask.GetType().Name), DiagnosticMessageType.Info);
deploymentContext.DateStarted = DateTime.UtcNow;
deploymentTask.DiagnosticMessagePosted += OnDeploymentTaskDiagnosticMessagePosted;
bool finishedSuccessfully = false;
OnDeploymentTaskStarting(deploymentInfo, deploymentTask, deploymentContext);
try
{
deploymentTask.Initialize(deploymentInfo);
if (_applicationConfiguration.DeployDependentProjects && deploymentInfo.ProjectConfigurationName == DeployDependenciesTask.DefaultTeamCityProjectConfiguration)
{
deploymentTask.EnableDependenciesDeployment(_objectFactory);
}
deploymentTask.PrepareAndExecute();
finishedSuccessfully = true;
PostDiagnosticMessage(
string.Format("Finished{0} '{1}' (\"{2}\").", (deploymentInfo.IsSimulation ? " (simulation)" : ""),
deploymentTask.GetType().Name, deploymentTask.Description), DiagnosticMessageType.Info);
PostDiagnosticMessage(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -",
DiagnosticMessageType.Info);
}
catch (Exception ex)
{
PostDiagnosticMessage(string.Format("Exception: {0}", ex.Message), DiagnosticMessageType.Error);
}
finally
{
deploymentContext.DateFinished = DateTime.UtcNow;
deploymentContext.FinishedSuccessfully = finishedSuccessfully;
// TODO IMM HI: catch exceptions; pass them upstream using some mechanisms like DeploymentTask.DiagnosticMessagePosted event
OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext);
deploymentTask.DiagnosticMessagePosted -= OnDeploymentTaskDiagnosticMessagePosted;
}
}
public DownloadArtifactsDeploymentStep(ProjectInfo projectInfo, DeploymentInfo deploymentInfo, string targetDirPath, IArtifactsRepository artifactsRepository)
{
Guard.NotNull(projectInfo, "projectInfo");
Guard.NotNull(deploymentInfo, "deploymentInfo");
Guard.NotNullNorEmpty(targetDirPath, "targetDirPath");
Guard.NotNull(artifactsRepository, "artifactsRepository");
_projectInfo = projectInfo;
_deploymentInfo = deploymentInfo;
_targetDirPath = targetDirPath;
_artifactsRepository = artifactsRepository;
_artifactsFilePath = Path.Combine(_targetDirPath, "artifacts.zip");
}
public DeploymentInfo GetDeploymentInfoFromEnvironmentVariables(string branch)
{
Console.WriteLine(" From environment variables...");
var deployment = new DeploymentInfo();
//var branch =
//deployment.Name = "devstaging";
deployment.Username = GetEnvironmentVariable("USERNAME", branch);
deployment.Password = GetEnvironmentVariable("PASSWORD", branch);
deployment.Ssh = new SshTarget();
deployment.Ssh.Host = GetEnvironmentVariable("SSH_HOST", branch);
deployment.Ssh.Username = GetEnvironmentVariable("SSH_USERNAME", branch);
deployment.Ssh.Password = GetEnvironmentVariable("SSH_PASSWORD", branch);
deployment.Ssh.Port = Convert.ToInt32(GetEnvironmentVariable("SSH_PORT", branch));
deployment.Mqtt = new MqttTarget();
deployment.Mqtt.Host = GetEnvironmentVariable("MQTT_HOST", branch);
deployment.Mqtt.Username = GetEnvironmentVariable("MQTT_USERNAME", branch);
deployment.Mqtt.Password = GetEnvironmentVariable("MQTT_PASSWORD", branch);
deployment.Mqtt.Port = Convert.ToInt32(GetEnvironmentVariable("MQTT_PORT", branch));
var remote = new DeploymentInfo();
remote.Ssh = new SshTarget();
remote.Name = branch + "2";
remote.Ssh.Host = GetEnvironmentVariable("SSH_HOST", branch + "2");
remote.Ssh.Username = GetEnvironmentVariable("SSH_USERNAME", branch + "2");
remote.Ssh.Password = GetEnvironmentVariable("SSH_PASSWORD", branch + "2");
remote.Ssh.Port = Convert.ToInt32(GetEnvironmentVariable("SSH_PORT", branch + "2"));
remote.Mqtt = new MqttTarget();
remote.Mqtt.Host = GetEnvironmentVariable("MQTT_HOST", branch + "2");
remote.Mqtt.Username = GetEnvironmentVariable("MQTT_USERNAME", branch + "2");
remote.Mqtt.Password = GetEnvironmentVariable("MQTT_PASSWORD", branch + "2");
remote.Mqtt.Port = Convert.ToInt32(GetEnvironmentVariable("MQTT_PORT", branch + "2"));
if (!String.IsNullOrEmpty(remote.Ssh.Host))
{
deployment.Remotes = new DeploymentInfo[] {
remote
};
}
return(deployment);
}
public void OnDeploymentTaskStarting_WhenEnvironmentIsProductionAndConfigurationIsNot_ThrowsInvalidOperationException()
{
DeploymentInfo deploymentInfo =
new DeploymentInfo(
Guid.NewGuid(),
false,
"project_name",
"branch",
"project_configuration_build_id",
EnforceTargetEnvironmentConstraintsModule.ProductionEnvironmentName,
new TerminalAppInputParams());
Assert.Throws <InvalidOperationException>(
() => _enforceTargetEnvironmentConstraintsModule.OnDeploymentTaskStarting(deploymentInfo, _deploymentTask, _deploymentContext));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private java.net.URL determineHarUrl() throws Exception
private URL determineHarUrl()
{
log.trace("Attempting to determine HarUrl...");
DeploymentInfo deploymentInfo = DeploymentInfo;
if (deploymentInfo == null)
{
log.warn("Unable to locate deployment info [" + ServiceName + "]");
return(null);
}
string str = deploymentInfo.url.File;
log.trace("checking our deployment unit [" + str + "]");
return((str.EndsWith(".har", StringComparison.Ordinal) || str.EndsWith(".har/", StringComparison.Ordinal)) ? deploymentInfo.url : null);
}
public void CreateReleaseZipAndPushToHost(string projectDirectory, DeploymentInfo deployment, SshHelper ssh)
{
Console.WriteLine("");
Console.WriteLine("Creating release zip...");
var starter = new ProcessStarter(projectDirectory);
starter.StartBash("bash create-release-zip.sh");
starter.OutputBuilder.Clear();
var sourceReleaseFilePath = Directory.GetFiles(projectDirectory + "/releases/")[0];
var destinationReleaseFilePath = "/usr/local/GrowSense/Installer/" + Path.GetFileName(sourceReleaseFilePath);
ssh.CopyFileTo(sourceReleaseFilePath, destinationReleaseFilePath);
}
public void OnDeploymentTaskStarting_DoNothing_SoDoesNotThrow()
{
var deploymentRequestRepository = new Mock <IDeploymentRequestRepository>();
var auditingModule = new AuditingModule(deploymentRequestRepository.Object);
var projectsInfoRepository = new Mock <IProjectInfoRepository>();
var environmentInfoRepository = new Mock <IEnvironmentInfoRepository>();
var artifactsRepository = new Mock <IArtifactsRepository>();
var directoryAdapter = new Mock <IDirectoryAdapter>();
var fileAdapter = new Mock <IFileAdapter>();
var zipFileAdapter = new Mock <IZipFileAdapter>();
var deploymentTask = new DeployTerminalAppDeploymentTask(projectsInfoRepository.Object, environmentInfoRepository.Object, artifactsRepository.Object, directoryAdapter.Object, fileAdapter.Object, zipFileAdapter.Object);
var deploymentContext = new DeploymentContext("requester");
DeploymentInfo deploymentInfo = DeploymentInfoGenerator.GetTerminalAppDeploymentInfo();
Assert.DoesNotThrow(() => auditingModule.OnDeploymentTaskStarting(deploymentInfo, deploymentTask, deploymentContext));
}
