protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
var projectInfo = GetProjectInfo <ProjectInfo>();
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
AddSubTask(
new CopyFilesDeploymentStep(
_directoryAdapter,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
new Lazy <string>(() => PreparePackageDirPath(PackageDirPath))));
}
private Lazy <string> AddStepsToObtainBinaries(EnvironmentInfo environmentInfo)
{
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
_projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
_projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (_projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
return(new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath));
}
protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
_projectInfo = GetProjectInfo <NtServiceProjectInfo>();
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
_projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
_projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (_projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
bool deployToClusteredEnvironment =
environmentInfo.EnableFailoverClusteringForNtServices;
if (deployToClusteredEnvironment)
{
PostDiagnosticMessage("Will deploy to a clustered environment.", DiagnosticMessageType.Trace);
if (string.IsNullOrEmpty(environmentInfo.GetFailoverClusterGroupNameForProject(DeploymentInfo.ProjectName)))
{
throw new InvalidOperationException(string.Format("Failover clustering for NT services is enabled for environment '{0}' but there is no cluster group mapping for project '{1}'.", environmentInfo.Name, DeploymentInfo.ProjectName));
}
DoPrepareDeploymentToClusteredEnvironment(
environmentInfo,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath));
}
else
{
PostDiagnosticMessage("Will deploy to a non-clustered environment.", DiagnosticMessageType.Trace);
DoPrepareDeploymentToStandardEnvironment(
environmentInfo,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath));
}
}
protected override void DoPrepare()
{
_environmentInfo = GetEnvironmentInfo();
_projectInfo = GetProjectInfo <ExtensionProjectInfo>();
_extendedProjectInfo = GetProjectInfo <NtServiceProjectInfo>(_projectInfo.ExtendedProjectName);
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
_projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
_projectInfo,
_environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
bool deployToClusteredEnvironment =
_environmentInfo.EnableFailoverClusteringForNtServices;
if (deployToClusteredEnvironment)
{
PostDiagnosticMessage("Will deploy to a clustered environment.", DiagnosticMessageType.Trace);
if (string.IsNullOrEmpty(_environmentInfo.GetFailoverClusterGroupNameForProject(_extendedProjectInfo.Name)))
{
throw new InvalidOperationException(string.Format("Failover clustering for NT services is enabled for environment '{0}' but there is no cluster group mapping for project '{1}'.", _environmentInfo.Name, _extendedProjectInfo.Name));
}
DoPrepareDeploymentToClusteredEnvironment(
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
_extendedProjectInfo);
}
else
{
PostDiagnosticMessage("Will deploy to a non-clustered environment.", DiagnosticMessageType.Trace);
AddSubTask(
new StopNtServiceDeploymentStep(
_ntServiceManager,
_environmentInfo.AppServerMachineName,
_extendedProjectInfo.NtServiceName));
DoPrepareCommonDeploymentSteps(_environmentInfo.GetAppServerNetworkPath, new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath));
AddSubTask(
new StartNtServiceDeploymentStep(
_ntServiceManager,
_environmentInfo.AppServerMachineName,
_extendedProjectInfo.NtServiceName));
}
}
protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
WebAppProjectInfo projectInfo = GetProjectInfo <WebAppProjectInfo>();
WebAppInputParams inputParams = (WebAppInputParams)DeploymentInfo.InputParams;
if (inputParams.OnlyIncludedWebMachines != null)
{
if (!inputParams.OnlyIncludedWebMachines.Any())
{
throw new DeploymentTaskException("If inputParams OnlyIncludedWebMachines has been specified, it must contain at least one web machine.");
}
string[] invalidMachineNames =
inputParams.OnlyIncludedWebMachines
.Except(environmentInfo.WebServerMachineNames)
.ToArray();
if (invalidMachineNames.Any())
{
throw new DeploymentTaskException(string.Format("Invalid web machines '{0}' have been specified.", string.Join(",", invalidMachineNames)));
}
}
if (projectInfo == null)
{
throw new InvalidOperationException(string.Format("Project info must be of type '{0}'.", typeof(WebAppProjectInfo).FullName));
}
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
WebAppProjectConfiguration configuration =
environmentInfo.GetWebAppProjectConfiguration(projectInfo);
CheckConfiguration(configuration);
string webSiteName = configuration.WebSiteName;
string webAppName = configuration.WebAppName;
IisAppPoolInfo appPoolInfo = environmentInfo.GetAppPoolInfo(configuration.AppPoolId);
IEnumerable <string> webMachinesToDeployTo =
(inputParams.OnlyIncludedWebMachines ?? environmentInfo.WebServerMachineNames)
.Distinct();
foreach (string webServerMachineName in webMachinesToDeployTo)
{
/* // TODO IMM HI: xxx we don't need this for now - should we parameterize this somehow?
* string webApplicationPhysicalPath =
* _iisManager.GetWebApplicationPath(
* webServerMachineName,
* string.Format("{0}/{1}", webSiteName, webAppName));
*
* if (!string.IsNullOrEmpty(webApplicationPhysicalPath))
* {
* string webApplicationNetworkPath =
* string.Format(
* "\\\\{0}\\{1}${2}",
* webServerMachineName,
* webApplicationPhysicalPath[0],
* webApplicationPhysicalPath.Substring(2));
*
* if (Directory.Exists(webApplicationNetworkPath))
* {
* var backupFilesDeploymentStep =
* new BackupFilesDeploymentStep(
* webApplicationNetworkPath);
*
* AddSubTask(backupFilesDeploymentStep);
* }
* }
*/
// create a step for creating a WebDeploy package
// TODO IMM HI: add possibility to specify physical path on the target machine
var createWebDeployPackageDeploymentStep =
new CreateWebDeployPackageDeploymentStep(
_msDeploy,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
webSiteName,
webAppName);
AddSubTask(createWebDeployPackageDeploymentStep);
// create a step for deploying the WebDeploy package to the target machine
var deployWebDeployPackageDeploymentStep =
new DeployWebDeployPackageDeploymentStep(
_msDeploy,
webServerMachineName,
new Lazy <string>(() => createWebDeployPackageDeploymentStep.PackageFilePath));
AddSubTask(deployWebDeployPackageDeploymentStep);
// check if the app pool exists on the target machine
if (_applicationConfiguration.CheckIfAppPoolExists && !_iisManager.AppPoolExists(webServerMachineName, appPoolInfo.Name))
{
// create a step for creating a new app pool
var createAppPoolDeploymentStep =
new CreateAppPoolDeploymentStep(
_iisManager,
webServerMachineName,
appPoolInfo);
AddSubTask(createAppPoolDeploymentStep);
// create a step for assigning the app pool to the web application
var setAppPoolDeploymentStep =
new SetAppPoolDeploymentStep(
_iisManager,
webServerMachineName,
webSiteName,
appPoolInfo,
webAppName);
AddSubTask(setAppPoolDeploymentStep);
}
}
}
protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
_projectInfo = GetProjectInfo <PowerShellScriptProjectInfo>();
IEnumerable <string> targetMachineNames = _projectInfo.GetTargetMachines(environmentInfo);
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
_projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
_projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (_projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
if (_projectInfo.IsRemote == false)
{
// Run powershell script
var runPowerShellScriptStep =
new RunPowerShellScriptStep(
_projectInfo.IsRemote,
null,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
_projectInfo.ScriptName);
AddSubTask(runPowerShellScriptStep);
return;
}
foreach (var targetMachineName in targetMachineNames)
{
// Create temp dir on remote machine
var createRemoteTempDirStep = new CreateRemoteTempDirStep(targetMachineName);
AddSubTask(createRemoteTempDirStep);
// Copy files to remote machine
string machineName = targetMachineName;
var copyFilesDeploymentStep = new CopyFilesDeploymentStep(
_directoryAdapter,
srcDirPathProvider: new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
dstDirPath: new Lazy <string>(() => EnvironmentInfo.GetNetworkPath(machineName, createRemoteTempDirStep.RemoteTempDirPath)));
AddSubTask(copyFilesDeploymentStep);
// Run powershell script
var runPowerShellScriptStep =
new RunPowerShellScriptStep(
_projectInfo.IsRemote,
targetMachineName,
new Lazy <string>(() => createRemoteTempDirStep.RemoteTempDirPath),
_projectInfo.ScriptName);
AddSubTask(runPowerShellScriptStep);
// Delete remote temp dir
var removeRemoteDirectory = new RemoveRemoteDirectoryStep(
targetMachineName,
new Lazy <string>(() => createRemoteTempDirStep.RemoteTempDirPath));
AddSubTask(removeRemoteDirectory);
}
}
protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
DbProjectInfo projectInfo = GetProjectInfo <DbProjectInfo>();
DbProjectConfiguration dbProjectConfiguration =
environmentInfo.GetDbProjectConfiguration(projectInfo);
DatabaseServer databaseServer =
environmentInfo.GetDatabaseServer(dbProjectConfiguration.DatabaseServerId);
string databaseServerMachineName = databaseServer.MachineName;
bool databaseExists = _dbVersionProvider.CheckIfDatabaseExists(
projectInfo.DbName,
databaseServerMachineName);
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (databaseExists)
{
// create a step for gathering scripts to run
var gatherDbScriptsToRunDeploymentStep = new GatherDbScriptsToRunDeploymentStep(
projectInfo.DbName,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
databaseServerMachineName,
environmentInfo.Name,
DeploymentInfo,
_dbVersionProvider,
_createScriptsToRunSelector
);
AddSubTask(gatherDbScriptsToRunDeploymentStep);
// create a step for running scripts
var runDbScriptsDeploymentStep = new RunDbScriptsDeploymentStep(
GetScriptRunner(projectInfo.IsTransactional, databaseServerMachineName, projectInfo.DbName, environmentInfo.DatabaseServers.FirstOrDefault(e => e.Id == projectInfo.DatabaseServerId)),
databaseServerMachineName,
new DeferredEnumerable <DbScriptToRun>(() => gatherDbScriptsToRunDeploymentStep.ScriptsToRun));
AddSubTask(runDbScriptsDeploymentStep);
}
else
{
// create step for dropping database
var createDatabaseDeploymentStep = new CreateDatabaseDeploymentStep(projectInfo, databaseServer, _dbManagerFactory);
AddSubTask(createDatabaseDeploymentStep);
// create step for deploying dacpac
var publishDatabaseDeploymentStep =
new PublishDatabaseDeploymentStep(
projectInfo,
databaseServer,
GetTempDirPath(),
_databasePublisher);
AddSubTask(publishDatabaseDeploymentStep);
}
foreach (string userId in projectInfo.Users)
{
var environmentUser = environmentInfo.EnvironmentUsers.SingleOrDefault(x => x.Id == userId);
if (environmentUser == null)
{
throw new DeploymentTaskException(string.Format("User [{0}] doesn't exist in enviroment configuration [{1}] in project [{2}]", userId, environmentInfo.Name, projectInfo.Name));
}
string user = _userNameNormalizer.ConvertToPreWin2000UserName(environmentUser.UserName, environmentInfo.DomainName);
IDbManager manager = _dbManagerFactory.CreateDbManager(databaseServerMachineName);
if (databaseExists && manager.UserExists(projectInfo.DbName, user))
{
foreach (string dbUserRole in _dbUserRoles)
{
if (!manager.CheckIfUserIsInRole(projectInfo.DbName, user, dbUserRole))
{
AddSubTask(new AddRoleToUserStep(manager, projectInfo.DbName, user, dbUserRole));
}
}
}
else
{
AddSubTask(new AddUserToDatabaseStep(manager, projectInfo.DbName, user));
foreach (string dbUserRole in _dbUserRoles)
{
AddSubTask(new AddRoleToUserStep(manager, projectInfo.DbName, user, dbUserRole));
}
}
}
}
protected override void DoPrepare()
{
EnvironmentInfo environmentInfo = GetEnvironmentInfo();
TerminalAppProjectInfo projectInfo = GetProjectInfo <TerminalAppProjectInfo>();
// create a step for downloading the artifacts
var downloadArtifactsDeploymentStep =
new DownloadArtifactsDeploymentStep(
projectInfo,
DeploymentInfo,
GetTempDirPath(),
_artifactsRepository);
AddSubTask(downloadArtifactsDeploymentStep);
// create a step for extracting the artifacts
var extractArtifactsDeploymentStep =
new ExtractArtifactsDeploymentStep(
projectInfo,
environmentInfo,
DeploymentInfo,
downloadArtifactsDeploymentStep.ArtifactsFilePath,
GetTempDirPath(),
_fileAdapter,
_directoryAdapter,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
var extractVersionDeploymentStep =
new ExtractVersionDeploymentStep(
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
projectInfo.TerminalAppExeName
);
AddSubTask(extractVersionDeploymentStep);
var prepareVersionedFolderDeploymentStep =
new PrepareVersionedFolderDeploymentStep(
DeploymentInfo.ProjectName,
environmentInfo.GetTerminalServerNetworkPath(environmentInfo.TerminalAppsBaseDirPath),
projectInfo.TerminalAppDirName,
new Lazy <string>(() => extractVersionDeploymentStep.Version));
AddSubTask(prepareVersionedFolderDeploymentStep);
AddSubTask(
new CleanDirectoryDeploymentStep(
_directoryAdapter,
_fileAdapter,
new Lazy <string>(() => prepareVersionedFolderDeploymentStep.VersionDeploymentDirPath),
excludedDirs: new string[] { }));
AddSubTask(
new CopyFilesDeploymentStep(
_directoryAdapter,
new Lazy <string>(() => extractArtifactsDeploymentStep.BinariesDirPath),
new Lazy <string>(() => prepareVersionedFolderDeploymentStep.VersionDeploymentDirPath)));
AddSubTask(
new UpdateApplicationShortcutDeploymentStep(
environmentInfo.GetTerminalServerNetworkPath(environmentInfo.TerminalAppsShortcutFolder),
new Lazy <string>(() => prepareVersionedFolderDeploymentStep.VersionDeploymentDirPath),
projectInfo.TerminalAppExeName,
projectInfo.Name));
}
