public void EvaluateTests(string taskSiteName, bool appPoolExists, bool siteExists, int errorsCount, string appPoolValidationMessage, string siteValidationMessage)
{
// Arrange
var fixture = new Fixture();
var task = Substitute.For <Task>(TaskName, fixture.Create <int>(), null, new List <InstallParam>(), new Dictionary <string, string>());
InstallParam siteNameParam = new InstallParam(SiteName, taskSiteName);
List <InstallParam> paramList = new List <InstallParam>
{
siteNameParam
};
task.LocalParams.Returns(paramList);
var validator = Substitute.ForPartsOf <AppPoolSiteValidator>();
validator.AppPoolExists(taskSiteName).Returns(appPoolExists);
validator.SiteExists(taskSiteName).Returns(siteExists);
// Act
IEnumerable <ValidationResult> result = validator.Evaluate(new Task[] { task });
IEnumerable <ValidationResult> errors = result.Where(r => r.State == ValidatorState.Error);
// Assert
Assert.Equal(errors.Count(), errorsCount);
this.ValidateMessage(appPoolValidationMessage, taskSiteName, SiteName, task.Name, errors);
this.ValidateMessage(siteValidationMessage, taskSiteName, SiteName, task.Name, errors);
}
public void ReturnsValidValidationResults(bool fileExists, ValidatorState expectedResult)
{
//Arrange
Task task = Substitute.For <Task>("", 0, null, new List <InstallParam>(), new Dictionary <string, string>());
task.LocalParams.Returns(new List <InstallParam>());
InstallParam licenseFileParam = new InstallParam("LicenseFile", @"C:\license.xml");
task.LocalParams.Add(licenseFileParam);
List <Task> tasks = Substitute.For <List <Task> >();
tasks.Add(task);
LicenseFileValidator val = Substitute.ForPartsOf <LicenseFileValidator>();
val.FileExists(string.Empty).ReturnsForAnyArgs(fileExists);
val.Data["LicenseFileVariable"] = "LicenseFile";
//Act
IEnumerable <ValidationResult> results = val.Evaluate(tasks);
//Assert
Assert.Contains(results, r => r.State == expectedResult);
}
public bool OnMovingNext(WizardArgs wizardArgs)
{
var args = (Delete9WizardArgs)wizardArgs;
args.ScriptsOnly = this.scriptsOnly.IsChecked ?? false;
args.ScriptRoot = args.Tasker.GlobalParams.FirstOrDefault(p => p.Name == "FilesRoot").Value;
Tasker tasker = args.Tasker;
tasker.GlobalParams.FirstOrDefault(p => p.Name == "FilesRoot").Value = args.ScriptRoot;
InstallParam sqlServer = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlServer");
if (sqlServer != null)
{
sqlServer.Value = args.InstanceConnectionString.DataSource;
}
InstallParam sqlAdminUser = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlAdminUser");
if (sqlAdminUser != null)
{
sqlAdminUser.Value = args.InstanceConnectionString.UserID;
}
InstallParam sqlAdminPass = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlAdminPassword");
if (sqlAdminPass != null)
{
sqlAdminPass.Value = args.InstanceConnectionString.Password;
}
return(true);
}
private SitecoreEnvironment CreateSitecoreEnvironment(Tasker tasker, string sqlDbPrefix, string uninstallDataPath)
{
SitecoreEnvironment sitecoreEnvironment = new SitecoreEnvironment(sqlDbPrefix);
sitecoreEnvironment.UnInstallDataPath = uninstallDataPath;
sitecoreEnvironment.Members = new List <SitecoreEnvironmentMember>();
foreach (Task powerShellTask in tasker.Tasks)
{
InstallParam installParam = powerShellTask.LocalParams.FirstOrDefault(x => x.Name == SiteName);
if (installParam != null && !string.IsNullOrEmpty(installParam.Value))
{
Hashtable evaluatedLocalParams = tasker.GetEvaluatedLocalParams(powerShellTask.LocalParams, tasker.GlobalParams);
if (evaluatedLocalParams != null && evaluatedLocalParams[SiteName] != null)
{
sitecoreEnvironment.Members.Add(new SitecoreEnvironmentMember(evaluatedLocalParams[SiteName].ToString(),
SitecoreEnvironmentMember.Types.Site.ToString()));
}
}
}
sitecoreEnvironment.Members = sitecoreEnvironment.Members.Distinct(new SitecoreEnvironmentMemberComparer()).ToList();
return(sitecoreEnvironment);
}
protected override void Process([NotNull] ProcessorArgs args)
{
Install9Args arguments = (Install9Args)args;
if (!arguments.Tasker.UnInstall || arguments.ScriptsOnly)
{
this.Skip();
return;
}
InstallParam sqlDbPrefixParam = arguments.Tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlDbPrefix");
if (sqlDbPrefixParam != null && !string.IsNullOrEmpty(sqlDbPrefixParam.Value))
{
foreach (SitecoreEnvironment sitecoreEnvironment in SitecoreEnvironmentHelper.SitecoreEnvironments)
{
if (sitecoreEnvironment.Name == sqlDbPrefixParam.Value)
{
SitecoreEnvironmentHelper.SitecoreEnvironments.Remove(sitecoreEnvironment);
SitecoreEnvironmentHelper.SaveSitecoreEnvironmentData(SitecoreEnvironmentHelper.SitecoreEnvironments);
return;
}
}
}
}
public void ReturnsValidValidationResults(string deployRoot, long freeSpace, ValidatorState expectedResult, string resultMessage)
{
//Arrange
Task task = Substitute.For <Task>("", 0, null, new List <InstallParam>(), new Dictionary <string, string>());
task.LocalParams.Returns(new List <InstallParam>());
InstallParam deployRootParam = new InstallParam("DeployRoot", deployRoot);
task.LocalParams.Add(deployRootParam);
List <Task> tasks = Substitute.For <List <Task> >();
tasks.Add(task);
DiskSpaceValidator val = Substitute.ForPartsOf <DiskSpaceValidator>();
val.GetHardDriveFreeSpace(string.Empty).ReturnsForAnyArgs(freeSpace);
val.Data["HardDriveWarningLimit"] = "5368709120";
val.Data["HardDriveErrorLimit"] = "3221225472";
val.Data["DeployRoot"] = "DeployRoot";
//Act
IEnumerable <ValidationResult> results = val.Evaluate(tasks);
//Assert
Assert.Contains(results, r => r.State == expectedResult && r.Message == resultMessage);
}
public async Task <ApiResponse <int> > Index(InstallParam param)
{
var installed = _configuration[ConfigKey.DbInstalled].ToBool();
if (!param.AdminPwd.IsNullOrWhiteSpace() && !installed)
{
if (await _installService.InitializeDb(param))
{
return(ApiResponse <int> .Ok());
}
}
return(ApiResponse <int> .Fail("安装失败"));
}
public static Task CreateTask(string taskName, string[] paramNames, string[] paramValues)
{
var task = Substitute.For <Task>("someTask", 1, null, new List <InstallParam>(),
new Dictionary <string, string>());
List <InstallParam> iParams = new List <InstallParam>();
for (int i = 0; i < paramNames.Length; ++i)
{
InstallParam p = new InstallParam(paramNames[i], paramValues[i]);
iParams.Add(p);
}
task.LocalParams.Returns(iParams);
return(task);
}
public void CertificateDoesNotExist(IEnumerable <Task> tasks)
{
InstallParam p = new InstallParam("somename", "somevalue");
tasks.First().LocalParams.Add(p);
CertificateValidator val = Substitute.ForPartsOf <CertificateValidator>();
val.WhenForAnyArgs(a => a.FindCertificates(null)).DoNotCallBase();
val.FindCertificates(null).ReturnsForAnyArgs(new X509Certificate2Collection());
val.Data["StoreName"] = "Root";
val.Data["ParamNames"] = p.Name;
Assert.DoesNotContain(val.Evaluate(tasks), r => r.State == Sitecore9Installer.Validation.ValidatorState.Error);
val.DidNotReceiveWithAnyArgs().ValidateCertificate(null);
}
protected override void Process([NotNull] ProcessorArgs args)
{
Install9Args arguments = (Install9Args)args;
if (arguments.Tasker.UnInstall || arguments.ScriptsOnly)
{
this.Skip();
return;
}
InstallParam sqlDbPrefixParam = arguments.Tasker.GlobalParams.FirstOrDefault(p => p.Name == SqlDbPrefix);
if (sqlDbPrefixParam != null && !string.IsNullOrEmpty(sqlDbPrefixParam.Value))
{
this.AddSitecoreEnvironment(this.CreateSitecoreEnvironment(arguments.Tasker, sqlDbPrefixParam.Value, arguments.UnInstallDataPath));
}
}
protected override void Process([NotNull] ProcessorArgs args)
{
Install9Args arguments = args as Install9Args;
Assert.ArgumentNotNull(arguments, nameof(arguments));
if (arguments.ScriptsOnly)
{
this.Skip();
return;
}
InstallParam param = arguments.Tasker.GlobalParams.FirstOrDefault(p => p.Name == "DeployRoot");
if (param != null)
{
int retriesNumber = 3;
for (int i = 0; i <= retriesNumber; i++)
{
if (Directory.Exists(param.Value))
{
try
{
Directory.Delete(param.Value, true);
}
catch (System.IO.IOException ex)
{
Log.Warn($"Can't remove directory: {param.Value}. {ex.Message}");
}
if (Directory.Exists(param.Value))
{
if (retriesNumber == i)
{
throw new Exception($"Can't remove directory: {param.Value}");
}
Thread.Sleep(10000);
}
else
{
break;
}
}
}
}
Directory.Delete(arguments.Tasker.UnInstallParamsPath, true);
}
protected override void Process([NotNull] ProcessorArgs args)
{
Install9Args arguments = args as Install9Args;
Assert.ArgumentNotNull(arguments, nameof(arguments));
if (arguments.ScriptsOnly)
{
this.Skip();
return;
}
Directory.Delete(arguments.Tasker.UnInstallParamsPath, true);
InstallParam param = arguments.Tasker.GlobalParams.FirstOrDefault(p => p.Name == "DeployRoot");
if (param != null && !Directory.GetFileSystemEntries(param.Value).Any())
{
Directory.Delete(param.Value, true);
}
}
public void EvaluateTests(string cmTaskName, string cmSiteName, string identityServerTaskName, string identityServerAllowedCorsOrigins, string identityServerPasswordRecoveryUrl, int warningsCount)
{
// Arrange
var fixture = new Fixture();
var cmTask = Substitute.For <Task>(cmTaskName, fixture.Create <int>(), null, new List <InstallParam>(), new Dictionary <string, string>());
InstallParam siteNameParam = new InstallParam(SiteName, cmSiteName);
List <InstallParam> paramList = new List <InstallParam>
{
siteNameParam
};
cmTask.LocalParams.Returns(paramList);
var identityServerTask = Substitute.For <Task>(identityServerTaskName, fixture.Create <int>(), null, new List <InstallParam>(), new Dictionary <string, string>());
InstallParam allowedCorsOriginsParam = new InstallParam(AllowedCorsOrigins, identityServerAllowedCorsOrigins);
InstallParam passwordRecoveryUrlParam = new InstallParam(PasswordRecoveryUrl, identityServerPasswordRecoveryUrl);
paramList = new List <InstallParam>
{
allowedCorsOriginsParam,
passwordRecoveryUrlParam
};
identityServerTask.LocalParams.Returns(paramList);
var validator = Substitute.ForPartsOf <CmIdentityServerSiteNameValidator>();
validator.Data["SitecoreXp1Cm"] = SitecoreXp1Cm;
validator.Data["SitecoreXm1Cm"] = SitecoreXm1Cm;
validator.Data["SitecoreXp0"] = SitecoreXp0;
validator.Data["SiteName"] = SiteName;
validator.Data["IdentityServer"] = IdentityServer;
validator.Data["AllowedCorsOrigins"] = AllowedCorsOrigins;
validator.Data["PasswordRecoveryUrl"] = PasswordRecoveryUrl;
// Act
IEnumerable <ValidationResult> result = validator.Evaluate(new Task[] { cmTask, identityServerTask });
IEnumerable <ValidationResult> warnings = result.Where(r => r.State == ValidatorState.Warning);
// Assert
Assert.Equal(warnings.Count(), warningsCount);
}
public async Task <bool> InitializeDb(InstallParam param)
{
_param = param;
try
{
var connectString = $"Server={param.DbUrl};Database={param.DbName};uid={param.DbUserName};pwd={param.DbUserPwd}";
ConfigDataHelper.UpdateConnectionString(ConfigKey.BlogsConnectionString, connectString);
await _blogsContext.Database.EnsureCreatedAsync();
Seed();
ConfigDataHelper.UpdateDbInstallStatus(true);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
return(true);
}
public void NotCompatible(IEnumerable <Task> tasks)
{
InstallParam server = new InstallParam("server", "val");
InstallParam user = new InstallParam("user", "val");
InstallParam pass = new InstallParam("pass", "val");
Task t = tasks.First();
t.LocalParams.Add(server);
t.LocalParams.Add(user);
t.LocalParams.Add(pass);
SqlVersionValidator val = Substitute.ForPartsOf <SqlVersionValidator>();
val.Data["Server"] = "server";
val.Data["User"] = "******";
val.Data["Password"] = "******";
val.Data["Versions"] = "15.0.*,17.0.*";
val.WhenForAnyArgs(v => v.GetSqlVersion(null, null, null)).DoNotCallBase();
val.GetSqlVersion(null, null, null).ReturnsForAnyArgs("12.0.12345.6789");
Assert.Contains(val.Evaluate(tasks), r => r.State == Sitecore9Installer.Validation.ValidatorState.Error);
}
public void EvaluateTests(string cmTaskName, string cmSiteName, string ddsPatchTaskName, string ddsPatchSiteName, bool areAnyErrors)
{
// Arrange
var fixture = new Fixture();
var cmTask = Substitute.For <Task>(cmTaskName, fixture.Create <int>(), null, new List <InstallParam>(), new Dictionary <string, string>());
InstallParam siteNameParam = new InstallParam(SiteName, cmSiteName);
List <InstallParam> paramList = new List <InstallParam>
{
siteNameParam
};
cmTask.LocalParams.Returns(paramList);
var ddsPatchTask = Substitute.For <Task>(ddsPatchTaskName, fixture.Create <int>(), null, new List <InstallParam>(), new Dictionary <string, string>());
siteNameParam = new InstallParam(SiteName, ddsPatchSiteName);
paramList = new List <InstallParam>
{
siteNameParam
};
ddsPatchTask.LocalParams.Returns(paramList);
var validator = Substitute.ForPartsOf <CmDdsPatchSiteNameValidator>();
validator.Data["SitecoreXp1Cm"] = SitecoreXp1Cm;
validator.Data["SitecoreXp1CmDdsPatch"] = SitecoreXp1CmDdsPatch;
validator.Data["SiteName"] = SiteName;
// Act
IEnumerable <ValidationResult> result = validator.Evaluate(new Task[] { cmTask, ddsPatchTask });
IEnumerable <ValidationResult> errors = result.Where(r => r.State == ValidatorState.Error);
// Assert
Assert.Equal(errors.Any(), areAnyErrors);
}
public void InitializeStep(WizardArgs wizardArgs)
{
var args = wizardArgs as ReinstallWizardArgs;
string uninstallPath = string.Empty;
SitecoreEnvironment env = SitecoreEnvironmentHelper.GetExistingSitecoreEnvironment(args.Instance.Name);
if (!string.IsNullOrEmpty(env?.UnInstallDataPath))
{
uninstallPath = env.UnInstallDataPath;
}
else
{
foreach (string installName in Directory.GetDirectories(ApplicationManager.UnInstallParamsFolder).OrderByDescending(s => s.Length))
{
if (args.Instance.Name.StartsWith(Path.GetFileName(installName)))
{
uninstallPath = installName;
break;
}
}
}
if (string.IsNullOrEmpty(uninstallPath))
{
WindowHelper.ShowMessage("UnInstall files not found.");
wizardArgs.WizardWindow.Close();
}
Tasker tasker = new Tasker(uninstallPath);
InstallParam sqlServer = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlServer");
if (sqlServer != null)
{
sqlServer.Value = args.ConnectionString.DataSource;
}
InstallParam sqlAdminUser = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlAdminUser");
if (sqlAdminUser != null)
{
sqlAdminUser.Value = args.ConnectionString.UserID;
}
InstallParam sqlAdminPass = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlAdminPassword");
if (sqlAdminPass != null)
{
sqlAdminPass.Value = args.ConnectionString.Password;
}
tasker.UnInstall = true;
args.Tasker = tasker;
StringBuilder displayText = new StringBuilder();
displayText.AppendLine("Reinstall:");
foreach (var task in tasker.Tasks.Where(t => t.SupportsUninstall()))
{
displayText.AppendLine(string.Format(" -{0}", task.Name));
}
this.TextBlock.Text = displayText.ToString();
args.InstanceName = args.Tasker.GlobalParams.First(p => p.Name == "SqlDbPrefix").Value;
}
public bool OnMovingNext(WizardArgs wizardArgs)
{
var productRevision = ProductRevision;
Assert.IsNotNull(productRevision, nameof(productRevision));
Product product = productRevision.SelectedValue as Product;
Assert.IsNotNull(product, nameof(product));
var name = GetValidWebsiteName();
if (name == null)
{
return(false);
}
var connectionString = ProfileManager.GetConnectionString();
SqlServerManager.Instance.ValidateConnectionString(connectionString);
var licensePath = ProfileManager.Profile.License;
Assert.IsNotNull(licensePath, @"The license file isn't set in the Settings window");
FileSystem.FileSystem.Local.File.AssertExists(licensePath, "The {0} file is missing".FormatWith(licensePath));
var args = (Install9WizardArgs)wizardArgs;
args.Validate = this.runValidation.IsChecked.Value;
args.InstanceName = name;
args.InstanceProduct = product;
args.InstanceConnectionString = connectionString;
args.LicenseFileInfo = new FileInfo(licensePath);
args.Product = product;
SolrDefinition solr = this.Solrs.SelectedItem as SolrDefinition;
if (solr == null)
{
WindowHelper.ShowMessage("Please provide solr.");
return(false);
}
args.SolrUrl = solr.Url; //this.solrUrl.Text;
args.SorlRoot = solr.Root; //this.solrRoot.Text;
args.ScriptRoot = System.IO.Path.Combine(Directory.GetParent(args.Product.PackagePath).FullName, System.IO.Path.GetFileNameWithoutExtension(args.Product.PackagePath));
if (!this.IsFilePathLengthValidInPackage(args.Product.PackagePath, args.ScriptRoot))
{
return(false);
}
if (!Directory.Exists(args.ScriptRoot))
{
Directory.CreateDirectory(args.ScriptRoot);
WindowHelper.LongRunningTask(() => this.UnpackInstallationFiles(args), "Unpacking unstallation files.", wizardArgs.WizardWindow);
WindowHelper.LongRunningTask(() => InstallTasksHelper.CopyCustomSifConfig(args), "Copying custom SIF configuration files to the install folder.", wizardArgs.WizardWindow);
WindowHelper.LongRunningTask(() => InstallTasksHelper.AddUninstallTasks(args), "Add Uninstall tasks to the OOB config files.", wizardArgs.WizardWindow);
}
else
{
if (MessageBox.Show(string.Format("Path '{0}' already exists. Do you want to overwrite it?", args.ScriptRoot), "Overwrite?", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
Directory.Delete(args.ScriptRoot, true);
Directory.CreateDirectory(args.ScriptRoot);
WindowHelper.LongRunningTask(() => this.UnpackInstallationFiles(args), "Unpacking installation files.", wizardArgs.WizardWindow);
WindowHelper.LongRunningTask(() => InstallTasksHelper.CopyCustomSifConfig(args), "Copying custom SIF configuration files to the install folder.", wizardArgs.WizardWindow);
WindowHelper.LongRunningTask(() => InstallTasksHelper.AddUninstallTasks(args), "Add Uninstall tasks to the OOB config files.", wizardArgs.WizardWindow);
}
}
string rootPath = this.LocationText.Text;
if (!args.ScriptsOnly)
{
if (string.IsNullOrWhiteSpace(rootPath))
{
WindowHelper.ShowMessage("Please specify location.");
return(false);
}
if (SIM.FileSystem.FileSystem.Local.Directory.Exists(rootPath))
{
if (Directory.EnumerateFileSystemEntries(rootPath).Any())
{
if (WindowHelper.ShowMessage("The folder with the same name already exists and is not empty. Would you like to delete it?", MessageBoxButton.OKCancel, MessageBoxImage.Question, MessageBoxResult.OK) == MessageBoxResult.OK)
{
SIM.FileSystem.FileSystem.Local.Directory.DeleteIfExists(rootPath, null);
SIM.FileSystem.FileSystem.Local.Directory.CreateDirectory(rootPath);
}
}
}
else
{
SIM.FileSystem.FileSystem.Local.Directory.CreateDirectory(rootPath);
}
}
Tasker tasker = new Tasker(args.ScriptRoot, Path.GetFileNameWithoutExtension(args.Product.PackagePath), rootPath);
InstallParam sqlServer = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlServer");
if (sqlServer != null)
{
sqlServer.Value = args.InstanceConnectionString.DataSource;
}
InstallParam sqlAdminUser = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlAdminUser");
if (sqlAdminUser != null)
{
sqlAdminUser.Value = args.InstanceConnectionString.UserID;
}
InstallParam sqlAdminPass = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlAdminPassword");
if (sqlAdminPass != null)
{
sqlAdminPass.Value = args.InstanceConnectionString.Password;
}
InstallParam sqlDbPrefix = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SqlDbPrefix");
if (sqlDbPrefix != null)
{
sqlDbPrefix.Value = args.InstanceName;
}
InstallParam licenseFile = tasker.GlobalParams.FirstOrDefault(p => p.Name == "LicenseFile");
if (licenseFile != null)
{
licenseFile.Value = args.LicenseFileInfo.FullName;
}
InstallParam solrRoot = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SolrRoot");
if (solrRoot != null)
{
solrRoot.Value = args.SorlRoot;
}
InstallParam solrService = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SolrService");
if (solrService != null && !string.IsNullOrEmpty(solr.Service))
{
solrService.Value = solr.Service; // this.SolrService.Text;
}
InstallParam solrUrl = tasker.GlobalParams.FirstOrDefault(p => p.Name == "SolrUrl");
if (solrUrl != null)
{
solrUrl.Value = args.SolrUrl;
}
args.ScriptsOnly = this.scriptsOnly.IsChecked ?? false;
args.Tasker = tasker;
VersionToSolr vts = ProfileManager.Profile.VersionToSolrMap.FirstOrDefault(s => s.Vesrion == product.ShortVersion);
if (vts == null)
{
vts = new VersionToSolr();
vts.Vesrion = product.ShortVersion;
ProfileManager.Profile.VersionToSolrMap.Add(vts);
}
vts.Solr = solr.Name;
ProfileManager.SaveChanges(ProfileManager.Profile);
return(true);
}
