public static void AttachDatabase(string name, string databasesFolderPath, ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, IPipelineController controller)
{
SetConnectionStringNode(name, defaultConnectionString, connectionString);
string databaseName = connectionString.GenerateDatabaseName(name);
string databasePath =
DatabaseFilenameHook(Path.Combine(databasesFolderPath, connectionString.DefaultFileName),
connectionString.Name.Replace("yafnet", "forum"), databasesFolderPath);
if (!IsRemoteSqlServer())
{
if (!FileSystem.FileSystem.Local.File.Exists(databasePath))
{
var file = Path.GetFileName(databasePath);
if (file.EqualsIgnoreCase("sitecore.reporting.mdf"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Analytics.mdf");
}
}
FileSystem.FileSystem.Local.File.AssertExists(databasePath, databasePath + " file doesn't exist");
}
if (SqlServerManager.Instance.DatabaseExists(databaseName, defaultConnectionString))
{
databaseName = ResolveConflict(defaultConnectionString, connectionString, databasePath, databaseName, controller);
}
if (databaseName != null)
{
SqlServerManager.Instance.AttachDatabase(databaseName, databasePath, defaultConnectionString);
}
}
public static void AttachDatabase(ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, string name, string databasesFolderPath, string instanceName, IPipelineController controller)
{
if (connectionString.IsMongoConnectionString)
{
connectionString.Value = AttachDatabasesHelper.GetMongoConnectionString(connectionString.Name, instanceName);
connectionString.SaveChanges();
return;
}
if (connectionString.IsSqlConnectionString)
{
try
{
AttachDatabasesHelper.AttachDatabase(name, databasesFolderPath, connectionString, defaultConnectionString, controller);
}
catch (Exception ex)
{
if (connectionString.Name == "reporting.secondary")
{
throw;
}
Log.Warn(ex, "Attaching reporting.secondary database failed. Skipping...");
}
}
}
public static void Process(IEnumerable<Database> innerDatabases, string rootPath, SqlConnectionStringBuilder connectionString, string instanceName, IPipelineController controller, List<string> done)
{
string localDataSource = SqlServerManager.Instance.NormalizeServerName(connectionString.DataSource);
foreach (Database database in innerDatabases)
{
var cstr = database.ConnectionString.ToString();
if (!SqlServerManager.Instance.IsSqlConnectionString(cstr))
{
continue;
}
// if the database is attached to remote SQL Server
string dataSource = SqlServerManager.Instance.NormalizeServerName(database.ConnectionString.DataSource);
if (!dataSource.EqualsIgnoreCase(localDataSource))
{
// user doesn't confirm deleting
if (controller == null || !controller.Confirm("The '{0}' database seems to be located on the '{1}' remote SQL server instead of the '{2}' local one specified in the Settings dialog. \n\nShould it be deleted as well?".FormatWith(database.RealName, dataSource, localDataSource)))
{
continue;
}
}
string fileName = database.FileName;
if (!string.IsNullOrEmpty(fileName))
{
// database is located out of the rootPath folder
if (!fileName.ToLower().Contains(rootPath))
{
// user doesn't confirm deleting
if (controller == null || !controller.Confirm("The '{0}' database with '{1}' file path is located out of the {2} instance's root path '{3}'. \n\nShould it be deleted as well?".FormatWith(database.RealName, fileName, instanceName, rootPath)))
{
continue;
}
}
}
if (SqlServerManager.Instance.DatabaseExists(database.RealName, connectionString))
{
database.Delete();
}
}
SqlServerManager.Instance.DetectDatabases(rootPath, connectionString, name =>
{
if (!done.Contains(name))
{
SqlServerManager.Instance.DeleteDatabase(name,
connectionString);
done.Add(name);
}
});
}
public Pipeline([NotNull] PipelineDefinition pipelineDefinition, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null, bool isAsync = true)
{
Assert.ArgumentNotNull(pipelineDefinition, "pipelineDefinition");
Assert.ArgumentNotNull(args, "args");
this.controller = controller;
this.pipelineDefinition = pipelineDefinition;
this.title = pipelineDefinition.Title;
this.steps = Step.CreateSteps(this.pipelineDefinition.Steps, args, controller);
this.isAsync = isAsync;
// Storing args for restarting pipeline
this.processorArgs = args;
}
private static void ProcessActions(Instance instance, SqlConnectionStringBuilder connectionString,
IPipelineController controller, Product module, Dictionary<string, string> variables,
XmlElement actionsElement)
{
// made replacement
actionsElement.InnerXml = variables.Aggregate(actionsElement.InnerXml,
(result, variable) => result.Replace(variable.Key, variable.Value)).Replace("{InstanceName}", instance.Name);
var actions = actionsElement.ChildNodes.OfType<XmlElement>();
var webRootPath = instance.WebRootPath;
List<string> ignoreCommands = new List<string>();
foreach (XmlElement action in actions.Where(a => a.Name.EqualsIgnoreCase("patch")))
{
var commandText = action.GetAttribute("command").EmptyToNull().IsNotNull("The command attribute of <patch /> element must exist and must not be empty");
var actionText = action.GetAttribute("action");
if (actionText == "delete")
{
ignoreCommands.Add(commandText);
}
}
// give extract more priority
if (actions.Any(xml => xml.Name.EqualsIgnoreCase("extract")) && !ignoreCommands.Contains("extract"))
{
FileSystem.FileSystem.Local.Zip.UnpackZip(module.PackagePath, instance.WebRootPath);
}
foreach (XmlElement action in actions)
{
var children = action.ChildNodes.OfType<XmlElement>();
string actionName = action.Name;
if (ignoreCommands.Contains(actionName))
{
continue;
}
switch (actionName)
{
case "extract":
{
// give extract more priority
// FileSystem.Instance.UnpackZip(module.PackagePath, instance.GetRootPath(webRootPath));
break;
}
case "config":
{
string configPath = action.GetAttribute("path");
try
{
XmlDocumentEx config = !string.IsNullOrEmpty(configPath)
? XmlDocumentEx.LoadFile(Path.Combine(webRootPath, configPath))
: instance.GetWebConfig(webRootPath);
PerformConfigChanges(instance, children, module, config, variables);
}
catch (XmlDocumentEx.FileIsMissingException ex)
{
Log.Warn(
"The path attribute is specified (path: {0}) but the file doesn't exist".FormatWith(configPath),
typeof(ConfigurationActions), ex);
}
break;
}
case "databases":
{
AddDatabase(instance, children, module, connectionString, controller);
break;
}
case "editfile":
{
EditFile(action.GetAttribute("path"), children, instance, variables);
break;
}
case "setRestrictingPlaceholders":
{
InstanceHelper.StartInstance(instance);
SetRestrictingPlaceholders(action.GetAttribute("names"), GetWebServiceUrl(instance));
break;
}
case "custom":
{
var typeName = action.GetAttribute("type").EmptyToNull().IsNotNull("The type attribute is missing in the <custom> install action");
var obj = (IPackageInstallActions)ReflectionUtil.CreateObject(typeName);
obj.Execute(instance, module);
break;
}
case "sql":
{
var db = action.GetAttribute("database");
var file = action.GetAttribute("file").Replace("$(data)", instance.DataFolderPath).Replace("$(website)", instance.WebRootPath);
if (!string.IsNullOrEmpty(file))
{
Assert.IsTrue(File.Exists(file), string.Format("The {0} file does not exist", file));
}
var sql = string.IsNullOrEmpty(file) ? action.InnerText : FileSystem.FileSystem.Local.File.ReadAllText(file);
Assert.IsNotNullOrEmpty(sql.Trim(), "The SQL command is empty");
var cstr = instance.Configuration.ConnectionStrings.FirstOrDefault(x => x.Name == db);
Assert.IsNotNull(cstr, "The {0} connection string is not found".FormatWith(db));
using (var conn = SqlServerManager.Instance.OpenConnection(new SqlConnectionStringBuilder(cstr.Value), false))
{
foreach (var command in sql.Split("GO"))
{
SqlServerManager.Instance.Execute(conn, command);
}
}
break;
}
}
}
}
private static void FillVariables(IEnumerable<XmlElement> sections, Dictionary<string, string> variables, Instance instance, IPipelineController controller)
{
var @params = sections.SingleOrDefault(s => s.Name.EqualsIgnoreCase("params"));
if (@params != null)
{
var children = @params.ChildNodes.OfType<XmlElement>();
foreach (XmlElement param in children)
{
string variableName = param.GetAttribute("name");
if (variables.ContainsKey(variableName))
{
continue;
}
string variableTitle = param.GetAttribute("title");
string defaultVariableValue = param.GetAttribute("defaultValue");
string mode = param.GetAttribute("mode");
var options = param.GetAttribute("options");
var typeName = param.GetAttribute("getOptionsType");
var methodName = param.GetAttribute("getOptionsMethod");
var multiselect = mode.EqualsIgnoreCase("multiselect");
string variableValue = controller != null
? (multiselect || mode.Equals("select")
? controller.Select(variableTitle, !string.IsNullOrEmpty(options)
? options.Split('|')
: GetOptions(typeName, methodName, instance), multiselect, defaultVariableValue)
: controller.Ask(variableTitle, defaultVariableValue))
: defaultVariableValue;
variables.Add(variableName, variableValue);
}
}
}
private static IEnumerable <Step> CreateStepsPrivate([NotNull] IEnumerable <StepDefinition> steps, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null)
{
Assert.ArgumentNotNull(steps, nameof(steps));
Assert.ArgumentNotNull(args, nameof(args));
foreach (StepDefinition stepDefinition in steps)
{
var argsName = stepDefinition.ArgsName.EmptyToNull();
Step step = new Step(ProcessorManager.CreateProcessors(stepDefinition.ProcessorDefinitions, args, controller), argsName);
Assert.IsNotNull(step, "Can't instantiate step");
yield return(step);
}
}
private static Pipeline CreatePipeline([NotNull] string pipelineName, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null, bool isAsync = true)
{
Assert.ArgumentNotNull(pipelineName, nameof(pipelineName));
Assert.ArgumentNotNull(args, nameof(args));
using (new ProfileSection("Create pipeline"))
{
ProfileSection.Argument("pipelineName", pipelineName);
ProfileSection.Argument("args", args);
ProfileSection.Argument("controller", controller);
ProfileSection.Argument("isAsync", isAsync);
Assert.IsTrue(Definitions.ContainsKey(pipelineName), "The {0} pipeline defintion does not exist".FormatWith(pipelineName));
PipelineDefinition definition = Definitions[pipelineName];
Pipeline pipeline = new Pipeline(definition, args, controller, isAsync);
if (controller != null)
{
controller.Pipeline = pipeline;
}
return(ProfileSection.Result(pipeline));
}
}
private static IEnumerable <Processor> CreateProcessorsPrivate([NotNull] IEnumerable <ProcessorDefinition> processorDefinitions, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller)
{
Assert.ArgumentNotNull(processorDefinitions, "processorDefinitions");
Assert.ArgumentNotNull(args, "args");
foreach (ProcessorDefinition processorDefinition in processorDefinitions)
{
foreach (Processor processor in processorDefinition.CreateProcessors(args))
{
processor.ProcessorDefinition = processorDefinition;
bool isRequireProcessing = true;
try
{
isRequireProcessing = processor.IsRequireProcessing(args);
}
catch (Exception ex)
{
Log.Warn("Cannot detect if the processor {0} requires processing".FormatWith(processor.ProcessorDefinition.Type), typeof(ProcessorManager), ex);
}
if (isRequireProcessing)
{
List <Processor> nested = CreateProcessors(processorDefinition.NestedProcessorDefinitions, args, controller);
processor.NestedProcessors.AddRange(nested);
processor.Controller = controller;
yield return(processor);
}
}
}
}
private static void FillVariables(IEnumerable <XmlElement> sections, Dictionary <string, string> variables, Instance instance, IPipelineController controller)
{
var @params = sections.SingleOrDefault(s => s.Name.EqualsIgnoreCase("params"));
if (@params != null)
{
var children = @params.ChildNodes.OfType <XmlElement>();
foreach (XmlElement param in children)
{
string variableName = param.GetAttribute("name");
if (variables.ContainsKey(variableName))
{
continue;
}
string variableTitle = param.GetAttribute("title");
string defaultVariableValue = param.GetAttribute("defaultValue");
string mode = param.GetAttribute("mode");
var options = param.GetAttribute("options");
var typeName = param.GetAttribute("getOptionsType");
var methodName = param.GetAttribute("getOptionsMethod");
var multiselect = mode.EqualsIgnoreCase("multiselect");
string variableValue = controller != null
? (multiselect || mode.Equals("select")
? controller.Select(variableTitle, !string.IsNullOrEmpty(options)
? options.Split('|')
: GetOptions(typeName, methodName, instance), multiselect, defaultVariableValue)
: controller.Ask(variableTitle, defaultVariableValue))
: defaultVariableValue;
variables.Add(variableName, variableValue);
}
}
}
public static void AttachDatabase(ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, string name, string databasesFolderPath, string instanceName, IPipelineController controller)
{
if (connectionString.IsMongoConnectionString)
{
connectionString.Value = AttachDatabasesHelper.GetMongoConnectionString(connectionString.Name, instanceName);
connectionString.SaveChanges();
return;
}
if (connectionString.IsSqlConnectionString)
{
try
{
AttachDatabasesHelper.AttachDatabase(name, databasesFolderPath, connectionString, defaultConnectionString, controller);
}
catch (Exception ex)
{
if (connectionString.Name == "reporting.secondary")
{
throw;
}
Log.Warn(ex, "Attaching reporting.secondary database failed. Skipping...");
}
}
}
private static void AddDatabase([NotNull] Instance instance, [NotNull] IEnumerable <XmlElement> databases, [NotNull] Product module, SqlConnectionStringBuilder connectionString, IPipelineController controller)
{
Assert.ArgumentNotNull(instance, "instance");
Assert.ArgumentNotNull(databases, "databases");
Assert.ArgumentNotNull(module, "module");
Assert.ArgumentNotNull(connectionString, "connectionString");
foreach (XmlElement database in databases)
{
string name = database.GetAttribute("name");
string role = database.GetAttribute("role").EmptyToNull() ?? name;
string fileName = database.GetAttribute("fileName");
string sourceFileName = database.GetAttribute("sourceFileName");
string databasesFolder = GetDatabasesFolder(instance, connectionString, controller);
var locationInPackage = database.GetAttribute("location");
Assert.IsNotNull(databasesFolder, "databasesFolder");
FileSystem.FileSystem.Local.Directory.AssertExists(databasesFolder);
bool skipAttach = false;
string realDBname = SqlServerManager.Instance.GenerateDatabaseRealName(instance.Name, role);
string physicalPath = Path.Combine(databasesFolder, fileName);
var newDatabaseConnectionString = new SqlConnectionStringBuilder(connectionString.ToString());
newDatabaseConnectionString.InitialCatalog = realDBname;
if (SqlServerManager.Instance.DatabaseExists(realDBname, newDatabaseConnectionString))
{
string databasePath = SqlServerManager.Instance.GetDatabaseFileName(realDBname, newDatabaseConnectionString);
const string theDatabaseExists = "The database with the same name ('{0}') already exists in the current instance of SQL Server ('{1}')";
if (string.IsNullOrEmpty(databasePath))
{
string message = string.Format(theDatabaseExists + ", but doesn't point to any file(s) and looks like corrupted.", realDBname, newDatabaseConnectionString.DataSource);
if (!controller.Confirm(message + " Would you like to delete it? If not then this installation will be interrupted."))
{
throw new InvalidOperationException(message);
}
SqlServerManager.Instance.DeleteDatabase(realDBname, newDatabaseConnectionString);
}
else if (!databasePath.EqualsIgnoreCase(physicalPath))
{
throw new InvalidOperationException(string.Format(theDatabaseExists + ", but points to files by another location ('{2}') than was expected ('{3}')", realDBname, newDatabaseConnectionString.DataSource, databasePath, physicalPath));
}
skipAttach = true;
}
if (!skipAttach)
{
ExtractDatabase(module, fileName, sourceFileName, databasesFolder, locationInPackage);
SqlServerManager.Instance.AttachDatabase(realDBname, physicalPath, newDatabaseConnectionString);
}
instance.Configuration.ConnectionStrings.Add(name, newDatabaseConnectionString);
}
}
public static void ExecuteActions([NotNull] Instance instance, [NotNull] Product[] modules, [CanBeNull] List <Product> done, [NotNull] string param, [CanBeNull] SqlConnectionStringBuilder connectionString,
[CanBeNull] IPipelineController controller = null, [CanBeNull] Dictionary <string, string> variables = null)
{
Assert.ArgumentNotNull(instance, "instance");
Assert.ArgumentNotNull(modules, "modules");
Assert.ArgumentNotNull(param, "param");
variables = variables ?? new Dictionary <string, string>();
foreach (Product module in modules)
{
if (done != null && done.Contains(module))
{
continue;
}
XmlDocument manifest = module.Manifest;
if (manifest == null)
{
Log.Warn("The {0} doesn't have a manifest".FormatWith(module), typeof(ConfigurationActions));
if (done != null)
{
done.Add(module);
}
continue;
}
Product instanceProduct = instance.Product;
if (!module.IsMatchRequirements(instanceProduct))
{
Log.Warn("The {0} doesn't suites for {1}".FormatWith(module, instanceProduct), typeof(ConfigurationActions));
if (done != null)
{
done.Add(module);
}
continue;
}
// Get the rules xpath
string[] paramArgs = param.Split('|');
string xpath =
paramArgs.Length == 2
? Product.ManifestPrefix + paramArgs[0] + "/install/" + paramArgs[1] // is package
: Product.ManifestPrefix + param + "/install"; // is archive
XmlElement element = manifest.SelectSingleNode(xpath) as XmlElement;
if (element == null)
{
Log.Warn("Can't find rules root (the {0} element in the manifest of the {3} file){1}The manifest is: {1}{2}".FormatWith(xpath, Environment.NewLine, manifest.OuterXml, module.PackagePath), typeof(ConfigurationActions));
if (done != null)
{
done.Add(module);
}
continue;
}
var sections = element.ChildNodes.OfType <XmlElement>().NotNull();
FillVariables(sections, variables, instance, controller);
var actions = sections.SingleOrDefault(s => s.Name.EqualsIgnoreCase("actions"));
ProcessActions(instance, connectionString, controller, module, variables, actions);
if (done != null)
{
done.Add(module);
}
}
}
public static void AttachDatabase(string name, string sqlPrefix, bool attachSql, string databasesFolderPath, Adapters.WebServer.ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, IPipelineController controller)
{
SetConnectionStringNode(name, sqlPrefix, defaultConnectionString, connectionString);
if (!attachSql)
{
return;
}
var databaseName = connectionString.GenerateDatabaseName(name, sqlPrefix);
var databasePath = GetDatabasePath(databasesFolderPath, connectionString, databaseName, ".mdf");
if (!File.Exists(databasePath))
{
databasePath = GetDatabasePath(databasesFolderPath, connectionString, databaseName, ".dacpac");
if (!File.Exists(databasePath))
{
Log.Warn($"File cannot be found: {databasePath} (.dacpac or .mdf)");
return;
}
}
if (SqlServerManager.Instance.DatabaseExists(databaseName, defaultConnectionString))
{
databaseName = ResolveConflict(defaultConnectionString, connectionString, databasePath, databaseName, controller);
}
if (databaseName != null)
{
var extension = Path.GetExtension(databasePath);
if (extension == ".dacpac")
{
new SqlAdapter(new SqlConnectionString(defaultConnectionString.ToString())).DeployDatabase(databaseName, new RealFileSystem().ParseFile(databasePath));
var tmpPath = SqlServerManager.Instance.GetDatabaseFileName(databaseName, defaultConnectionString);
SqlServerManager.Instance.DetachDatabase(databaseName, defaultConnectionString);
extension = ".mdf";
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), Settings.CoreInstallRenameSqlFiles.Value ? databaseName + extension : Path.GetFileNameWithoutExtension(databasePath) + extension);
File.Move(tmpPath, databasePath);
}
SqlServerManager.Instance.AttachDatabase(databaseName, databasePath, defaultConnectionString);
}
}
public static void AttachDatabase(string name, string sqlPrefix, bool attachSql, string databasesFolderPath, ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, IPipelineController controller)
{
SetConnectionStringNode(name, sqlPrefix, defaultConnectionString, connectionString);
if (!attachSql)
{
return;
}
var databaseName = connectionString.GenerateDatabaseName(name, sqlPrefix);
var databasePath =
DatabaseFilenameHook(Path.Combine(databasesFolderPath, connectionString.DefaultFileName),
connectionString.Name.Replace("yafnet", "forum"), databasesFolderPath);
if (!FileSystem.Local.File.Exists(databasePath))
{
var file = Path.GetFileName(databasePath);
if (connectionString.Name.EqualsIgnoreCase("reporting"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Analytics.mdf");
}
else if (connectionString.Name.EqualsIgnoreCase("exm.dispatch"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Exm.mdf");
}
else if (connectionString.Name.EqualsIgnoreCase("session"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Sessions.mdf");
}
}
FileSystem.Local.File.AssertExists(databasePath, databasePath + " file doesn't exist");
if (Settings.CoreInstallRenameSqlFiles.Value)
{
// Make the database data file also matching databaseName
var newPath = databasePath.Replace(connectionString.DefaultFileName, string.Concat(databaseName, ".mdf"));
try
{
File.Move(databasePath, newPath);
}
catch
{
}
// Assert again
databasePath = newPath;
FileSystem.Local.File.AssertExists(databasePath, databasePath + " file doesn't exist");
}
if (SqlServerManager.Instance.DatabaseExists(databaseName, defaultConnectionString))
{
databaseName = ResolveConflict(defaultConnectionString, connectionString, databasePath, databaseName, controller);
}
if (databaseName != null)
{
SqlServerManager.Instance.AttachDatabase(databaseName, databasePath, defaultConnectionString);
}
}
public Pipeline([NotNull] PipelineDefinition pipelineDefinition, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null, bool isAsync = true)
{
Assert.ArgumentNotNull(pipelineDefinition, "pipelineDefinition");
Assert.ArgumentNotNull(args, "args");
this.controller = controller;
this.pipelineDefinition = pipelineDefinition;
this.title = pipelineDefinition.Title;
this.steps = Step.CreateSteps(this.pipelineDefinition.Steps, args, controller);
this.isAsync = isAsync;
// Storing args for restarting pipeline
this.processorArgs = args;
}
public PipelineStartInfo([NotNull] ProcessorArgs processorArgs, [NotNull] List <Step> steps, [CanBeNull] IPipelineController pipelineController = null)
{
Assert.ArgumentNotNull(processorArgs, "processorArgs");
Assert.ArgumentNotNull(steps, "steps");
this.ProcessorArgs = processorArgs;
this.PipelineController = pipelineController;
this.Steps = steps;
}
private static string GetDatabasesFolder(Instance instance, SqlConnectionStringBuilder connectionString, IPipelineController controller)
{
string databasesFolder;
Database mainDatabase = GetMainDatabase(instance, connectionString);
if (mainDatabase == null)
{
while (true)
{
databasesFolder = controller.Ask(
"Can't find any local database of the " + instance +
" instance to detect the Databases folder. Please specify it manually:",
instance.RootPath.TrimEnd('\\') + "\\Databases");
if (string.IsNullOrEmpty(databasesFolder))
{
if (controller.Confirm("You didn't input anything - would you like to terminate this installation?"))
{
throw new Exception("Aborted.");
}
continue;
}
if (!FileSystem.FileSystem.Local.Directory.Exists(databasesFolder))
{
if (controller.Confirm("The " + databasesFolder + " doesn't exist. Would you like to create the folder?"))
{
FileSystem.FileSystem.Local.Directory.CreateDirectory(databasesFolder);
break;
}
}
else
{
break;
}
}
}
else
{
databasesFolder = Path.GetDirectoryName(mainDatabase.FileName).EmptyToNull();
}
return(databasesFolder);
}
public static void AttachDatabase(Adapters.WebServer.ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, string name, string sqlPrefix, bool attachSql, string databasesFolderPath, string instanceName, IPipelineController controller)
{
if (connectionString.IsMongoConnectionString)
{
connectionString.Value = GetMongoConnectionString(connectionString.Name, sqlPrefix);
connectionString.SaveChanges();
return;
}
if (connectionString.IsSqlConnectionString)
{
AttachDatabase(name, sqlPrefix, attachSql, databasesFolderPath, connectionString, defaultConnectionString, controller);
}
}
private static void ProcessActions(Instance instance, SqlConnectionStringBuilder connectionString,
IPipelineController controller, Product module, Dictionary <string, string> variables,
XmlElement actionsElement)
{
// made replacement
actionsElement.InnerXml = variables.Aggregate(actionsElement.InnerXml,
(result, variable) => result.Replace(variable.Key, variable.Value)).Replace("{InstanceName}", instance.Name);
var actions = actionsElement.ChildNodes.OfType <XmlElement>();
var webRootPath = instance.WebRootPath;
List <string> ignoreCommands = new List <string>();
foreach (XmlElement action in actions.Where(a => a.Name.EqualsIgnoreCase("patch")))
{
var commandText = action.GetAttribute("command").EmptyToNull().IsNotNull("The command attribute of <patch /> element must exist and must not be empty");
var actionText = action.GetAttribute("action");
if (actionText == "delete")
{
ignoreCommands.Add(commandText);
}
}
// give extract more priority
if (actions.Any(xml => xml.Name.EqualsIgnoreCase("extract")) && !ignoreCommands.Contains("extract"))
{
FileSystem.FileSystem.Local.Zip.UnpackZip(module.PackagePath, instance.WebRootPath);
}
foreach (XmlElement action in actions)
{
var children = action.ChildNodes.OfType <XmlElement>();
string actionName = action.Name;
if (ignoreCommands.Contains(actionName))
{
continue;
}
switch (actionName)
{
case "extract":
{
// give extract more priority
// FileSystem.Instance.UnpackZip(module.PackagePath, instance.GetRootPath(webRootPath));
break;
}
case "config":
{
string configPath = action.GetAttribute("path");
try
{
XmlDocumentEx config = !string.IsNullOrEmpty(configPath)
? XmlDocumentEx.LoadFile(Path.Combine(webRootPath, configPath))
: instance.GetWebConfig(webRootPath);
PerformConfigChanges(instance, children, module, config, variables);
}
catch (XmlDocumentEx.FileIsMissingException ex)
{
Log.Warn(
"The path attribute is specified (path: {0}) but the file doesn't exist".FormatWith(configPath),
typeof(ConfigurationActions), ex);
}
break;
}
case "databases":
{
AddDatabase(instance, children, module, connectionString, controller);
break;
}
case "editfile":
{
EditFile(action.GetAttribute("path"), children, instance, variables);
break;
}
case "setRestrictingPlaceholders":
{
InstanceHelper.StartInstance(instance);
SetRestrictingPlaceholders(action.GetAttribute("names"), GetWebServiceUrl(instance));
break;
}
case "custom":
{
var typeName = action.GetAttribute("type").EmptyToNull().IsNotNull("The type attribute is missing in the <custom> install action");
var obj = (IPackageInstallActions)ReflectionUtil.CreateObject(typeName);
obj.Execute(instance, module);
break;
}
case "sql":
{
var db = action.GetAttribute("database");
var file = action.GetAttribute("file").Replace("$(data)", instance.DataFolderPath).Replace("$(website)", instance.WebRootPath);
if (!string.IsNullOrEmpty(file))
{
Assert.IsTrue(File.Exists(file), string.Format("The {0} file does not exist", file));
}
var sql = string.IsNullOrEmpty(file) ? action.InnerText : FileSystem.FileSystem.Local.File.ReadAllText(file);
Assert.IsNotNullOrEmpty(sql.Trim(), "The SQL command is empty");
var cstr = instance.Configuration.ConnectionStrings.FirstOrDefault(x => x.Name == db);
Assert.IsNotNull(cstr, "The {0} connection string is not found".FormatWith(db));
using (var conn = SqlServerManager.Instance.OpenConnection(new SqlConnectionStringBuilder(cstr.Value), false))
{
foreach (var command in sql.Split("GO"))
{
SqlServerManager.Instance.Execute(conn, command);
}
}
break;
}
}
}
}
public static void StartPipeline([NotNull] string pipelineName, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController pipelineController = null, bool isAsync = true)
{
Assert.ArgumentNotNull(pipelineName, nameof(pipelineName));
Assert.ArgumentNotNull(args, nameof(args));
Log.Info($"Pipeline '{pipelineName}' starts, isAsync: {isAsync.ToString(CultureInfo.InvariantCulture)}");
using (new ProfileSection("Start pipeline"))
{
ProfileSection.Argument("pipelineName", pipelineName);
ProfileSection.Argument("args", args);
ProfileSection.Argument("pipelineController", pipelineController);
ProfileSection.Argument("isAsync", isAsync);
var pipeline = CreatePipeline(pipelineName, args, pipelineController, isAsync);
pipeline.Start();
}
}
private static IEnumerable<Processor> CreateProcessorsPrivate([NotNull] IEnumerable<ProcessorDefinition> processorDefinitions, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller)
{
Assert.ArgumentNotNull(processorDefinitions, nameof(processorDefinitions));
Assert.ArgumentNotNull(args, nameof(args));
foreach (ProcessorDefinition processorDefinition in processorDefinitions)
{
foreach (Processor processor in processorDefinition.CreateProcessors(args,controller))
{
if (processor.ProcessorDefinition == null)
{
processor.ProcessorDefinition = processorDefinition;
}
bool isRequireProcessing = true;
try
{
isRequireProcessing = processor.IsRequireProcessing(args);
}
catch (Exception ex)
{
Log.Warn(ex, $"Cannot detect if the processor {processor.ProcessorDefinition.Type} requires processing");
}
if (isRequireProcessing)
{
List<Processor> nested = CreateProcessors(processorDefinition._NestedProcessorDefinitions, args, controller);
processor._NestedProcessors.AddRange(nested);
processor.Controller = controller;
yield return processor;
}
}
}
}
public static List <Processor> CreateProcessors([NotNull] IEnumerable <ProcessorDefinition> processorDefinitions, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null)
{
Assert.ArgumentNotNull(processorDefinitions, "processorDefinitions");
Assert.ArgumentNotNull(args, "args");
return(new List <Processor>(CreateProcessorsPrivate(processorDefinitions, args, controller)));
}
public PipelineStartInfo([NotNull] ProcessorArgs processorArgs, [NotNull] List <Step> steps, [CanBeNull] IPipelineController pipelineController = null)
{
Assert.ArgumentNotNull(processorArgs, nameof(processorArgs));
Assert.ArgumentNotNull(steps, nameof(steps));
ProcessorArgs = processorArgs;
PipelineController = pipelineController;
_Steps = steps;
}
public PipelineStartInfo([NotNull] ProcessorArgs processorArgs, [NotNull] List<Step> steps, [CanBeNull] IPipelineController pipelineController = null)
{
Assert.ArgumentNotNull(processorArgs, "processorArgs");
Assert.ArgumentNotNull(steps, "steps");
this.ProcessorArgs = processorArgs;
this.PipelineController = pipelineController;
this.Steps = steps;
}
public Pipeline([NotNull] PipelineDefinition pipelineDefinition, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null, bool isAsync = true)
{
Assert.ArgumentNotNull(pipelineDefinition, nameof(pipelineDefinition));
Assert.ArgumentNotNull(args, nameof(args));
Controller = controller;
PipelineDefinition = pipelineDefinition;
Title = pipelineDefinition.Title;
_Steps = Step.CreateSteps(PipelineDefinition.Steps, args, controller);
IsAsync = isAsync;
// Storing args for restarting pipeline
ProcessorArgs = args;
}
public static List <Step> CreateSteps([NotNull] List <StepDefinition> stepDefinitions, [NotNull] ProcessorArgs args, [CanBeNull] IPipelineController controller = null)
{
Assert.ArgumentNotNull(stepDefinitions, nameof(stepDefinitions));
Assert.ArgumentNotNull(args, nameof(args));
return(new List <Step>(CreateStepsPrivate(stepDefinitions, args, controller)));
}
public static string ResolveConflict(SqlConnectionStringBuilder defaultConnectionString, ConnectionString connectionString, string databasePath, string databaseName, IPipelineController controller)
{
string existingDatabasePath = SqlServerManager.Instance.GetDatabaseFileName(databaseName, defaultConnectionString);
if (string.IsNullOrEmpty(existingDatabasePath))
{
var m = "The database with the same '{0}' name is already exists in the SQL Server metabase but points to non-existing file. ".FormatWith(databaseName);
if (controller.Confirm(m + "Would you like to delete it?"))
{
SqlServerManager.Instance.DeleteDatabase(databaseName, defaultConnectionString);
return databaseName;
}
throw new Exception(m);
}
if (existingDatabasePath.EqualsIgnoreCase(databasePath))
{
return null;
}
// todo: replce this with shiny message box
string delete = "Delete the '{0}' database".FormatWith(databaseName);
const string AnotherName = "Use another database name";
const string Cancel = "Terminate current action";
string[] options = new[]
{
delete, AnotherName, Cancel
};
string m2 = "The database with '{0}' name already exists".FormatWith(databaseName);
string result = controller.Select(m2, options);
switch (result)
{
case Cancel:
throw new Exception(m2);
case AnotherName:
databaseName = ResolveConflictByUnsedName(defaultConnectionString, connectionString, databaseName);
break;
default:
SqlServerManager.Instance.DeleteDatabase(databaseName, defaultConnectionString);
break;
}
return databaseName;
}
private static void AddDatabase([NotNull] Instance instance, [NotNull] IEnumerable<XmlElement> databases, [NotNull] Product module, SqlConnectionStringBuilder connectionString, IPipelineController controller)
{
Assert.ArgumentNotNull(instance, "instance");
Assert.ArgumentNotNull(databases, "databases");
Assert.ArgumentNotNull(module, "module");
Assert.ArgumentNotNull(connectionString, "connectionString");
foreach (XmlElement database in databases)
{
string name = database.GetAttribute("name");
string role = database.GetAttribute("role").EmptyToNull() ?? name;
string fileName = database.GetAttribute("fileName");
string sourceFileName = database.GetAttribute("sourceFileName");
string databasesFolder = GetDatabasesFolder(instance, connectionString, controller);
var locationInPackage = database.GetAttribute("location");
Assert.IsNotNull(databasesFolder, "databasesFolder");
FileSystem.FileSystem.Local.Directory.AssertExists(databasesFolder);
bool skipAttach = false;
string realDBname = SqlServerManager.Instance.GenerateDatabaseRealName(instance.Name, role);
string physicalPath = Path.Combine(databasesFolder, fileName);
var newDatabaseConnectionString = new SqlConnectionStringBuilder(connectionString.ToString());
newDatabaseConnectionString.InitialCatalog = realDBname;
if (SqlServerManager.Instance.DatabaseExists(realDBname, newDatabaseConnectionString))
{
string databasePath = SqlServerManager.Instance.GetDatabaseFileName(realDBname, newDatabaseConnectionString);
const string theDatabaseExists = "The database with the same name ('{0}') already exists in the current instance of SQL Server ('{1}')";
if (string.IsNullOrEmpty(databasePath))
{
string message = string.Format(theDatabaseExists + ", but doesn't point to any file(s) and looks like corrupted.", realDBname, newDatabaseConnectionString.DataSource);
if (!controller.Confirm(message + " Would you like to delete it? If not then this installation will be interrupted."))
{
throw new InvalidOperationException(message);
}
SqlServerManager.Instance.DeleteDatabase(realDBname, newDatabaseConnectionString);
}
else if (!databasePath.EqualsIgnoreCase(physicalPath))
{
throw new InvalidOperationException(string.Format(theDatabaseExists + ", but points to files by another location ('{2}') than was expected ('{3}')", realDBname, newDatabaseConnectionString.DataSource, databasePath, physicalPath));
}
skipAttach = true;
}
if (!skipAttach)
{
if ("data".Equals(locationInPackage, StringComparison.InvariantCulture))
{
var sourceMdfFile = Path.Combine(instance.DataFolderPath, fileName);
var sourceLdfFile = Path.ChangeExtension(sourceMdfFile, "ldf");
if (!FileSystem.FileSystem.Local.File.Exists(sourceMdfFile) || !FileSystem.FileSystem.Local.File.Exists(sourceLdfFile))
{
throw new InvalidOperationException("mdf or ldf database files not found in Data folder");
}
var targetLdfFile = Path.ChangeExtension(physicalPath, "ldf");
FileSystem.FileSystem.Local.File.Move(sourceMdfFile, physicalPath);
FileSystem.FileSystem.Local.File.Move(sourceLdfFile, targetLdfFile);
}
else
{
ExtractDatabase(module, fileName, sourceFileName, databasesFolder, locationInPackage);
}
SqlServerManager.Instance.AttachDatabase(realDBname, physicalPath, newDatabaseConnectionString);
}
instance.Configuration.ConnectionStrings.Add(name, newDatabaseConnectionString);
}
}
public static void Process(IEnumerable <Database> innerDatabases, string rootPath, SqlConnectionStringBuilder connectionString, string instanceName, IPipelineController controller, List <string> done)
{
var localDataSource = SqlServerManager.Instance.NormalizeServerName(connectionString.DataSource);
foreach (Database database in innerDatabases)
{
var cstr = database.ConnectionString.ToString();
if (!SqlServerManager.Instance.IsSqlConnectionString(cstr))
{
continue;
}
// if the database is attached to remote SQL Server
var dataSource = SqlServerManager.Instance.NormalizeServerName(database.ConnectionString.DataSource);
if (!dataSource.EqualsIgnoreCase(localDataSource))
{
// user doesn't confirm deleting
if (controller == null || !controller.Confirm("The '{0}' database seems to be located on the '{1}' remote SQL server instead of the '{2}' local one specified in the Settings dialog. \n\nShould it be deleted as well?".FormatWith(database.RealName, dataSource, localDataSource)))
{
continue;
}
}
var fileName = database.FileName;
if (!string.IsNullOrEmpty(fileName))
{
// database is located out of the rootPath folder
if (!fileName.ToLower().Contains(rootPath))
{
// user doesn't confirm deleting
if (controller == null || !controller.Confirm("The '{0}' database with '{1}' file path is located out of the {2} instance's root path '{3}'. \n\nShould it be deleted as well?".FormatWith(database.RealName, fileName, instanceName, rootPath)))
{
continue;
}
}
}
if (SqlServerManager.Instance.DatabaseExists(database.RealName, connectionString))
{
database.Delete();
}
}
SqlServerManager.Instance.DetectDatabases(rootPath, connectionString, name =>
{
if (!done.Contains(name))
{
SqlServerManager.Instance.DeleteDatabase(name,
connectionString);
done.Add(name);
}
});
}
private static string GetDatabasesFolder(Instance instance, SqlConnectionStringBuilder connectionString, IPipelineController controller)
{
string databasesFolder;
Database mainDatabase = GetMainDatabase(instance, connectionString);
if (mainDatabase == null)
{
while (true)
{
databasesFolder = controller.Ask(
"Can't find any local database of the " + instance +
" instance to detect the Databases folder. Please specify it manually:",
instance.RootPath.TrimEnd('\\') + "\\Databases");
if (string.IsNullOrEmpty(databasesFolder))
{
if (controller.Confirm("You didn't input anything - would you like to terminate this installation?"))
{
throw new Exception("Aborted.");
}
continue;
}
if (!FileSystem.FileSystem.Local.Directory.Exists(databasesFolder))
{
if (controller.Confirm("The " + databasesFolder + " doesn't exist. Would you like to create the folder?"))
{
FileSystem.FileSystem.Local.Directory.CreateDirectory(databasesFolder);
break;
}
}
else
{
break;
}
}
}
else
{
databasesFolder = Path.GetDirectoryName(mainDatabase.FileName).EmptyToNull();
}
return databasesFolder;
}
private static bool ExecuteSteps([NotNull] ProcessorArgs args, [NotNull] IEnumerable <Step> steps, [CanBeNull] IPipelineController controller = null, bool startThisAndNestedProcessors = true)
{
Assert.ArgumentNotNull(args, nameof(args));
Assert.ArgumentNotNull(steps, nameof(steps));
using (new ProfileSection("Execute pipeline steps"))
{
ProfileSection.Argument("args", args);
ProfileSection.Argument("steps", steps);
ProfileSection.Argument("controller", controller);
ProfileSection.Argument("startThisAndNestedProcessors", startThisAndNestedProcessors);
foreach (Step step in steps)
{
ProcessorArgs innerArgs = null;
/* Use args' member as args for nested pipeline*/
var argsName = step.ArgsName.EmptyToNull();
if (argsName != null)
{
Type type = args.GetType();
const BindingFlags Flags = BindingFlags.Instance | BindingFlags.NonPublic;
FieldInfo field = type.GetField(argsName) ?? type.GetField(argsName, Flags);
if (field != null)
{
innerArgs = (ProcessorArgs)field.GetValue(args);
}
else
{
PropertyInfo property = type.GetProperty(argsName) ?? type.GetProperty(argsName, Flags);
if (property != null)
{
innerArgs = (ProcessorArgs)property.GetValue(args, new object[0]);
}
}
Assert.IsNotNull(innerArgs, "Inner args are null, " + argsName);
}
startThisAndNestedProcessors = ExecuteProcessors(innerArgs ?? args, step._Processors, controller,
startThisAndNestedProcessors);
}
return(startThisAndNestedProcessors);
}
}
public static void ExtractFile([NotNull] string packagePath, [NotNull] string webRootPath, [NotNull] string databasesFolderPath, [NotNull] string dataFolderPath, bool attachSql, bool installRadControls, bool installDictionaries, [CanBeNull] IPipelineController controller = null)
{
Assert.ArgumentNotNull(packagePath, nameof(packagePath));
Assert.ArgumentNotNull(webRootPath, nameof(webRootPath));
Assert.ArgumentNotNull(databasesFolderPath, nameof(databasesFolderPath));
Assert.ArgumentNotNull(dataFolderPath, nameof(dataFolderPath));
Log.Info($"Extracting {packagePath}");
var ignore = installRadControls ? ":#!" : RadControls;
var ignore2 = installDictionaries ? ":#!" : Dictionaries;
var incrementProgress = controller != null ? new Action <long>(controller.IncrementProgress) : null;
try
{
using (var zip = new ZipFile(packagePath))
{
var prefix = zip.Entries.First(x => x.FileName.StartsWith("Sitecore ")).FileName;
prefix = prefix.Substring(0, prefix.IndexOf('/', 1));
var webRootPrefix = prefix + "/Website/";
var websitePrefixLength = webRootPrefix.Length;
var databasesPrefix = prefix + "/Databases/";
var databasesPrefixLength = databasesPrefix.Length;
var databasesPrefix2 = "Databases/";
var databasesPrefix2Length = databasesPrefix2.Length;
var dataPrefix = prefix + "/Data/";
var dataPrefixLength = dataPrefix.Length;
foreach (var entry in zip.Entries)
{
if (incrementProgress != null)
{
incrementProgress(1);
}
var fileName = entry.FileName;
if (fileName.StartsWith(webRootPrefix, StringComparison.OrdinalIgnoreCase))
{
var virtualFilePath = fileName.Substring(websitePrefixLength);
if (virtualFilePath.StartsWith(ignore, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (virtualFilePath.StartsWith(ignore2, StringComparison.OrdinalIgnoreCase))
{
continue;
}
var filePath = Path.Combine(webRootPath, fileName.Substring(websitePrefixLength));
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else if (fileName.StartsWith(databasesPrefix, StringComparison.OrdinalIgnoreCase))
{
if (!attachSql)
{
continue;
}
if (!fileName.EndsWith(".mdf", StringComparison.OrdinalIgnoreCase) && !fileName.EndsWith(".dacpac", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var text = fileName.Substring(databasesPrefixLength);
if (text.Contains("Sitecore.Analytics."))
{
text = text.Replace("Sitecore.Analytics.", "Sitecore.Reporting.");
}
var filePath = Path.Combine(databasesFolderPath, text);
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else if (fileName.StartsWith(databasesPrefix2, StringComparison.OrdinalIgnoreCase))
{
if (!attachSql)
{
continue;
}
if (!fileName.EndsWith(".mdf", StringComparison.OrdinalIgnoreCase) && !fileName.EndsWith(".dacpac", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var text = fileName.Substring(databasesPrefix2Length);
if (text.Contains("Sitecore.Analytics."))
{
text = text.Replace("Sitecore.Analytics.", "Sitecore.Reporting.");
}
var filePath = Path.Combine(databasesFolderPath, text);
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else if (fileName.StartsWith(dataPrefix, StringComparison.OrdinalIgnoreCase))
{
var filePath = Path.Combine(dataFolderPath, fileName.Substring(dataPrefixLength));
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else
{
Log.Warn($"Unexpected file or directory is ignored: {fileName}");
}
}
}
}
catch (ZipException)
{
throw new InvalidOperationException($"The \"{packagePath}\" package seems to be corrupted.");
}
}
public abstract IEnumerable <Processor> CreateProcessors(ProcessorArgs args, IPipelineController controller);
private static bool ExecuteProcessors([NotNull] ProcessorArgs args, [NotNull] IEnumerable <Processor> processorList, [CanBeNull] IPipelineController controller = null, bool startThisAndNestedProcessors = true)
{
Assert.ArgumentNotNull(args, nameof(args));
Assert.ArgumentNotNull(processorList, nameof(processorList));
using (new ProfileSection("Execute pipeline processors"))
{
ProfileSection.Argument("args", args);
ProfileSection.Argument("processorList", processorList);
ProfileSection.Argument("controller", controller);
ProfileSection.Argument("startThisAndNestedProcessors", startThisAndNestedProcessors);
bool result = startThisAndNestedProcessors;
foreach (Processor processor in processorList)
{
bool processorResult = startThisAndNestedProcessors;
if (processorResult)
{
processorResult = processor.Execute(args);
}
else
{
processor.Skip();
}
if (controller != null)
{
controller.IncrementProgress();
}
// Process nested steps
result &= ExecuteProcessors(args, processor._NestedProcessors, controller, processorResult);
}
return(ProfileSection.Result(result));
}
}
public static string ResolveConflict(SqlConnectionStringBuilder defaultConnectionString, ConnectionString connectionString, string databasePath, string databaseName, IPipelineController controller)
{
string existingDatabasePath = SqlServerManager.Instance.GetDatabaseFileName(databaseName, defaultConnectionString);
if (string.IsNullOrEmpty(existingDatabasePath))
{
var m = "The database with the same '{0}' name is already exists in the SQL Server metabase but points to non-existing file. ".FormatWith(databaseName);
if (controller.Confirm(m + "Would you like to delete it?"))
{
SqlServerManager.Instance.DeleteDatabase(databaseName, defaultConnectionString);
return(databaseName);
}
throw new Exception(m);
}
if (existingDatabasePath.EqualsIgnoreCase(databasePath))
{
return(null);
}
// todo: replce this with shiny message box
string delete = "Delete the '{0}' database".FormatWith(databaseName);
const string AnotherName = "Use another database name";
const string Cancel = "Terminate current action";
string[] options = new[]
{
delete, AnotherName, Cancel
};
string m2 = "The database with '{0}' name already exists".FormatWith(databaseName);
string result = controller.Select(m2, options);
switch (result)
{
case Cancel:
throw new Exception(m2);
case AnotherName:
databaseName = ResolveConflictByUnsedName(defaultConnectionString, connectionString, databaseName);
break;
default:
SqlServerManager.Instance.DeleteDatabase(databaseName, defaultConnectionString);
break;
}
return(databaseName);
}
public static void AttachDatabase(string name, string databasesFolderPath, ConnectionString connectionString, SqlConnectionStringBuilder defaultConnectionString, IPipelineController controller)
{
SetConnectionStringNode(name, defaultConnectionString, connectionString);
string databaseName = connectionString.GenerateDatabaseName(name);
string databasePath =
DatabaseFilenameHook(Path.Combine(databasesFolderPath, connectionString.DefaultFileName),
connectionString.Name.Replace("yafnet", "forum"), databasesFolderPath);
if (!FileSystem.FileSystem.Local.File.Exists(databasePath))
{
var file = Path.GetFileName(databasePath);
if (connectionString.Name.EqualsIgnoreCase("reporting"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Analytics.mdf");
}
else if (connectionString.Name.EqualsIgnoreCase("exm.dispatch"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Exm.mdf");
}
else if (connectionString.Name.EqualsIgnoreCase("session"))
{
databasePath = Path.Combine(Path.GetDirectoryName(databasePath), "Sitecore.Sessions.mdf");
}
}
FileSystem.FileSystem.Local.File.AssertExists(databasePath, databasePath + " file doesn't exist");
if (SqlServerManager.Instance.DatabaseExists(databaseName, defaultConnectionString))
{
databaseName = ResolveConflict(defaultConnectionString, connectionString, databasePath, databaseName, controller);
}
if (databaseName != null)
{
SqlServerManager.Instance.AttachDatabase(databaseName, databasePath, defaultConnectionString);
}
}
public static void ExtractFile([NotNull] string packagePath, [NotNull] string webRootPath, [NotNull] string databasesFolderPath, [NotNull] string dataFolderPath, [CanBeNull] IPipelineController controller = null)
{
Assert.ArgumentNotNull(packagePath, "packagePath");
Assert.ArgumentNotNull(webRootPath, "webRootPath");
Assert.ArgumentNotNull(databasesFolderPath, "databasesFolderPath");
Assert.ArgumentNotNull(dataFolderPath, "dataFolderPath");
Log.Info("Extracting {0}".FormatWith(packagePath), typeof(InstallHelper));
var ignore = Settings.CoreInstallRadControls.Value ? ":#!" : "sitecore/shell/RadControls";
var ignore2 = Settings.CoreInstallDictionaries.Value ? ":#!" : "sitecore/shell/Controls/Rich Text Editor/Dictionaries";
var incrementProgress = controller != null ? new Action <long>(controller.IncrementProgress) : null;
try
{
using (var zip = new ZipFile(packagePath))
{
var prefix = zip.Entries.First().FileName;
prefix = prefix.Substring(0, prefix.IndexOf('/', 1));
var webRootPrefix = prefix + "/Website/";
var websitePrefixLength = webRootPrefix.Length;
var databasesPrefix = prefix + "/Databases/";
var databasesPrefixLength = databasesPrefix.Length;
var dataPrefix = prefix + "/Data/";
var dataPrefixLength = dataPrefix.Length;
foreach (var entry in zip.Entries)
{
if (incrementProgress != null)
{
incrementProgress(1);
}
var fileName = entry.FileName;
if (fileName.StartsWith(webRootPrefix, StringComparison.OrdinalIgnoreCase))
{
var virtualFilePath = fileName.Substring(websitePrefixLength);
if (virtualFilePath.StartsWith(ignore, StringComparison.OrdinalIgnoreCase))
{
continue;
}
if (virtualFilePath.StartsWith(ignore2, StringComparison.OrdinalIgnoreCase))
{
continue;
}
var filePath = Path.Combine(webRootPath, fileName.Substring(websitePrefixLength));
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else if (fileName.StartsWith(databasesPrefix, StringComparison.OrdinalIgnoreCase))
{
if (fileName.EndsWith(".ldf"))
{
continue;
}
var filePath = Path.Combine(databasesFolderPath, fileName.Substring(databasesPrefixLength));
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else if (fileName.StartsWith(dataPrefix, StringComparison.OrdinalIgnoreCase))
{
var filePath = Path.Combine(dataFolderPath, fileName.Substring(dataPrefixLength));
if (entry.IsDirectory)
{
Directory.CreateDirectory(filePath);
continue;
}
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var write = new StreamWriter(filePath))
{
entry.Extract(write.BaseStream);
}
}
else
{
Log.Warn("Unexpected file or directory is ignored: " + fileName, typeof(InstallHelper));
}
}
}
}
catch (ZipException)
{
throw new InvalidOperationException(string.Format("The \"{0}\" package seems to be corrupted.", packagePath));
}
}
