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 void GetWebServerNetworkPath_WhenAbsoluteLocalPathIsCorrect_ReturnCorrectPath()
{
var envInfo =
new EnvironmentInfo(
_EnvironmentName,
true,
_ConfigurationTemplateName,
_AppServerMachine,
_FailoverClusterMachineName,
_WebMachineNames,
_TerminalMachineName,
_SchedulerServerTasksMachineNames,
_SchedulerServerBinariesMachineNames,
_NtServicesBaseDirPath,
_WebAppsBaseDirPath,
_SchedulerAppsBaseDirPath,
_TerminalAppsBaseDirPath,
false,
TestData.EnvironmentUsers,
TestData.AppPoolInfos,
TestData.DatabaseServers,
TestData.ProjectToFailoverClusterGroupMappings,
TestData.WebAppProjectConfigurationOverrides,
TestData.DbProjectConfigurationOverrides,
_TerminalAppsShortcutFolder,
_ArtifactsDeploymentDirPath,
_DomainName,
TestData.CustomEnvMachines);
Assert.AreEqual(
"\\\\" + _WebMachineNames[0] + "\\c$\\",
envInfo.GetWebServerNetworkPath(_WebMachineNames[0], "c:\\"));
}
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 override IEnumerable<string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo)
{
Guard.NotNull(objectFactory, "objectFactory");
Guard.NotNull(environmentInfo, "environmentInfo");
return
environmentInfo.TerminalAppsBaseDirPath
.Select(machineName => environmentInfo.GetSchedulerServerNetworkPath(machineName.ToString(), ""))
.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 override IEnumerable<string> GetTargetFolders(EnvironmentInfo environmentInfo)
{
if (environmentInfo == null)
{
throw new ArgumentNullException("environmentInfo");
}
return
new List<string>
{
environmentInfo.GetTerminalServerNetworkPath(
Path.Combine(environmentInfo.TerminalAppsBaseDirPath, TerminalAppDirName))
};
}
public string GetDefaultPackageDirPath(string environmentName, string projectName)
{
EnvironmentInfo environmentInfo = _environmentInfoRepository.FindByName(environmentName);
if (environmentInfo == null)
{
throw new FaultException <EnvironmentNotFoundFault>(new EnvironmentNotFoundFault {
EnvironmentName = environmentName
});
}
if (string.IsNullOrEmpty(environmentInfo.ManualDeploymentPackageDirPath))
{
return(null);
}
return(_dirPathParamsResolver.ResolveParams(environmentInfo.ManualDeploymentPackageDirPath, projectName));
}
public override IEnumerable<string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo)
{
Guard.NotNull(objectFactory, "objectFactory");
Guard.NotNull(environmentInfo, "environmentInfo");
WebAppProjectConfiguration configuration =
environmentInfo.GetWebAppProjectConfiguration(Name);
return
environmentInfo
.WebServerMachineNames
.Select(
wsmn =>
environmentInfo.GetWebServerNetworkPath(
wsmn,
Path.Combine(environmentInfo.WebAppsBaseDirPath, configuration.WebAppDirName)))
.ToList();
}
public static string CollectPasssword(IPasswordCollector passwordCollector, EnvironmentInfo environmentInfo, string machineName, string userId, out EnvironmentUser environmentUser)
{
if (passwordCollector == null)
{
throw new ArgumentNullException("passwordCollector");
}
if (environmentInfo == null)
{
throw new ArgumentNullException("environmentInfo");
}
if (string.IsNullOrEmpty(machineName))
{
throw new ArgumentException("Argument can't be null nor empty.", "machineName");
}
if (string.IsNullOrEmpty(userId))
{
throw new ArgumentException("Argument can't be null nor empty.", "userId");
}
environmentUser = environmentInfo.GetEnvironmentUserByName(userId);
if (environmentUser == null)
{
throw new InvalidOperationException(string.Format("There's no environment user with id '{0}' defined in environment named '{1}'.", userId, environmentInfo.Name));
}
string environmentUserPassword =
passwordCollector.CollectPasswordForUser(
environmentInfo.Name,
machineName,
environmentUser.UserName);
if (string.IsNullOrEmpty(environmentUserPassword))
{
throw new InvalidOperationException(string.Format("Couldn't obtain password for user named '{0}' for environment named '{1}'.", environmentUser.UserName, environmentInfo.Name));
}
return environmentUserPassword;
}
public List <string> GetWebMachineNames(string environmentName)
{
if (string.IsNullOrEmpty(environmentName))
{
throw new ArgumentException("Environment name can't be null or empty", "environmentName");
}
EnvironmentInfo environmentInfo = _environmentInfoRepository.FindByName(environmentName);
if (environmentInfo == null)
{
throw new FaultException <EnvironmentNotFoundFault>(
new EnvironmentNotFoundFault
{
EnvironmentName = environmentName
});
}
return(environmentInfo.WebServerMachineNames.ToList());
}
public IEnumerable<string> GetTargetUrls(EnvironmentInfo environmentInfo)
{
if (environmentInfo == null)
{
throw new ArgumentNullException("environmentInfo");
}
WebAppProjectConfiguration webAppProjectConfiguration =
environmentInfo.GetWebAppProjectConfiguration(Name);
// TODO IMM HI: what about https vs http?
return
environmentInfo.WebServerMachineNames
.Select(
wsmn =>
string.Format(
"http://{0}/{1}",
wsmn,
webAppProjectConfiguration.WebAppName))
.ToList();
}
public List <string> GetWebAppProjectTargetUrls(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");
}
WebAppProjectInfo webAppProjectInfo =
_projectInfoRepository.FindByName(projectName) as WebAppProjectInfo;
if (webAppProjectInfo == 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> targetUrls =
webAppProjectInfo.GetTargetUrls(environmentInfo)
.ToList();
return(targetUrls);
}
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 GetWebServerNetworkPath_WhenAbsoluteLocalPathIsCorrect_ReturnCorrectPath()
{
var envInfo =
new EnvironmentInfo(
_EnvironmentName,
_ConfigurationTemplateName,
_AppServerMachine,
_FailoverClusterMachineName,
_WebMachineNames,
_TerminalMachineName,
_DatabaseMachineName,
_NtServicesBaseDirPath,
_WebAppsBaseDirPath,
_SchedulerAppsBaseDirPath,
_TerminalAppsBaseDirPath,
false,
_EnvironmentUsers,
_ProjectToFailoverClusterGroupMappings);
Assert.AreEqual(
"\\\\" + _WebMachineNames[0] + "\\c$\\",
envInfo.GetWebServerNetworkPath(_WebMachineNames[0], "c:\\"));
}
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 abstract IEnumerable<string> GetTargetFolders(EnvironmentInfo environmentInfo);
public void Test_GetTargetFolders_RunsProperly_WhenAllIsWell()
{
string machine = Environment.MachineName;
const string baseDirPath = "c:\\basedir";
var envInfo =
new EnvironmentInfo(
"name",
true,
"templates",
machine,
"failover",
new[] { "webmachine" },
"terminalmachine",
new[] { "schedulerServerTasksMachineName1", "schedulerServerTasksMachineName2", },
new[] { "schedulerServerBinariesMachineName1", "schedulerServerBinariesMachineName2", },
baseDirPath,
"webbasedir",
"c:\\scheduler",
"terminal",
false,
TestData.EnvironmentUsers,
TestData.AppPoolInfos,
TestData.DatabaseServers,
TestData.ProjectToFailoverClusterGroupMappings,
TestData.WebAppProjectConfigurationOverrides,
TestData.DbProjectConfigurationOverrides,
"terminalAppsShortcutFolder",
"artifactsDeploymentDirPath",
"domain-name",
TestData.CustomEnvMachines);
var projectInfo =
new NtServiceProjectInfo(
_ProjectName,
_ArtifactsRepositoryName,
_AllowedEnvironmentNames,
_ArtifactsRepositoryDirName,
_ArtifactsAreNotEnvironmentSpecific,
_NtServiceName,
_NtServiceDirName,
_NtServiceDisplayName,
_NtServiceExeName,
_NtServiceUserId,
"");
var targetFolders = projectInfo.GetTargetFolders(_objectFactoryFake.Object, envInfo).ToList();
Assert.IsNotNull(targetFolders);
Assert.AreEqual(1, targetFolders.Count);
Assert.AreEqual("\\\\" + machine + "\\c$\\basedir\\" + _NtServiceDirName, targetFolders[0]);
}
public void SetUp()
{
_projectInfoRepositoryFake = new Mock<IProjectInfoRepository>();
_environmentInfoRepositoryFake = new Mock<IEnvironmentInfoRepository>();
_artifactsRepositoryFake = new Mock<IArtifactsRepository>();
_taskSchedulerFake = new Mock<ITaskScheduler>();
_passwordCollectorFake = new Mock<IPasswordCollector>();
_directoryAdapterFake = new Mock<IDirectoryAdapter>();
_fileAdapterFake = new Mock<IFileAdapter>();
_zipFileAdapterFake = new Mock<IZipFileAdapter>();
_projectInfo = ProjectInfoGenerator.GetSchedulerAppProjectInfo();
SchedulerAppTask schedulerAppTask1 = _projectInfo.SchedulerAppTasks.First();
SchedulerAppTask schedulerAppTask2 = _projectInfo.SchedulerAppTasks.Second();
_environmentInfo =
DeploymentDataGenerator.GetEnvironmentInfo(
new[]
{
new EnvironmentUser(schedulerAppTask1.UserId, "user_name_1"),
new EnvironmentUser(schedulerAppTask2.UserId, "user_name_2"),
});
_projectInfoRepositoryFake.Setup(pir => pir.FindByName(It.IsAny<string>()))
.Returns(_projectInfo);
string exeAbsolutePath1 =
Path.Combine(
_environmentInfo.SchedulerAppsBaseDirPath,
_projectInfo.SchedulerAppDirName,
schedulerAppTask1.ExecutableName);
var scheduledTaskRepetition1 =
new ScheduledTaskRepetition(
schedulerAppTask1.Repetition.Interval,
schedulerAppTask1.Repetition.Duration,
schedulerAppTask1.Repetition.StopAtDurationEnd);
ScheduledTaskDetails taskDetails1 =
GetTaskDetails(schedulerAppTask1, exeAbsolutePath1, true, false, scheduledTaskRepetition1);
ScheduledTaskDetails taskDetailsDisabled1 =
GetTaskDetails(schedulerAppTask1, exeAbsolutePath1, false, false, scheduledTaskRepetition1);
int timesCalled11 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.First(), schedulerAppTask1.Name))
.Returns(() =>
{
timesCalled11++;
if (timesCalled11 == 1)
{
return taskDetails1;
}
if (timesCalled11 == 2)
{
return taskDetailsDisabled1;
}
throw new Exception("Unexpected number of calls!");
});
int timesCalled21 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.Second(), schedulerAppTask1.Name))
.Returns(() =>
{
timesCalled21++;
if (timesCalled21 == 1)
{
return taskDetails1;
}
if (timesCalled21 == 2)
{
return taskDetailsDisabled1;
}
throw new Exception("Unexpected number of calls!");
});
string exeAbsolutePath2 =
Path.Combine(
_environmentInfo.SchedulerAppsBaseDirPath,
_projectInfo.SchedulerAppDirName,
schedulerAppTask2.ExecutableName);
var scheduledTaskRepetition2 =
new ScheduledTaskRepetition(
schedulerAppTask2.Repetition.Interval,
schedulerAppTask2.Repetition.Duration,
schedulerAppTask2.Repetition.StopAtDurationEnd);
ScheduledTaskDetails taskDetails2 =
GetTaskDetails(schedulerAppTask2, exeAbsolutePath2, true, false, scheduledTaskRepetition2);
ScheduledTaskDetails taskDetailsDisabled2 =
GetTaskDetails(schedulerAppTask2, exeAbsolutePath2, false, false, scheduledTaskRepetition2);
int timesCalled12 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.First(), schedulerAppTask2.Name))
.Returns(() =>
{
timesCalled12++;
if (timesCalled12 == 1)
{
return taskDetails2;
}
if (timesCalled12 == 2)
{
return taskDetailsDisabled2;
}
throw new Exception("Unexpected number of calls!");
});
int timesCalled22 = 0;
_taskSchedulerFake
.Setup(x => x.GetScheduledTaskDetails(_environmentInfo.SchedulerServerTasksMachineNames.Second(), schedulerAppTask2.Name))
.Returns(() =>
{
timesCalled22++;
if (timesCalled22 == 1)
{
return taskDetails2;
}
if (timesCalled22 == 2)
{
return taskDetailsDisabled2;
}
throw new Exception("Unexpected number of calls!");
});
_environmentInfoRepositoryFake
.Setup(x => x.FindByName(It.IsAny<string>()))
.Returns(_environmentInfo);
_directoryAdapterFake
.Setup(x => x.Exists(It.IsAny<string>()))
.Returns(true);
_deployTask =
new DeploySchedulerAppDeploymentTask(
_projectInfoRepositoryFake.Object,
_environmentInfoRepositoryFake.Object,
_artifactsRepositoryFake.Object,
_taskSchedulerFake.Object,
_passwordCollectorFake.Object,
_directoryAdapterFake.Object,
_fileAdapterFake.Object,
_zipFileAdapterFake.Object);
_deployTask.Initialize(DeploymentInfoGenerator.GetSchedulerAppDeploymentInfo());
}
public void Test_GetTargetFolders_RunsProperly_WhenAllIsWell()
{
string machine = Environment.MachineName;
const string baseDirPath = "c:\\basedir";
var envInfo =
new EnvironmentInfo(
"name",
"templates",
machine,
"failover",
new[] { "webmachine" },
"terminalmachine",
"databasemachine",
baseDirPath,
"webbasedir",
"c:\\scheduler",
"terminal",
false,
_EnvironmentUsers,
_ProjectToFailoverClusterGroupMappings);
var projectInfo =
new NtServiceProjectInfo(
_ProjectName,
_ArtifactsRepositoryName,
_ArtifactsRepositoryDirName,
_ArtifactsAreNotEnvironmentSpecific,
_NtServiceName,
_NtServiceDirName,
_NtServiceDisplayName,
_NtServiceExeName,
_NtServiceUserId);
var targetFolders = projectInfo.GetTargetFolders(envInfo).ToList();
Assert.IsNotNull(targetFolders);
Assert.AreEqual(1, targetFolders.Count);
Assert.AreEqual("\\\\" + machine + "\\c$\\basedir\\" + _NtServiceDirName, targetFolders[0]);
}
private bool HasSettingsChanged(ScheduledTaskDetails taskDetails, SchedulerAppTask schedulerAppTask, EnvironmentInfo environmentInfo)
{
if (taskDetails == null)
{
return false;
}
string taskExecutablePath = GetTaskExecutablePath(schedulerAppTask, environmentInfo);
return !(taskDetails.Name == schedulerAppTask.Name
&& taskDetails.ScheduledHour == schedulerAppTask.ScheduledHour
&& taskDetails.ScheduledMinute == schedulerAppTask.ScheduledMinute
&& taskDetails.ExecutionTimeLimitInMinutes == schedulerAppTask.ExecutionTimeLimitInMinutes
&& taskDetails.Repetition.Interval == schedulerAppTask.Repetition.Interval
&& taskDetails.Repetition.Duration == schedulerAppTask.Repetition.Duration
&& taskDetails.Repetition.StopAtDurationEnd == schedulerAppTask.Repetition.StopAtDurationEnd
&& taskDetails.ExeAbsolutePath == taskExecutablePath);
}
public void Test_GetTargetFolders_RunsProperly_WhenAllIsWell()
{
string machine = Environment.MachineName;
var envInfo =
new EnvironmentInfo(
"name",
"templates",
machine,
"failover",
new[] { "webmachine" },
"terminalmachine",
"databasemachine",
"C:\\basedir",
"C:\\basedir",
"c:\\scheduler",
"terminal",
false,
_EnvironmentUsers,
_ProjectToFailoverClusterGroupMappings);
var projectInfo =
new WebAppProjectInfo(
Name,
ArtifactsRepositoryName,
ArtifactsRepositoryDirName,
false,
IisSiteName,
WebAppName,
WebAppDirName,
AppPoolInfo);
Assert.IsNotNullOrEmpty(projectInfo.GetTargetFolders(envInfo).FirstOrDefault());
}
public override IEnumerable <string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo)
{
Guard.NotNull(objectFactory, "objectFactory");
Guard.NotNull(environmentInfo, "environmentInfo");
return
(environmentInfo.TerminalAppsBaseDirPath
.Select(machineName => environmentInfo.GetSchedulerServerNetworkPath(machineName.ToString(), ""))
.ToList());
}
public void Test_GetTargetFolde_RunsProperly_WhenAllIsWell()
{
string machine = Environment.MachineName;
const string baseDirPath = "c:\\basedir";
var envInfo =
new EnvironmentInfo(
"name",
true,
"templates",
"appservermachine",
"failover",
new[] { "webmachine" },
"terminalmachine",
new[] { machine },
new[] { machine },
baseDirPath,
"webbasedir",
"c:\\scheduler",
"terminal",
false,
TestData.EnvironmentUsers,
TestData.AppPoolInfos,
TestData.DatabaseServers,
TestData.ProjectToFailoverClusterGroupMappings,
TestData.WebAppProjectConfigurationOverrides,
TestData.DbProjectConfigurationOverrides,
"terminalAppsShortcutFolder",
"artifactsDeploymentDirPath",
"domain-name",
TestData.CustomEnvMachines);
var schedulerAppProjectInfo =
new SchedulerAppProjectInfo(
_ProjectName,
_ArtifactsRepositoryName,
_AllowedEnvironmentNames,
_ArtifactsRepositoryDirName,
_ArtifactsAreNotEnvirionmentSpecific,
_SchedulerAppDirName,
_SchedulerAppExeName,
new List<SchedulerAppTask>
{
new SchedulerAppTask(
_SchedulerAppName,
_SchedulerAppName,
_SchedulerAppUserId,
_ScheduledHour,
_ScheduledMinute,
_ExecutionTimeLimitInMinutes,
_Repetition)
});
List<string> targetFolders =
schedulerAppProjectInfo.GetTargetFolders(_objectFactoryFake.Object, envInfo)
.ToList();
Assert.IsNotNull(targetFolders);
Assert.AreEqual(1, targetFolders.Count);
Assert.AreEqual("\\\\" + machine + "\\c$\\scheduler\\" + _SchedulerAppDirName, targetFolders[0]);
}
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);
}
public override IEnumerable<string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo)
{
Guard.NotNull(objectFactory, "objectFactory");
Guard.NotNull(environmentInfo, "environmentInfo");
if (environmentInfo.EnableFailoverClusteringForNtServices)
{
IFailoverClusterManager failoverClusterManager =
objectFactory.CreateFailoverClusterManager();
string clusterGroupName =
environmentInfo.GetFailoverClusterGroupNameForProject(Name);
IEnumerable<string> possibleNodeNames =
failoverClusterManager.GetPossibleNodeNames(
environmentInfo.FailoverClusterMachineName,
clusterGroupName);
return
possibleNodeNames
.Select(node => EnvironmentInfo.GetNetworkPath(node, Path.Combine(environmentInfo.NtServicesBaseDirPath, NtServiceDirName)))
.ToList();
}
else
{
return
new List<string>
{
environmentInfo.GetAppServerNetworkPath(
Path.Combine(environmentInfo.NtServicesBaseDirPath, NtServiceDirName))
};
}
}
private void DoPrepareDeploymentToStandardEnvironment(EnvironmentInfo environmentInfo, Lazy<string> artifactsBinariesDirPathProvider)
{
Func<CollectedCredentials> collectCredentialsFunc =
() =>
{
if (UseLocalSystemUser)
{
return new CollectedCredentials(LocalSystemUserName);
}
EnvironmentUser environmentUser =
environmentInfo.GetEnvironmentUser(_projectInfo.NtServiceUserId);
string environmentUserPassword =
PasswordCollectorHelper.CollectPasssword(
_passwordCollector,
DeploymentInfo.DeploymentId,
environmentInfo,
environmentInfo.AppServerMachineName,
environmentUser,
OnDiagnosticMessagePosted);
return
new CollectedCredentials(
environmentUser.UserName,
environmentUserPassword);
};
DoPrepareCommonDeploymentSteps(
_projectInfo.NtServiceName,
environmentInfo.AppServerMachineName,
environmentInfo.NtServicesBaseDirPath,
environmentInfo.GetAppServerNetworkPath,
artifactsBinariesDirPathProvider,
collectCredentialsFunc,
true);
}
private void DoPrepareDeploymentToClusteredEnvironment(EnvironmentInfo environmentInfo, Lazy<string> artifactsBinariesDirPathProvider)
{
string clusterGroupName = environmentInfo.GetFailoverClusterGroupNameForProject(DeploymentInfo.ProjectName);
if (string.IsNullOrEmpty(clusterGroupName))
{
throw new InvalidOperationException(string.Format("There is no cluster group defined for project '{0}' in environment '{1}'.", DeploymentInfo.ProjectName, environmentInfo.Name));
}
string failoverClusterMachineName = environmentInfo.FailoverClusterMachineName;
if (string.IsNullOrEmpty(failoverClusterMachineName))
{
throw new InvalidOperationException(string.Format("Environment '{0}' has no failover cluster machine name defined.", environmentInfo.Name));
}
string currentNodeName =
_failoverClusterManager.GetCurrentNodeName(failoverClusterMachineName, clusterGroupName);
if (string.IsNullOrEmpty(currentNodeName))
{
throw new InvalidOperationException(string.Format("Cluster group '{0}' has no current node in a cluster '{1}' in environment '{2}'.", clusterGroupName, environmentInfo.FailoverClusterMachineName, environmentInfo.Name));
}
PostDiagnosticMessage(string.Format("Current node: '{0}'.", currentNodeName), DiagnosticMessageType.Trace);
List<string> possibleNodeNames =
_failoverClusterManager.GetPossibleNodeNames(failoverClusterMachineName, clusterGroupName)
.ToList();
PostDiagnosticMessage(string.Format("Possible nodes: {0}.", string.Join(", ", possibleNodeNames.Select(n => string.Format("'{0}'", n)))), DiagnosticMessageType.Trace);
if (possibleNodeNames.Count < 2)
{
throw new InvalidOperationException(string.Format("There is only one possible node for cluster group '{0}' in a cluster '{1}' in environment '{2}'.", clusterGroupName, environmentInfo.FailoverClusterMachineName, environmentInfo.Name));
}
// update nt service on all machines other than current owner node
CollectedCredentials cachedCollectedCredentials = null;
Func<string, Func<CollectedCredentials>> collectCredentialsFunc =
machineName =>
() =>
{
// ReSharper disable AccessToModifiedClosure
if (cachedCollectedCredentials != null)
{
return cachedCollectedCredentials;
}
// ReSharper restore AccessToModifiedClosure
if (UseLocalSystemUser)
{
cachedCollectedCredentials = new CollectedCredentials(LocalSystemUserName);
}
else
{
EnvironmentUser environmentUser =
environmentInfo.GetEnvironmentUser(_projectInfo.NtServiceUserId);
string environmentUserPassword =
PasswordCollectorHelper.CollectPasssword(
_passwordCollector,
DeploymentInfo.DeploymentId,
environmentInfo,
machineName,
environmentUser,
OnDiagnosticMessagePosted);
cachedCollectedCredentials =
new CollectedCredentials(
environmentUser.UserName,
environmentUserPassword);
}
return cachedCollectedCredentials;
};
foreach (string possibleNodeName in possibleNodeNames)
{
string machineName = possibleNodeName;
if (string.Equals(machineName, currentNodeName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
DoPrepareCommonDeploymentSteps(
_projectInfo.NtServiceName,
machineName,
environmentInfo.NtServicesBaseDirPath,
absoluteLocalPath => EnvironmentInfo.GetNetworkPath(machineName, absoluteLocalPath),
artifactsBinariesDirPathProvider,
collectCredentialsFunc(machineName),
false);
}
// move cluster group to another node
string targetNodeName =
possibleNodeNames.FirstOrDefault(nodeName => nodeName != currentNodeName);
PostDiagnosticMessage(string.Format("Target node: '{0}'.", targetNodeName), DiagnosticMessageType.Trace);
if (string.IsNullOrEmpty(targetNodeName))
{
throw new InvalidOperationException(string.Format("There is no node in cluster '{0}' that we can move cluster group '{1}' to.", failoverClusterMachineName, clusterGroupName));
}
AddSubTask(
new MoveClusterGroupToAnotherNodeDeploymentStep(
_failoverClusterManager,
failoverClusterMachineName,
clusterGroupName,
targetNodeName));
// update nt service on the machine that was the previous owner node
string previousMachineName = currentNodeName;
DoPrepareCommonDeploymentSteps(
_projectInfo.NtServiceName,
previousMachineName,
environmentInfo.NtServicesBaseDirPath,
absoluteLocalPath => EnvironmentInfo.GetNetworkPath(previousMachineName, absoluteLocalPath),
artifactsBinariesDirPathProvider,
collectCredentialsFunc(previousMachineName),
false);
}
public override IEnumerable<string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo)
{
throw new NotSupportedException();
}
public override IEnumerable <string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo)
{
throw new NotSupportedException();
}
public void Test_GetAppServerNetworkPath_Throws_When_path_startswithbackslashes()
{
var envInfo = new EnvironmentInfo(
_EnvironmentName,
true,
_ConfigurationTemplateName,
_AppServerMachine,
_FailoverClusterMachineName,
_WebMachineNames,
_TerminalMachineName,
_SchedulerServerTasksMachineNames,
_SchedulerServerBinariesMachineNames,
_NtServicesBaseDirPath,
_WebAppsBaseDirPath,
_SchedulerAppsBaseDirPath,
_TerminalAppsBaseDirPath,
false,
TestData.EnvironmentUsers,
TestData.AppPoolInfos,
TestData.DatabaseServers,
TestData.ProjectToFailoverClusterGroupMappings,
TestData.WebAppProjectConfigurationOverrides,
TestData.DbProjectConfigurationOverrides,
_TerminalAppsShortcutFolder,
_ArtifactsDeploymentDirPath,
_DomainName,
TestData.CustomEnvMachines);
Assert.Throws<ArgumentException>(
() => envInfo.GetAppServerNetworkPath(@"\\kasjdkasdj"));
}
public override IEnumerable<string> GetTargetFolders(EnvironmentInfo environmentInfo)
{
if (environmentInfo == null)
{
throw new ArgumentNullException("environmentInfo");
}
// TODO IMM HI: this might be wrong (due to msdeploy)!
return
environmentInfo
.WebServerMachineNames
.Select(
wsmn =>
environmentInfo.GetWebServerNetworkPath(
wsmn,
Path.Combine(environmentInfo.WebAppsBaseDirPath, WebAppDirName)))
.ToList();
}
public abstract IEnumerable <string> GetTargetFolders(IObjectFactory objectFactory, EnvironmentInfo environmentInfo);
private string GetTaskExecutablePath(SchedulerAppTask schedulerAppTask, EnvironmentInfo environmentInfo)
{
string targetDirPath = GetTargetDirPath(environmentInfo);
return Path.Combine(targetDirPath, schedulerAppTask.ExecutableName);
}
public void Test_GetTargetUrls_RunsProperly_WhenAllIsWell()
{
string machine = Environment.MachineName;
const string baseDirPath = "c:\\basedir";
var envInfo =
new EnvironmentInfo(
"name",
"templates",
machine,
"failover",
new[] { "webmachine" },
"terminalmachine",
"databasemachine",
baseDirPath,
"webbasedir",
"c:\\scheduler",
"terminal",
false,
_EnvironmentUsers,
_ProjectToFailoverClusterGroupMappings);
var projectInfo =
new WebAppProjectInfo(
Name,
ArtifactsRepositoryName,
ArtifactsRepositoryDirName,
ArtifactsAreNotEnvironmentSpecific,
IisSiteName,
WebAppName,
WebAppDirName,
AppPoolInfo);
List<string> targetUrls =
projectInfo.GetTargetUrls(envInfo)
.ToList();
Assert.IsNotNull(targetUrls);
Assert.AreEqual(1, targetUrls.Count);
Assert.AreEqual("http://webmachine/" + WebAppName, targetUrls[0]);
}
private void AddTaskConfigurationSteps(EnvironmentInfo environmentInfo, string schedulerServerTasksMachineName, SchedulerAppTask schedulerAppTask, ScheduledTaskDetails taskDetails = null)
{
bool hasSettingsChanged = HasSettingsChanged(taskDetails, schedulerAppTask, environmentInfo);
bool taskExists = taskDetails != null;
EnvironmentUser environmentUser =
environmentInfo.GetEnvironmentUserById(schedulerAppTask.UserId);
string environmentUserPassword = null;
if (!taskExists || hasSettingsChanged)
{
// collect password if not already collected
if (!_collectedPasswordsByUserName.TryGetValue(environmentUser.UserName, out environmentUserPassword))
{
environmentUserPassword =
PasswordCollectorHelper.CollectPasssword(
_passwordCollector,
DeploymentInfo.DeploymentId,
environmentInfo,
schedulerServerTasksMachineName,
environmentUser,
OnDiagnosticMessagePosted);
_collectedPasswordsByUserName.Add(environmentUser.UserName, environmentUserPassword);
}
}
string taskExecutablePath =
GetTaskExecutablePath(schedulerAppTask, environmentInfo);
if (!taskExists)
{
// create a step for scheduling a new app
AddSubTask(
new CreateSchedulerTaskDeploymentStep(
schedulerServerTasksMachineName,
schedulerAppTask.Name,
taskExecutablePath,
environmentUser.UserName,
environmentUserPassword,
schedulerAppTask.ScheduledHour,
schedulerAppTask.ScheduledMinute,
schedulerAppTask.ExecutionTimeLimitInMinutes,
schedulerAppTask.Repetition,
_taskScheduler));
}
else if (hasSettingsChanged)
{
// create a step for updating an existing scheduler app
AddSubTask(
new UpdateSchedulerTaskDeploymentStep(
schedulerServerTasksMachineName,
schedulerAppTask.Name,
taskExecutablePath,
environmentUser.UserName,
environmentUserPassword,
schedulerAppTask.ScheduledHour,
schedulerAppTask.ScheduledMinute,
schedulerAppTask.ExecutionTimeLimitInMinutes,
schedulerAppTask.Repetition,
_taskScheduler));
}
}
public void Test_InstallNtServiceDeploymentStepServiceDirPathDoesntExist()
{
const string serviceName = "serviceName";
const string serviceDir = "serviceDir";
const string artifactsRepo = "artifactsRepo";
const string projectName = "projectName";
const string buildID = "id";
const string envName = "envName";
const string baseDirPath = "c:\\basedir";
string machine = Environment.MachineName;
var ntServiceProjectInfo =
new NtServiceProjectInfo(
"name",
artifactsRepo,
"artifactsRepoDir",
false,
serviceName,
serviceDir,
"serviceDisplayed",
"exeName",
"Sample.User");
var envInfo =
new EnvironmentInfo(
"name",
"templates",
machine,
"failover",
new[] { "webmachine" },
"terminalmachine",
"databasemachine",
baseDirPath,
"webbasedir",
"scheduler",
"terminal",
false,
_EnvironmentUsers,
_ProjectToFailoverClusterGroupMappings);
_environmentInfoRepository
.Setup(e => e.GetByName(envName))
.Returns(envInfo);
_passwordCollector
.Setup(pc => pc.CollectPasswordForUser(envInfo.Name, envInfo.AppServerMachineName, envInfo.GetEnvironmentUserByName(ntServiceProjectInfo.NtServiceUserId).UserName))
.Returns("some password");
_ntServiceManager
.Setup(n => n.DoesServiceExist(machine, serviceName))
.Returns(false);
_artifactsRepository
.Setup(a => a.GetArtifacts(artifactsRepo,projectName, buildID, It.IsAny<string>()));
var deployNTService =
new DeployNtServiceDeploymentTask(
_environmentInfoRepository.Object,
_artifactsRepository.Object,
_ntServiceManager.Object,
_passwordCollector.Object,
_failoverClusterManager.Object,
ntServiceProjectInfo,
projectName,
buildID,
envName);
Assert.Throws<DeploymentTaskException>(deployNTService.PrepareAndExecute);
}
private string GetTargetDirPath(EnvironmentInfo environmentInfo)
{
return Path.Combine(environmentInfo.SchedulerAppsBaseDirPath, _projectInfo.SchedulerAppDirName);
}
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);
}
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,
_zipFileAdapter);
AddSubTask(extractArtifactsDeploymentStep);
if (_projectInfo.ArtifactsAreEnvironmentSpecific)
{
var binariesConfiguratorStep =
new ConfigureBinariesStep(
environmentInfo.ConfigurationTemplateName,
GetTempDirPath());
AddSubTask(binariesConfiguratorStep);
}
return new Lazy<string>(() => extractArtifactsDeploymentStep.BinariesDirPath);
}
