private static InstallResult ValidatePackage(IManifest[] manifests, StepVisitor visitor, bool enableCustomValidation, out int warnings)
{
InstallResult result = new InstallResult();
warnings = 0;
int warn;
if (enableCustomValidation)
{
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnPackageValidating(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
}
foreach (var manifest in manifests)
{
if (enableCustomValidation)
{
Logger.LogMessage(String.Concat("Validating ", manifest.PackageInfo.Name, " (version: ", manifest.PackageInfo.Version, ")"));
}
var pkgInfo = manifest.PackageInfo;
if (pkgInfo == null)
{
Logger.LogMessage("Required PackageDescription is missing");
return(new InstallResult {
Successful = false
});
}
CheckPackageNameAndVersion(pkgInfo);
if (enableCustomValidation)
{
Logger.LogMessage("Package is valid.");
}
}
if (enableCustomValidation)
{
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnPackageValidated(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
}
return(new InstallResult {
Successful = true
});
}
private static bool ExecuteStepFamily(IEnumerable <InstallStep> steps, StepVisitor visitor, out bool needRestart, out int warnings)
{
warnings = 0;
needRestart = false;
//-- initialize steps
try
{
foreach (var step in steps)
{
step.Initialize();
}
}
catch (Exception e)
{
Logger.LogException(e, "INITIALIZING ERROR");
return(false);
}
//-- excute steps
foreach (var step in steps)
{
try
{
StepResult result = visitor.DoIt(step);
needRestart = result.NeedRestart;
if (result.Kind == StepResultKind.Error)
{
return(false);
}
if (result.Kind == StepResultKind.Warning)
{
warnings++;
}
}
catch (Exception e)
{
Logger.LogException(e);
return(false);
}
}
return(true);
}
private static InstallResult DoIt(string fsPath, StepVisitor visitor, bool withBinaries)
{
InstallResult result = new InstallResult {
Successful = true, NeedRestart = false
};
try
{
int warn;
int err;
int warnings = 0;
int errors = 0;
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(AssemblyHandler.CurrentDomain_ReflectionOnlyAssemblyResolve);
var unpacker = CreateUnpacker(fsPath);
var manifests = unpacker.Unpack(fsPath);
var dbScripts = GetDbScripts(manifests);
InstallResult dbScriptResult;
dbScriptResult = ExecuteDbScripts(PositionInSequence.BeforePackageValidating, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
var validateResult = ValidatePackage(manifests, visitor, withBinaries, out warn);
warnings += warn;
if (!validateResult.Successful)
{
return(validateResult);
}
result.Combine(validateResult);
dbScriptResult = ExecuteDbScripts(PositionInSequence.AfterPackageValidating, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
//------------------------------------------------------------
if (withBinaries)
{
dbScriptResult = ExecuteDbScripts(PositionInSequence.BeforeCheckRequirements, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
Logger.LogMessage("");
Logger.LogMessage("------------------------------ Prerequisits ---------------------------------");
Logger.LogMessage("");
result.Combine(ExecutePrerequisits(manifests, visitor, out warn, out err));
warnings += warn;
if (!result.Successful)
{
return(result);
}
dbScriptResult = ExecuteDbScripts(PositionInSequence.AfterCheckRequirements, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
dbScriptResult = ExecuteDbScripts(PositionInSequence.BeforeExecutables, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
Logger.LogMessage("");
Logger.LogMessage("------------------------------ Executables ----------------------------------");
Logger.LogMessage("");
result.Combine(ExecuteExecutables(manifests, visitor, out warn, out err));
warnings += warn;
dbScriptResult = ExecuteDbScripts(PositionInSequence.AfterExecutables, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
if (!result.Successful || result.NeedRestart)
{
if (warnings > 0)
{
Logger.LogMessage(String.Concat(warnings, " warnings"));
}
if (errors > 0)
{
Logger.LogMessage(String.Concat(errors, " errors"));
}
return(result);
}
}
dbScriptResult = ExecuteDbScripts(PositionInSequence.BeforeContentTypes, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
Logger.LogMessage("");
Logger.LogMessage("------------------------------ ContentTypes ---------------------------------");
Logger.LogMessage("");
result.Combine(ExecuteContentTypes(manifests, visitor, out warn, out err));
warnings += warn;
if (!result.Successful)
{
return(result);
}
dbScriptResult = ExecuteDbScripts(PositionInSequence.AfterContentTypes, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
dbScriptResult = ExecuteDbScripts(PositionInSequence.BeforeContents, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
Logger.LogMessage("");
Logger.LogMessage("-------------------------------- Contents -----------------------------------");
Logger.LogMessage("");
result.Combine(ExecuteContents(manifests, visitor, out warn, out err));
warnings += warn;
if (!result.Successful)
{
return(result);
}
dbScriptResult = ExecuteDbScripts(PositionInSequence.AfterContents, dbScripts, visitor);
if (!dbScriptResult.Successful)
{
return(dbScriptResult);
}
result.Combine(dbScriptResult);
if (warnings > 0)
{
Logger.LogMessage(String.Concat(warnings, " warnings"));
}
if (errors > 0)
{
Logger.LogMessage(String.Concat(errors, " errors"));
}
return(result);
}
catch (Exception e)
{
Logger.LogException(e);
return(new InstallResult {
Successful = false
});
}
}
private static InstallResult ExecuteDbScripts(PositionInSequence positionInSequence, IEnumerable <DbScriptInstallStep> dbScripts, StepVisitor visitor)
{
var currentScripts = (from dbScript in dbScripts where dbScript.Running == positionInSequence select dbScript).Cast <InstallStep>().ToArray <InstallStep>();
if (currentScripts.Length == 0)
{
return new InstallResult {
Successful = true
}
}
;
Logger.LogMessage("");
Logger.LogMessage(String.Concat("------------------- Execute DbScripts " + positionInSequence.ToString() + " -------------------"));
Logger.LogMessage("");
bool needRestart;
int warnings;
if (!ExecuteStepFamily(currentScripts, visitor, out needRestart, out warnings))
{
return(ReturnWithErrorResult());
}
return(new InstallResult {
Successful = true, NeedRestart = false
});
}
private static InstallResult ExecuteContents(IEnumerable <IManifest> manifests, StepVisitor visitor, out int warnings, out int errors)
{
warnings = 0;
int warn;
errors = 0;
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnBeforeInstallContents(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
var contentSteps = new List <ContentInstallStep>();
foreach (var manifest in manifests)
{
contentSteps.AddRange(GetContentSteps(manifest));
}
//---- Initialize contents
try
{
foreach (var step in contentSteps)
{
step.Initialize();
}
}
catch (Exception e)
{
Logger.LogException(e, "INITIALIZING ERROR");
return(ReturnWithErrorResult());
}
//---- Install contents
contentSteps.Sort();
var postponedContents = new List <ContentInstallStep>();
foreach (var step in contentSteps)
{
try
{
StepResult result = visitor.DoIt(step);
if (result.Kind == StepResultKind.Warning)
{
warnings++;
}
if (result.Kind == StepResultKind.Error)
{
return(ReturnWithErrorResult());
}
if (result.NeedSetReferencePhase)
{
postponedContents.Add(step);
}
}
catch (Exception e)
{
Logger.LogException(e);
return(ReturnWithErrorResult());
}
}
foreach (var step in postponedContents)
{
try
{
StepResult result = step.SetReferences();
if (result.Kind == StepResultKind.Warning)
{
warnings++;
}
if (result.Kind == StepResultKind.Error)
{
errors++;
}
}
catch (Exception e)
{
Logger.LogException(e);
return(ReturnWithErrorResult());
}
}
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnAfterInstallContents(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
return(new InstallResult {
Successful = true, NeedRestart = false
});
}
private static InstallResult ExecuteContentTypes(IEnumerable <IManifest> manifests, StepVisitor visitor, out int warnings, out int errors)
{
warnings = 0;
errors = 0;
int warn;
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnBeforeInstallContentTypes(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
var batchContentTypeInstallStep = AggregateContentTypeInstallSteps(manifests);
if (batchContentTypeInstallStep != null)
{
//---- Initialize
try
{
batchContentTypeInstallStep.Initialize();
}
catch (Exception e)
{
Logger.LogException(e, "INITIALIZING ERROR");
return(ReturnWithErrorResult());
}
//---- Install
try
{
StepResult result = visitor.DoIt(batchContentTypeInstallStep);
if (result.Kind == StepResultKind.Warning)
{
warnings++;
}
if (result.Kind == StepResultKind.Error)
{
return(ReturnWithErrorResult());
}
}
catch (Exception e)
{
Logger.LogException(e);
return(ReturnWithErrorResult());
}
}
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnAfterInstallContentTypes(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
return(new InstallResult {
Successful = true, NeedRestart = false
});
}
private static InstallResult ExecuteExecutables(IEnumerable <IManifest> manifests, StepVisitor visitor, out int warnings, out int errors)
{
int warn;
bool needRestart;
bool needRestartAggregated = false;
warnings = 0;
errors = 0;
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnBeforeInstallExecutables(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
foreach (var manifest in manifests)
{
Logger.LogMessage(String.Concat("Package: ", manifest.PackageInfo.Name, " version: ", manifest.PackageInfo.Version));
if (manifest.Executables.Length == 0)
{
Logger.LogMessage("Has not any executables");
}
if (!ExecuteStepFamily(manifest.Executables, visitor, out needRestart, out warn))
{
return(ReturnWithErrorResult());
}
if (needRestart)
{
needRestartAggregated = true;
}
warnings += warn;
}
if (!CustomInstallStep.Invoke(GetMethod <CustomInstallStep>(x => x.OnAfterInstallExecutables(default(bool))), visitor.IsProbing, out warn))
{
return(ReturnWithErrorResult());
}
warnings += warn;
return(new InstallResult {
Successful = true, NeedRestart = needRestartAggregated
});
}
