private void OnDeploymentTaskStarting(DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
foreach (IDeploymentPipelineModule deploymentPipelineModule in _modules)
{
deploymentPipelineModule.OnDeploymentTaskStarting(deploymentTask, deploymentContext);
}
}
public void StartDeployment(DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
if (deploymentTask == null)
{
throw new ArgumentNullException("deploymentTask");
}
if (deploymentContext == null)
{
throw new ArgumentNullException("deploymentContext");
}
deploymentContext.DateStarted = DateTime.UtcNow;
bool finishedSuccessfully = false;
OnDeploymentTaskStarting(deploymentTask, deploymentContext);
try
{
deploymentTask.PrepareAndExecute();
finishedSuccessfully = true;
}
finally
{
deploymentContext.DateFinished = DateTime.UtcNow;
deploymentContext.FinishedSuccessfully = finishedSuccessfully;
// TODO IMM HI: catch exceptions; pass them upstream using some mechanisms like DeploymentTask.DiagnosticMessagePosted event
OnDeploymentTaskFinished(
deploymentTask,
deploymentContext);
}
}
public void OnDeploymentTaskFinished_DoNothing_SoDoesNotThrows()
{
var enforceTargetEnvironmentConstraintsModule = new EnforceTargetEnvironmentConstraintsModule();
var environmentInfoRepository = new Mock<IEnvironmentInfoRepository>();
var artifactsRepository = new Mock<IArtifactsRepository>();
TerminalAppProjectInfo projectInfo = new TerminalAppProjectInfo("name", "artifactsRepositoryName", "artifactsrepositoryDirName", false, "terminalAppName", "terminalAppDirName", "terminalAppExeName");
var deploymentTask = new DeployTerminalAppDeploymentTask(environmentInfoRepository.Object, artifactsRepository.Object, projectInfo, "Production", "buildId", "prod");
var deploymentContext = new DeploymentContext("requester");
Assert.DoesNotThrow(() => enforceTargetEnvironmentConstraintsModule.OnDeploymentTaskFinished(deploymentTask, deploymentContext));
}
public void OnDeploymentTaskStarting_WhenEnvironmentIsProductionAndConfigurationIsNot_ThrowsInvalidOperationException()
{
var enforceTargetEnvironmentConstraintsModule = new EnforceTargetEnvironmentConstraintsModule();
var environmentInfoRepository = new Mock<IEnvironmentInfoRepository>();
var artifactsRepository = new Mock<IArtifactsRepository>();
TerminalAppProjectInfo projectInfo = new TerminalAppProjectInfo("name", "artifactsRepositoryName", "artifactsrepositoryDirName", false, "terminalAppName", "terminalAppDirName", "terminalAppExeName");
var deploymentTask = new DeployTerminalAppDeploymentTask(environmentInfoRepository.Object, artifactsRepository.Object, projectInfo, "trunk", "buildId", "prod");
var deploymentContext = new DeploymentContext("requester");
Assert.Throws<InvalidOperationException>(() => enforceTargetEnvironmentConstraintsModule.OnDeploymentTaskStarting(deploymentTask, deploymentContext));
}
public void OnDeploymentTaskStarting_DoNothing_SoDoesNotThrow()
{
var deploymentRequestRepository = new Mock<IDeploymentRequestRepository>();
var auditingModule = new AuditingModule(deploymentRequestRepository.Object);
var environmentInfoRepository = new Mock<IEnvironmentInfoRepository>();
var artifactsRepository = new Mock<IArtifactsRepository>();
TerminalAppProjectInfo projectInfo = new TerminalAppProjectInfo("name", "artifactsRepositoryName", "artifactsrepositoryDirName", false, "terminalAppName", "terminalAppDirName", "terminalAppExeName");
var deploymentTask = new DeployTerminalAppDeploymentTask(environmentInfoRepository.Object, artifactsRepository.Object, projectInfo, "Production", "buildId", "prod");
var deploymentContext = new DeploymentContext("requester");
Assert.DoesNotThrow(() => auditingModule.OnDeploymentTaskStarting(deploymentTask, deploymentContext));
}
public void StartDeployment(string targetEnvironment, List<ProjectDeploymentData> projectDeployments, DeploymentContext deploymentContext)
{
Guard.NotNull(projectDeployments, "projectDeploymentInfos");
Guard.NotNull(deploymentContext, "deploymentContext");
if (projectDeployments.Any() == false)
{
PostDiagnosticMessage(string.Format("No projects to deploy on environment '{0}'.", targetEnvironment), DiagnosticMessageType.Info);
return;
}
PostDiagnosticMessage(string.Format("Starting deployment of environment: '{0}'.", targetEnvironment), DiagnosticMessageType.Info);
PostDiagnosticMessage(string.Format("Projects count to deploy: '{0}'.", projectDeployments.Count), DiagnosticMessageType.Info);
deploymentContext.DateStarted = DateTime.UtcNow;
int successfullyDeployed = 0;
foreach (var projectDeployment in projectDeployments)
{
var isPrepared = PrepareProject(projectDeployment, deploymentContext);
if (isPrepared == false)
{
continue;
}
var isDeployed = ExecuteProjectDeployment(projectDeployment, deploymentContext);
if (isDeployed)
{
successfullyDeployed++;
}
}
deploymentContext.DateFinished = DateTime.UtcNow;
deploymentContext.FinishedSuccessfully = projectDeployments.Count == successfullyDeployed;
int failedCount = projectDeployments.Count - successfullyDeployed;
PostDiagnosticMessage(string.Format("Finished deployment of environment: '{0}', successfully deployed: {1}, failed: {2}", targetEnvironment, successfullyDeployed, failedCount), DiagnosticMessageType.Info);
PostDiagnosticMessage(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -",
DiagnosticMessageType.Info);
}
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));
}
public void OnDeploymentTaskFinished_ExpectAddDeploymentRequest()
{
DeploymentInfo deploymentInfo = DeploymentInfoGenerator.GetTerminalAppDeploymentInfo();
var deploymentRequestRepository = new Mock<IDeploymentRequestRepository>(MockBehavior.Strict);
var auditingModule = new AuditingModule(deploymentRequestRepository.Object);
var environmentInfoRepository = new Mock<IEnvironmentInfoRepository>();
var artifactsRepository = new Mock<IArtifactsRepository>();
var projectsInfoRepository = new Mock<IProjectInfoRepository>();
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");
deploymentRequestRepository
.Setup(
drr =>
drr.AddDeploymentRequest(
It.Is<DeploymentRequest>(
r => r.ProjectName == deploymentInfo.ProjectName
&& r.TargetEnvironmentName == deploymentInfo.TargetEnvironmentName)));
environmentInfoRepository
.Setup(x => x.FindByName(deploymentInfo.TargetEnvironmentName))
.Returns(DeploymentDataGenerator.GetEnvironmentInfo());
projectsInfoRepository
.Setup(pir => pir.FindByName(deploymentInfo.ProjectName))
.Returns(DeploymentDataGenerator.GetTerminalAppProjectInfo());
deploymentTask.Initialize(deploymentInfo);
deploymentTask.Prepare();
Assert.DoesNotThrow(() => auditingModule.OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext));
}
public void OnDeploymentTaskFinished_ExpectAddDeploymnetRequest()
{
string projectName = "projectName";
string targetEnvironmentName = "targetEnvironmentName";
var deploymentRequestRepository = new Mock<IDeploymentRequestRepository>(MockBehavior.Strict);
var auditingModule = new AuditingModule(deploymentRequestRepository.Object);
var environmentInfoRepository = new Mock<IEnvironmentInfoRepository>();
var artifactsRepository = new Mock<IArtifactsRepository>();
TerminalAppProjectInfo projectInfo = new TerminalAppProjectInfo(projectName, "artifactsRepositoryName", "artifactsrepositoryDirName", false, "terminalAppName", "terminalAppDirName", "terminalAppExeName");
var deploymentTask = new DeployTerminalAppDeploymentTask(environmentInfoRepository.Object, artifactsRepository.Object, projectInfo, "Production", "buildId", targetEnvironmentName);
var deploymentContext = new DeploymentContext("requester");
deploymentRequestRepository
.Setup(
drr =>
drr.AddDeploymentRequest(
It.Is<DeploymentRequest>(
r => r.ProjectName == projectName
&& r.TargetEnvironmentName == targetEnvironmentName)));
Assert.DoesNotThrow(() => auditingModule.OnDeploymentTaskFinished(deploymentTask, deploymentContext));
}
public void StartDeployment(DeploymentInfo deploymentInfo, DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
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);
deploymentTask.PrepareAndExecute();
finishedSuccessfully = true;
PostDiagnosticMessage(string.Format("Finished{0} '{1}' (\"{2}\").", (deploymentInfo.IsSimulation ? " (simulation)" : ""), deploymentTask.GetType().Name, deploymentTask.Description), DiagnosticMessageType.Info);
PostDiagnosticMessage("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -", DiagnosticMessageType.Info);
}
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;
}
}
private void OnDeploymentTaskFinished(DeploymentInfo deploymentInfo, DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
foreach (IDeploymentPipelineModule deploymentPipelineModule in _modules)
{
deploymentPipelineModule.OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext);
}
}
public override int Run(string[] args)
{
if (args.Length != 3)
{
DisplayCommandUsage();
return 1;
}
IProjectInfoRepository projectInfoRepository =
ObjectFactory.Instance.CreateProjectInfoRepository();
string projectName = args[0];
string projectConfigurationName = args[1];
string targetEnvironmentName = args[2];
ProjectInfo projectInfo = projectInfoRepository.GetByName(projectName);
if (projectInfo == null)
{
OutputWriter.WriteLine("Project named '{0}' doesn't exist.", projectName);
return 1;
}
ITeamCityClient teamCityClient =
ObjectFactory.Instance.CreateTeamCityClient();
Project project = teamCityClient.GetProjectByName(projectInfo.ArtifactsRepositoryName);
ProjectDetails projectDetails = teamCityClient.GetProjectDetails(project);
ProjectConfiguration projectConfiguration =
projectDetails.ConfigurationsList
.Configurations
.SingleOrDefault(pc => pc.Name == projectConfigurationName);
if (projectConfiguration == null)
{
OutputWriter.WriteLine(
"Project configuration named '{0}' doesn't exist for project '{1}'.",
projectConfigurationName,
projectName);
return 0;
}
ProjectConfigurationDetails projectConfigurationDetails =
teamCityClient.GetProjectConfigurationDetails(projectConfiguration);
ProjectConfigurationBuild projectConfigurationBuild =
teamCityClient.GetProjectConfigurationBuilds(projectConfigurationDetails, 0, 1)
.Builds
.FirstOrDefault();
if (projectConfigurationBuild == null)
{
throw new InvalidOperationException(
string.Format(
"Project configuration '{0}' of project '{1}' doesn't have any builds yet.",
projectConfigurationName,
projectName));
}
if (projectConfigurationBuild.Status != BuildStatus.Success)
{
throw new InvalidOperationException(
string.Format(
"Couldn't deploy latest build of project configuration '{0}' of project '{1}' because it was not successfull.",
projectConfigurationName,
projectName));
}
string projectConfigurationBuildId = projectConfigurationBuild.Id;
try
{
DeploymentTask deploymentTask =
projectInfo.CreateDeploymentTask(
ObjectFactory.Instance,
projectConfigurationName,
projectConfigurationBuildId,
targetEnvironmentName);
deploymentTask.DiagnosticMessagePosted +=
(eventSender, tmpArgs) => LogMessage(tmpArgs.Message);
IDeploymentPipeline deploymentPipeline =
ObjectFactory.Instance.CreateDeploymentPipeline();
var deploymentContext = new DeploymentContext(RequesterIdentity);
deploymentPipeline.StartDeployment(deploymentTask, deploymentContext);
return 0;
}
catch (Exception exc)
{
LogMessage("Error: " + exc);
return 1;
}
}
private void StartTask(DeploymentTask deploymentTask, Guid uniqueClientId, string requesterIdentity, Core.Domain.DeploymentInfo deploymentInfo)
{
var deploymentContext =
new DeploymentContext(requesterIdentity);
EventHandler<DiagnosticMessageEventArgs> deploymentPipelineDiagnosticMessageAction =
(eventSender, tmpArgs) => LogMessage(uniqueClientId, tmpArgs.MessageType, tmpArgs.Message);
try
{
_deploymentPipeline.DiagnosticMessagePosted += deploymentPipelineDiagnosticMessageAction;
_deploymentPipeline.StartDeployment(deploymentInfo, deploymentTask, deploymentContext, _applicationConfiguration.DeployDependentProjects);
}
finally
{
_deploymentPipeline.DiagnosticMessagePosted -= deploymentPipelineDiagnosticMessageAction;
}
}
public override int Run(string[] args)
{
if (args.Length != 4 && args.Length != 5)
{
DisplayCommandUsage();
return 1;
}
IProjectInfoRepository projectInfoRepository =
ObjectFactory.Instance.CreateProjectInfoRepository();
string projectName = args[0];
string projectConfigurationName = args[1];
string projectConfigurationBuildId = args[2];
string targetEnvironmentName = args[3];
bool isSimulation = (args.Length >= 5 ? string.Equals(args[4], "simulate", StringComparison.OrdinalIgnoreCase) : false);
ProjectInfo projectInfo = projectInfoRepository.FindByName(projectName);
if (projectInfo == null)
{
OutputWriter.WriteLine("Project named '{0}' doesn't exist.", projectName);
return 1;
}
Guid deploymentId = Guid.NewGuid();
var deploymentInfo =
new DeploymentInfo(
deploymentId,
isSimulation,
projectName,
projectConfigurationName,
projectConfigurationBuildId,
targetEnvironmentName,
projectInfo.CreateEmptyInputParams());
try
{
DeploymentTask deploymentTask =
projectInfo.CreateDeploymentTask(ObjectFactory.Instance);
IDeploymentPipeline deploymentPipeline =
ObjectFactory.Instance.CreateDeploymentPipeline();
deploymentPipeline.DiagnosticMessagePosted +=
(sender, tmpArgs) => LogMessage(tmpArgs.Message, tmpArgs.MessageType);
var deploymentContext = new DeploymentContext(RequesterIdentity);
deploymentPipeline.StartDeployment(deploymentInfo, deploymentTask, deploymentContext, false);
return 0;
}
catch (Exception exc)
{
LogMessage("Error: " + exc, DiagnosticMessageType.Error);
return 1;
}
}
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;
}
}
private void OnDeploymentTaskFinished(DeploymentInfo deploymentInfo, DeploymentTask deploymentTask, DeploymentContext deploymentContext)
{
foreach (IDeploymentPipelineModule deploymentPipelineModule in _modules)
{
deploymentPipelineModule.OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext);
}
}
public void StartDeployment(string targetEnvironment, List <ProjectDeploymentData> projectDeployments, DeploymentContext deploymentContext)
{
Guard.NotNull(projectDeployments, "projectDeploymentInfos");
Guard.NotNull(deploymentContext, "deploymentContext");
if (projectDeployments.Any() == false)
{
PostDiagnosticMessage(string.Format("No projects to deploy on environment '{0}'.", targetEnvironment), DiagnosticMessageType.Info);
return;
}
PostDiagnosticMessage(string.Format("Starting deployment of environment: '{0}'.", targetEnvironment), DiagnosticMessageType.Info);
PostDiagnosticMessage(string.Format("Projects count to deploy: '{0}'.", projectDeployments.Count), DiagnosticMessageType.Info);
deploymentContext.DateStarted = DateTime.UtcNow;
int successfullyDeployed = 0;
foreach (var projectDeployment in projectDeployments)
{
var isPrepared = PrepareProject(projectDeployment, deploymentContext);
if (isPrepared == false)
{
continue;
}
var isDeployed = ExecuteProjectDeployment(projectDeployment, deploymentContext);
if (isDeployed)
{
successfullyDeployed++;
}
}
deploymentContext.DateFinished = DateTime.UtcNow;
deploymentContext.FinishedSuccessfully = projectDeployments.Count == successfullyDeployed;
int failedCount = projectDeployments.Count - successfullyDeployed;
PostDiagnosticMessage(string.Format("Finished deployment of environment: '{0}', successfully deployed: {1}, failed: {2}", targetEnvironment, successfullyDeployed, failedCount), DiagnosticMessageType.Info);
PostDiagnosticMessage(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -",
DiagnosticMessageType.Info);
}
private bool ExecuteProjectDeployment(ProjectDeploymentData projectDeploymentData, DeploymentContext deploymentContext)
{
DeploymentInfo deploymentInfo = projectDeploymentData.DeploymentInfo;
DeploymentTask deploymentTask = projectDeploymentData.DeploymentTask;
PostDiagnosticMessage(string.Format("Starting{0} '{1}'.", (deploymentInfo.IsSimulation ? " (simulation)" : ""), deploymentTask.GetType().Name), DiagnosticMessageType.Info);
deploymentTask.DiagnosticMessagePosted += OnDeploymentTaskDiagnosticMessagePosted;
try
{
deploymentTask.Execute();
PostDiagnosticMessage(
string.Format("Finished{0} '{1}' (\"{2}\").", (deploymentInfo.IsSimulation ? " (simulation)" : ""),
deploymentTask.GetType().Name, deploymentTask.Description), DiagnosticMessageType.Info);
PostDiagnosticMessage(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -",
DiagnosticMessageType.Info);
return(true);
}
catch (Exception ex)
{
PostDiagnosticMessage(string.Format("Exception: {0}", ex.Message), DiagnosticMessageType.Error);
LogInnerException(ex);
}
finally
{
// TODO IMM HI: catch exceptions; pass them upstream using some mechanisms like DeploymentTask.DiagnosticMessagePosted event
OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext);
deploymentTask.DiagnosticMessagePosted -= OnDeploymentTaskDiagnosticMessagePosted;
}
return(false);
}
public override int Run(string[] args)
{
if (args.Length != 4)
{
DisplayCommandUsage();
return 1;
}
IProjectInfoRepository projectInfoRepository =
ObjectFactory.Instance.CreateProjectInfoRepository();
string projectName = args[0];
string projectConfigurationName = args[1];
string projectConfigurationBuildId = args[2];
string targetEnvironmentName = args[3];
ProjectInfo projectInfo = projectInfoRepository.GetByName(projectName);
if (projectInfo == null)
{
OutputWriter.WriteLine("Project named '{0}' doesn't exist.", projectName);
return 1;
}
try
{
DeploymentTask deploymentTask =
projectInfo.CreateDeploymentTask(
ObjectFactory.Instance,
projectConfigurationName,
projectConfigurationBuildId,
targetEnvironmentName);
deploymentTask.DiagnosticMessagePosted +=
(eventSender, tmpArgs) => LogMessage(tmpArgs.Message);
IDeploymentPipeline deploymentPipeline =
ObjectFactory.Instance.CreateDeploymentPipeline();
var deploymentContext = new DeploymentContext(RequesterIdentity);
deploymentPipeline.StartDeployment(deploymentTask, deploymentContext);
return 0;
}
catch (Exception exc)
{
LogMessage("Error: " + exc);
return 1;
}
}
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 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;
}
public void SetUp()
{
_environmentInfoRepositoryFake = new Mock<IEnvironmentInfoRepository>();
_artifactsRepositoryFake = new Mock<IArtifactsRepository>();
_projectsInfoRepositoryFake = new Mock<IProjectInfoRepository>();
_directoryAdapterFake = new Mock<IDirectoryAdapter>(MockBehavior.Loose);
_fileAdapterFake = new Mock<IFileAdapter>(MockBehavior.Loose);
_zipFileAdapterFake = new Mock<IZipFileAdapter>(MockBehavior.Loose);
_deploymentContext = new DeploymentContext("requester");
_deploymentTask =
new DeployTerminalAppDeploymentTask(
_projectsInfoRepositoryFake.Object,
_environmentInfoRepositoryFake.Object,
_artifactsRepositoryFake.Object,
_directoryAdapterFake.Object,
_fileAdapterFake.Object,
_zipFileAdapterFake.Object);
_enforceTargetEnvironmentConstraintsModule = new EnforceTargetEnvironmentConstraintsModule();
}
private void StartTask(DeploymentTask deploymentTask, Guid uniqueClientId, string requesterIdentity, DeploymentInfo deploymentInfoDto, ProjectInfo projectInfo)
{
Core.Domain.DeploymentInfo deploymentInfo =
DtoMapper.ConvertDeploymentInfo(deploymentInfoDto, projectInfo);
var deploymentContext =
new DeploymentContext(requesterIdentity);
EventHandler<DiagnosticMessageEventArgs> deploymentPipelineDiagnosticMessageAction =
(eventSender, tmpArgs) =>
{
_log.DebugIfEnabled(() => string.Format("{0}: {1}", tmpArgs.MessageType, tmpArgs.Message));
_diagnosticMessagesLogger.LogMessage(uniqueClientId, tmpArgs.MessageType, tmpArgs.Message);
};
try
{
_deploymentPipeline.DiagnosticMessagePosted += deploymentPipelineDiagnosticMessageAction;
_deploymentPipeline.StartDeployment(deploymentInfo, deploymentTask, deploymentContext);
}
finally
{
_deploymentPipeline.DiagnosticMessagePosted -= deploymentPipelineDiagnosticMessageAction;
}
}
private void DoDeploy(Guid uniqueClientId, string requesterIdentity, string projectConfigurationName, string projectConfigurationBuildId, string targetEnvironmentName, ProjectInfo projectInfo)
{
DeploymentTask deploymentTask =
projectInfo.CreateDeploymentTask(
ObjectFactory.Instance,
projectConfigurationName,
projectConfigurationBuildId,
targetEnvironmentName);
deploymentTask.DiagnosticMessagePosted +=
(eventSender, tmpArgs) =>
{
_log.DebugIfEnabled(() => string.Format("{0}: {1}", tmpArgs.MessageType, tmpArgs.Message));
_diagnosticMessagesLogger.LogMessage(uniqueClientId, tmpArgs.MessageType, tmpArgs.Message);
};
var deploymentContext =
new DeploymentContext(requesterIdentity);
_deploymentPipeline.StartDeployment(deploymentTask, deploymentContext);
}
private bool ExecuteProjectDeployment(ProjectDeploymentData projectDeploymentData, DeploymentContext deploymentContext)
{
DeploymentInfo deploymentInfo = projectDeploymentData.DeploymentInfo;
DeploymentTask deploymentTask = projectDeploymentData.DeploymentTask;
PostDiagnosticMessage(string.Format("Starting{0} '{1}'.", (deploymentInfo.IsSimulation ? " (simulation)" : ""), deploymentTask.GetType().Name), DiagnosticMessageType.Info);
deploymentTask.DiagnosticMessagePosted += OnDeploymentTaskDiagnosticMessagePosted;
try
{
deploymentTask.Execute();
PostDiagnosticMessage(
string.Format("Finished{0} '{1}' (\"{2}\").", (deploymentInfo.IsSimulation ? " (simulation)" : ""),
deploymentTask.GetType().Name, deploymentTask.Description), DiagnosticMessageType.Info);
PostDiagnosticMessage(
"- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -",
DiagnosticMessageType.Info);
return true;
}
catch (Exception ex)
{
PostDiagnosticMessage(string.Format("Exception: {0}", ex.Message), DiagnosticMessageType.Error);
LogInnerException(ex);
}
finally
{
// TODO IMM HI: catch exceptions; pass them upstream using some mechanisms like DeploymentTask.DiagnosticMessagePosted event
OnDeploymentTaskFinished(deploymentInfo, deploymentTask, deploymentContext);
deploymentTask.DiagnosticMessagePosted -= OnDeploymentTaskDiagnosticMessagePosted;
}
return false;
}
