public void Deploy(Guid deploymentId, Guid uniqueClientId, string requesterIdentity, DeploymentInfo deploymentInfoDto)
{
try
{
Guard.NotEmpty(deploymentId, "deploymentId");
Guard.NotEmpty(uniqueClientId, "uniqueClientId");
Guard.NotNullNorEmpty(requesterIdentity, "requesterIdentity");
Guard.NotNull(deploymentInfoDto, "DeploymentInfo");
ProjectInfo projectInfo =
_projectInfoRepository.FindByName(deploymentInfoDto.ProjectName);
if (projectInfo == null)
{
throw new FaultException <ProjectNotFoundFault>(new ProjectNotFoundFault {
ProjectName = deploymentInfoDto.ProjectName
});
}
Core.Domain.DeploymentInfo deploymentInfo =
DtoMapper.ConvertDeploymentInfo(deploymentInfoDto, projectInfo);
DoDeploy(uniqueClientId, requesterIdentity, deploymentInfo, projectInfo);
}
catch (Exception exc)
{
HandleDeploymentException(exc, uniqueClientId);
}
}
private static InputParams BuildInputParams(ProjectInfo projectInfo, EnvironmentInfo environmentInfo)
{
switch (projectInfo.Type)
{
case ProjectType.WebApp:
// deploy to all web server machines
return(new WebAppInputParams(environmentInfo.WebServerMachineNames));
case ProjectType.Db:
return(new DbInputParams());
case ProjectType.NtService:
return(new NtServiceInputParams());
case ProjectType.SchedulerApp:
return(new SsdtInputParams());
case ProjectType.TerminalApp:
return(new SsdtInputParams());
case ProjectType.WebService:
return(new SsdtInputParams());
case ProjectType.Extension:
return(new ExtensionInputParams());
case ProjectType.PowerShellScript:
return(new PowerShellInputParams());
default:
throw new DeploymentTaskException(string.Format("Project type: {0} is not supported in environment deployment.", projectInfo.Type));
}
}
public DownloadArtifactsDeploymentStep(IArtifactsRepository artifactsRepository, ProjectInfo projectInfo, string projectConfigurationName, string projectConfigurationBuildId, string targetDirPath)
{
if (artifactsRepository == null)
{
throw new ArgumentNullException("artifactsRepository");
}
if (projectInfo == null)
{
throw new ArgumentNullException("projectInfo");
}
if (string.IsNullOrEmpty(projectConfigurationName))
{
throw new ArgumentException("Argument can't be null nor empty.", "projectConfigurationName");
}
if (string.IsNullOrEmpty(projectConfigurationBuildId))
{
throw new ArgumentException("Argument can't be null nor empty.", "projectConfigurationBuildId");
}
if (string.IsNullOrEmpty(targetDirPath))
{
throw new ArgumentException("Argument can't be null nor empty.", "targetDirPath");
}
_artifactsRepository = artifactsRepository;
_projectInfo = projectInfo;
_projectConfigurationName = projectConfigurationName;
_projectConfigurationBuildId = projectConfigurationBuildId;
_targetDirPath = targetDirPath;
_artifactsFilePath = Path.Combine(_targetDirPath, "artifacts.zip");
}
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 List <ProjectConfiguration> GetProjectConfigurations(string projectName)
{
Guard.NotNullNorEmpty(projectName, "projectName");
ProjectInfo projectInfo = _projectInfoRepository.FindByName(projectName);
List <TeamCityBuildType> projectConfigurations = _teamCityClient.GetBuildTypesWithBranches(projectInfo.ArtifactsRepositoryName).ToList();
return(projectConfigurations.Select(DtoMapper.Map <TeamCityBuildType, ProjectConfiguration>).ToList());
}
public ExtractArtifactsDeploymentStep(EnvironmentInfo environmentInfo, ProjectInfo projectInfo, string projectConfigurationName, string projectConfigurationBuildId, string artifactsFilePath, string targetArtifactsDirPath)
{
if (environmentInfo == null)
{
throw new ArgumentNullException("environmentInfo");
}
if (projectInfo == null)
{
throw new ArgumentNullException("projectInfo");
}
if (string.IsNullOrEmpty(projectConfigurationName))
{
throw new ArgumentException("Argument can't be null nor empty.", "projectConfigurationName");
}
if (string.IsNullOrEmpty(projectConfigurationBuildId))
{
throw new ArgumentException("Argument can't be null nor empty.", "projectConfigurationBuildId");
}
if (string.IsNullOrEmpty(artifactsFilePath))
{
throw new ArgumentException("Argument can't be null nor empty.", "artifactsFilePath");
}
if (string.IsNullOrEmpty(targetArtifactsDirPath))
{
throw new ArgumentException("Argument can't be null nor empty.", "targetArtifactsDirPath");
}
_environmentInfo = environmentInfo;
_projectInfo = projectInfo;
_projectConfigurationName = projectConfigurationName;
_projectConfigurationBuildId = projectConfigurationBuildId;
_artifactsFilePath = artifactsFilePath;
_targetArtifactsDirPath = targetArtifactsDirPath;
string archiveParentPath = string.Empty;
if (_projectInfo.ArtifactsAreEnvironmentSpecific)
{
archiveParentPath = string.Format("{0}/", _environmentInfo.ConfigurationTemplateName);
}
// eg. when artifacts are enviroment specific: Service/dev2/
_archiveSubPath =
!string.IsNullOrEmpty(_projectInfo.ArtifactsRepositoryDirName)
? string.Format("{0}{1}/", archiveParentPath, _projectInfo.ArtifactsRepositoryDirName)
: archiveParentPath;
}
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 List <ProjectConfigurationBuild> GetProjectConfigurationBuilds(string projectName, string projectConfigurationName, string branchName, int maxCount)
{
Guard.NotNullNorEmpty(projectName, "projectName");
Guard.NotNullNorEmpty(projectConfigurationName, "projectConfigurationName");
ProjectInfo projectInfo = _projectInfoRepository.FindByName(projectName);
TeamCityBuildType teamCityBuildType = _teamCityClient.GetBuildTypes(projectInfo.ArtifactsRepositoryName).FirstOrDefault(x => x.Name == projectConfigurationName);
if (teamCityBuildType == null)
{
return(new List <ProjectConfigurationBuild>());
}
IEnumerable <TeamCityBuild> projectConfigurationBuilds = _teamCityClient.GetBuilds(teamCityBuildType.Id, branchName, 0, maxCount, true);
return(projectConfigurationBuilds.Select(DtoMapper.Map <TeamCityBuild, ProjectConfigurationBuild>).ToList());
}
private ProjectConfigurationBuild GetLatestSuccessfulBuild(string projectName, string projectConfigurationName)
{
Guard.NotNullNorEmpty(projectName, "projectName");
Guard.NotNullNorEmpty(projectConfigurationName, "projectConfigurationName");
ProjectInfo projectInfo = _projectInfoRepository.FindByName(projectName);
TeamCityBuildType teamCityBuildType = _teamCityClient.GetBuildTypes(projectInfo.ArtifactsRepositoryName).FirstOrDefault(x => x.Name == projectConfigurationName);
if (teamCityBuildType == null)
{
return(null);
}
TeamCityBuild lastSuccessfulBuild = _teamCityClient.GetLastSuccessfulBuild(teamCityBuildType.Id);
ProjectConfigurationBuild projectConfigurationOfLastBuild = DtoMapper.Map <TeamCityBuild, ProjectConfigurationBuild>(lastSuccessfulBuild);
return(projectConfigurationOfLastBuild);
}
public List <string> GetProjectTargetFolders(string projectName, string environmentName)
{
if (string.IsNullOrEmpty(projectName))
{
throw new ArgumentException("Argument can't be null nor empty.", "projectName");
}
if (string.IsNullOrEmpty(environmentName))
{
throw new ArgumentException("Argument can't be null nor empty.", "environmentName");
}
ProjectInfo projectInfo =
_projectInfoRepository.FindByName(projectName);
if (projectInfo == null)
{
throw new FaultException <ProjectNotFoundFault>(new ProjectNotFoundFault {
ProjectName = projectName
});
}
EnvironmentInfo environmentInfo =
_environmentInfoRepository.FindByName(environmentName);
if (environmentInfo == null)
{
throw new FaultException <EnvironmentNotFoundFault>(new EnvironmentNotFoundFault {
EnvironmentName = environmentName
});
}
List <string> targetFolders =
projectInfo.GetTargetFolders(ObjectFactory.Instance, environmentInfo)
.ToList();
return(targetFolders);
}
public void CreatePackageAsync(Guid deploymentId, Guid uniqueClientId, string requesterIdentity, DeploymentInfo deploymentInfo, string packageDirPath)
{
try
{
Guard.NotEmpty(deploymentId, "deploymentId");
Guard.NotEmpty(uniqueClientId, "uniqueClientId");
Guard.NotNullNorEmpty(requesterIdentity, "requesterIdentity");
Guard.NotNull(deploymentInfo, "deploymentInfo");
ProjectInfo projectInfo =
_projectInfoRepository.FindByName(deploymentInfo.ProjectName);
if (projectInfo == null)
{
throw new FaultException <ProjectNotFoundFault>(new ProjectNotFoundFault {
ProjectName = deploymentInfo.ProjectName
});
}
ThreadPool.QueueUserWorkItem(
state =>
{
try
{
DoCreatePackage(uniqueClientId, requesterIdentity, deploymentInfo, projectInfo, packageDirPath);
}
catch (Exception exc)
{
HandleDeploymentException(exc, uniqueClientId);
}
});
}
catch (Exception exc)
{
HandleDeploymentException(exc, uniqueClientId);
}
}
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 Core.Domain.DeploymentInfo OverwriteConfigurationIfSelfDeployment(Core.Domain.DeploymentInfo deploymentInfo, ProjectInfo projectInfo)
{
if (projectInfo is UberDeployerAgentProjectInfo)
{
return new Core.Domain.DeploymentInfo(
deploymentInfo.DeploymentId,
deploymentInfo.IsSimulation,
deploymentInfo.ProjectName,
deploymentInfo.ProjectConfigurationName,
deploymentInfo.ProjectConfigurationBuildId,
_applicationConfiguration.AgentServiceEnvironmentName,
deploymentInfo.InputParams);
}
return deploymentInfo;
}
private void DoDeploy(Guid uniqueClientId, string requesterIdentity, Core.Domain.DeploymentInfo deploymentInfo, ProjectInfo projectInfo)
{
DeploymentTask deploymentTask = projectInfo.CreateDeploymentTask(ObjectFactory.Instance);
Core.Domain.DeploymentInfo deployInfo = OverwriteConfigurationIfSelfDeployment(deploymentInfo, projectInfo);
StartTask(deploymentTask, uniqueClientId, requesterIdentity, deployInfo);
}
private void DoCreatePackage(Guid uniqueClientId, string requesterIdentity, DeploymentInfo deploymentInfoDto, ProjectInfo projectInfo, string packageDirPath)
{
var deploymentTask =
new CreateManualDeploymentPackageDeploymentTask(
ObjectFactory.Instance.CreateProjectInfoRepository(),
ObjectFactory.Instance.CreateEnvironmentInfoRepository(),
ObjectFactory.Instance.CreateArtifactsRepository(),
ObjectFactory.Instance.CreateDirectoryAdapter(),
ObjectFactory.Instance.CreateFileAdapter(),
ObjectFactory.Instance.CreateZipFileAdapter(),
packageDirPath);
Core.Domain.DeploymentInfo deploymentInfo =
DtoMapper.ConvertDeploymentInfo(deploymentInfoDto, projectInfo);
StartTask(deploymentTask, uniqueClientId, requesterIdentity, deploymentInfo);
}
private static InputParams BuildInputParams(ProjectInfo projectInfo, EnvironmentInfo environmentInfo)
{
switch (projectInfo.Type)
{
case ProjectType.WebApp:
// deploy to all web server machines
return new WebAppInputParams(environmentInfo.WebServerMachineNames);
case ProjectType.Db:
return new DbInputParams();
case ProjectType.NtService:
return new NtServiceInputParams();
case ProjectType.SchedulerApp:
return new SsdtInputParams();
case ProjectType.TerminalApp:
return new SsdtInputParams();
case ProjectType.WebService:
return new SsdtInputParams();
case ProjectType.Extension:
return new ExtensionInputParams();
case ProjectType.PowerShellScript:
return new PowerShellInputParams();
default:
throw new DeploymentTaskException(string.Format("Project type: {0} is not supported in environment deployment.", projectInfo.Type));
}
}
private void DoCreatePackage(Guid uniqueClientId, string requesterIdentity, DeploymentInfo deploymentInfoDto, ProjectInfo projectInfo, string packageDirPath)
{
var deploymentTask =
new CreateManualDeploymentPackageDeploymentTask(
ObjectFactory.Instance.CreateProjectInfoRepository(),
ObjectFactory.Instance.CreateEnvironmentInfoRepository(),
ObjectFactory.Instance.CreateArtifactsRepository(),
ObjectFactory.Instance.CreateDirectoryAdapter(),
ObjectFactory.Instance.CreateFileAdapter(),
ObjectFactory.Instance.CreateZipFileAdapter(),
packageDirPath);
Core.Domain.DeploymentInfo deploymentInfo =
DtoMapper.ConvertDeploymentInfo(deploymentInfoDto, projectInfo);
StartTask(deploymentTask, uniqueClientId, requesterIdentity, deploymentInfo);
}
private void DoDeploy(Guid uniqueClientId, string requesterIdentity, Core.Domain.DeploymentInfo deploymentInfo, ProjectInfo projectInfo)
{
DeploymentTask deploymentTask = projectInfo.CreateDeploymentTask(ObjectFactory.Instance);
Core.Domain.DeploymentInfo deployInfo = OverwriteConfigurationIfSelfDeployment(deploymentInfo, projectInfo);
StartTask(deploymentTask, uniqueClientId, requesterIdentity, deployInfo);
}
public ProjectDeploymentData(DeploymentInfo deploymentInfo, ProjectInfo projectInfo, DeploymentTask deploymentTask)
{
DeploymentTask = deploymentTask;
DeploymentInfo = deploymentInfo;
ProjectInfo = projectInfo;
}
private ProjectMetadata GetOrdinaryProjectMetadata(ProjectInfo projectInfo, EnvironmentInfo environmentInfo)
{
var projectVersions = new List<MachineSpecificProjectVersion>();
IEnumerable<string> targetFolders =
projectInfo.GetTargetFolders(_objectFactory, environmentInfo);
foreach (string targetFolder in targetFolders)
{
_log.DebugIfEnabled(() => string.Format("Processing target folder: '{0}'.", targetFolder));
string machineName;
if (!TryExtractMachineName(targetFolder, out machineName))
{
machineName = "?";
}
string projectVersion;
string assemblyFilePath =
Path.Combine(targetFolder, projectInfo.GetMainAssemblyFileName());
// TODO IMM HI: temporary solution for getting version of web projects with main assemblies of form XXX.Web.dll or XXX.WebApp.dll.
if (projectInfo is WebAppProjectInfo)
{
string originalAssemblyFilePath = assemblyFilePath;
if (!File.Exists(assemblyFilePath))
{
assemblyFilePath = AddSuffixToFileName(originalAssemblyFilePath, ".Web");
}
if (!File.Exists(assemblyFilePath))
{
assemblyFilePath = AddSuffixToFileName(originalAssemblyFilePath, ".WebApp");
}
if (!File.Exists(assemblyFilePath))
{
assemblyFilePath = AddSuffixToFileName(originalAssemblyFilePath, ".Host");
}
}
if (File.Exists(assemblyFilePath))
{
FileVersionInfo fileVersionInfo =
FileVersionInfo.GetVersionInfo(assemblyFilePath);
projectVersion = fileVersionInfo.FileVersion;
}
else
{
projectVersion = "?";
}
projectVersions.Add(
new MachineSpecificProjectVersion(
machineName,
projectVersion));
}
return new ProjectMetadata(projectInfo.Name, environmentInfo.Name, projectVersions);
}
private void DoDeploy(Guid uniqueClientId, string requesterIdentity, DeploymentInfo deploymentInfoDto, ProjectInfo projectInfo)
{
DeploymentTask deploymentTask = projectInfo.CreateDeploymentTask(ObjectFactory.Instance);
StartTask(deploymentTask, uniqueClientId, requesterIdentity, deploymentInfoDto, projectInfo);
}
public ProjectDeploymentData(DeploymentInfo deploymentInfo, ProjectInfo projectInfo, DeploymentTask deploymentTask)
{
DeploymentTask = deploymentTask;
DeploymentInfo = deploymentInfo;
ProjectInfo = projectInfo;
}
private IEnumerable <ProjectDeploymentData> CreateProjectEnvironmentDeployments(Guid uniqueClientId, EnvironmentDeployInfo environmentDeployInfo, IEnumerable <ProjectToDeploy> projects)
{
var projectDeployments = new List <ProjectDeploymentData>();
var priorityProjectDeplyoments = new List <ProjectDeploymentData>();
EnvironmentInfo environmentInfo = _environmentInfoRepository.FindByName(environmentDeployInfo.TargetEnvironment);
if (environmentInfo == null)
{
throw new FaultException <EnvironmentNotFoundFault>(new EnvironmentNotFoundFault {
EnvironmentName = environmentDeployInfo.TargetEnvironment
});
}
foreach (var projectToDeploy in projects)
{
try
{
ProjectInfo projectInfo = _projectInfoRepository.FindByName(projectToDeploy.ProjectName);
if (projectInfo == null)
{
throw new DeploymentTaskException(string.Format("Not found configuration for project: {0}", projectToDeploy.ProjectName));
}
ProjectConfigurationBuild lastSuccessfulBuild = GetLatestSuccessfulBuild(projectToDeploy.ProjectName, environmentDeployInfo.BuildConfigurationName);
if (lastSuccessfulBuild == null)
{
throw new DeploymentTaskException(string.Format("Successful build not found for project: {0} and configuration: {1}", projectToDeploy, environmentDeployInfo.BuildConfigurationName));
}
InputParams inputParams = BuildInputParams(projectInfo, environmentInfo);
var deploymentInfo = new Core.Domain.DeploymentInfo(projectToDeploy.DeploymentId, false, projectToDeploy.ProjectName, environmentDeployInfo.BuildConfigurationName, lastSuccessfulBuild.Id, environmentDeployInfo.TargetEnvironment, inputParams);
DeploymentTask deploymentTask;
// TODO LK: could replace below code with factory
if (projectInfo.Type == ProjectType.Db)
{
DeploymentTask dropDbProjectDeploymentTask = new DropDbProjectDeploymentTask(
ObjectFactory.Instance.CreateProjectInfoRepository(),
ObjectFactory.Instance.CreateEnvironmentInfoRepository(),
ObjectFactory.Instance.CreateDbManagerFactory());
priorityProjectDeplyoments.Add(new ProjectDeploymentData(deploymentInfo, projectInfo, dropDbProjectDeploymentTask));
deploymentTask =
new DeployDbProjectDeploymentTask(
ObjectFactory.Instance.CreateProjectInfoRepository(),
ObjectFactory.Instance.CreateEnvironmentInfoRepository(),
ObjectFactory.Instance.CreateArtifactsRepository(),
ObjectFactory.Instance.CreateDbScriptRunnerFactory(),
ObjectFactory.Instance.CreateDbVersionProvider(),
ObjectFactory.Instance.CreateFileAdapter(),
ObjectFactory.Instance.CreateZipFileAdapter(),
ObjectFactory.Instance.CreateScriptsToRunWebSelectorForEnvironmentDeploy(),
ObjectFactory.Instance.CreateMsSqlDatabasePublisher(),
ObjectFactory.Instance.CreateDbManagerFactory(),
ObjectFactory.Instance.CreateUserNameNormalizer(),
ObjectFactory.Instance.CreateDirectoryAdapter());
}
else if (projectInfo.Type == ProjectType.NtService)
{
deploymentTask = new DeployNtServiceDeploymentTask(
ObjectFactory.Instance.CreateProjectInfoRepository(),
ObjectFactory.Instance.CreateEnvironmentInfoRepository(),
ObjectFactory.Instance.CreateArtifactsRepository(),
ObjectFactory.Instance.CreateNtServiceManager(),
ObjectFactory.Instance.CreatePasswordCollector(),
ObjectFactory.Instance.CreateFailoverClusterManager(),
ObjectFactory.Instance.CreateDirectoryAdapter(),
ObjectFactory.Instance.CreateFileAdapter(),
ObjectFactory.Instance.CreateZipFileAdapter())
{
UseLocalSystemUser = true
};
}
else
{
deploymentTask = projectInfo.CreateDeploymentTask(ObjectFactory.Instance);
}
projectDeployments.Add(new ProjectDeploymentData(deploymentInfo, projectInfo, deploymentTask));
}
catch (Exception e)
{
LogMessage(uniqueClientId, DiagnosticMessageType.Error, e.Message);
}
}
priorityProjectDeplyoments.AddRange(projectDeployments);
return(priorityProjectDeplyoments);
}
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 Core.Domain.DeploymentInfo OverwriteConfigurationIfSelfDeployment(Core.Domain.DeploymentInfo deploymentInfo, ProjectInfo projectInfo)
{
if (projectInfo is UberDeployerAgentProjectInfo)
{
return(new Core.Domain.DeploymentInfo(
deploymentInfo.DeploymentId,
deploymentInfo.IsSimulation,
deploymentInfo.ProjectName,
deploymentInfo.ProjectConfigurationName,
deploymentInfo.ProjectConfigurationBuildId,
_applicationConfiguration.AgentServiceEnvironmentName,
deploymentInfo.InputParams));
}
return(deploymentInfo);
}
public void SetUp()
{
_environmentInfo = DeploymentDataGenerator.GetEnvironmentInfo();
_deploymentInfo = DeploymentInfoGenerator.GetDbDeploymentInfo();
_projectInfo = ProjectInfoGenerator.GetTerminalAppProjectInfo();
_fileAdapterFake = new Mock<IFileAdapter>(MockBehavior.Loose);
_directoryAdapterFake = new Mock<IDirectoryAdapter>(MockBehavior.Loose);
_zipFileAdapterFake = new Mock<IZipFileAdapter>(MockBehavior.Loose);
_deploymentStep =
new ExtractArtifactsDeploymentStep(
_projectInfo,
_environmentInfo,
_deploymentInfo,
_ArtifactsFilePath,
_TargetArtifactsDirPath,
_fileAdapterFake.Object,
_directoryAdapterFake.Object,
_zipFileAdapterFake.Object);
}
public void SetUp()
{
_environmentInfo = DeploymentDataGenerator.GetEnvironmentInfo();
_projectInfo = DeploymentDataGenerator.GetDbProjectInfo();
_deploymentStep = new ExtractArtifactsDeploymentStep(
_environmentInfo,
_projectInfo,
_ProjectConfigurationName,
_ProjectConfigurationBuildId,
_ArtifactsFilePath,
_TargetArtifactsDirPath);
}
