public ChocolateyPackageInformation get_package_information(IPackage package)
{
var packageInformation = new ChocolateyPackageInformation(package);
if (package == null)
{
this.Log().Debug("No package information as package is null.");
return(packageInformation);
}
var pkgStorePath = _fileSystem.combine_paths(ApplicationParameters.ChocolateyPackageInfoStoreLocation, "{0}.{1}".format_with(package.Id, package.Version.to_string()));
if (!_fileSystem.directory_exists(pkgStorePath))
{
return(packageInformation);
}
string registrySnapshotFile = _fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_FILE);
if (_fileSystem.file_exists(registrySnapshotFile))
{
packageInformation.RegistrySnapshot = _registryService.read_from_file(registrySnapshotFile);
}
packageInformation.HasSilentUninstall = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, SILENT_UNINSTALLER_FILE));
packageInformation.IsSideBySide = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, SIDE_BY_SIDE_FILE));
packageInformation.IsPinned = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, PIN_FILE));
return(packageInformation);
}
public void backup_existing_version(ChocolateyConfiguration config, IPackage installedPackage)
{
var pathResolver = NugetCommon.GetPathResolver(config, NugetCommon.GetNuGetFileSystem(config, _nugetLogger));
var pkgInstallPath = pathResolver.GetInstallPath(installedPackage);
if (!_fileSystem.directory_exists(pkgInstallPath))
{
var chocoPathResolver = pathResolver as ChocolateyPackagePathResolver;
if (chocoPathResolver != null)
{
chocoPathResolver.UseSideBySidePaths = !chocoPathResolver.UseSideBySidePaths;
pkgInstallPath = chocoPathResolver.GetInstallPath(installedPackage);
}
}
if (_fileSystem.directory_exists(pkgInstallPath))
{
this.Log().Debug("Backing up existing {0} prior to upgrade.".format_with(installedPackage.Id));
var backupLocation = pkgInstallPath + ApplicationParameters.RollbackPackageSuffix;
_fileSystem.copy_directory(pkgInstallPath, backupLocation, overwriteExisting: true);
}
}
public ChocolateyPackageInformation get_package_information(IPackage package)
{
var packageInformation = new ChocolateyPackageInformation(package);
if (package == null)
{
this.Log().Debug("No package information as package is null.");
return(packageInformation);
}
var pkgStorePath = _fileSystem.combine_paths(ApplicationParameters.ChocolateyPackageInfoStoreLocation, "{0}.{1}".format_with(package.Id, package.Version.to_string()));
if (!_fileSystem.directory_exists(pkgStorePath))
{
return(packageInformation);
}
FaultTolerance.try_catch_with_logging_exception(
() =>
{
packageInformation.RegistrySnapshot = _registryService.read_from_file(_fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_FILE));
},
"Unable to read registry snapshot file for {0} (located at {1})".format_with(package.Id, _fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_FILE)),
throwError: false,
logWarningInsteadOfError: true
);
FaultTolerance.try_catch_with_logging_exception(
() =>
{
packageInformation.FilesSnapshot = _filesService.read_from_file(_fileSystem.combine_paths(pkgStorePath, FILES_SNAPSHOT_FILE));
},
"Unable to read files snapshot file",
throwError: false,
logWarningInsteadOfError: true
);
packageInformation.HasSilentUninstall = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, SILENT_UNINSTALLER_FILE));
packageInformation.IsSideBySide = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, SIDE_BY_SIDE_FILE));
packageInformation.IsPinned = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, PIN_FILE));
var argsFile = _fileSystem.combine_paths(pkgStorePath, ARGS_FILE);
if (_fileSystem.file_exists(argsFile))
{
packageInformation.Arguments = _fileSystem.read_file(argsFile);
}
return(packageInformation);
}
public void handle_package_uninstall(PackageResult packageResult, ChocolateyConfiguration config)
{
if (!_fileSystem.directory_exists(packageResult.InstallLocation))
{
packageResult.InstallLocation += ".{0}".format_with(packageResult.Package.Version.to_string());
}
_shimgenService.uninstall(config, packageResult);
if (!config.SkipPackageInstallProvider)
{
_powershellService.uninstall(config, packageResult);
}
if (packageResult.Success)
{
_autoUninstallerService.run(packageResult, config);
}
// we don't care about the exit code
if (config.Information.PlatformType == PlatformType.Windows)
{
CommandExecutor.execute_static("shutdown", "/a", config.CommandExecutionTimeoutSeconds, _fileSystem.get_current_directory(), (s, e) => { }, (s, e) => { }, false, false);
}
if (packageResult.Success)
{
//todo: v2 clean up package information store for things no longer installed (call it compact?)
uninstall_cleanup(config, packageResult);
}
else
{
this.Log().Error(ChocolateyLoggers.Important, "{0} {1} not successful.".format_with(packageResult.Name, "uninstall"));
handle_unsuccessful_operation(config, packageResult, movePackageToFailureLocation: false, attemptRollback: false);
}
if (!packageResult.Success)
{
// throw an error so that NuGet Service doesn't attempt to continue with package removal
throw new ApplicationException("{0} {1} not successful.".format_with(packageResult.Name, "uninstall"));
}
}
public void remove_rollback_directory_if_exists(string packageName)
{
var rollbackDirectory = _fileSystem.combine_paths(ApplicationParameters.PackageBackupLocation, packageName);
if (!_fileSystem.directory_exists(rollbackDirectory))
{
//search for folder
var possibleRollbacks = _fileSystem.get_directories(ApplicationParameters.PackageBackupLocation, packageName + "*");
if (possibleRollbacks != null && possibleRollbacks.Count() != 0)
{
rollbackDirectory = possibleRollbacks.OrderByDescending(p => p).DefaultIfEmpty(string.Empty).FirstOrDefault();
}
}
if (string.IsNullOrWhiteSpace(rollbackDirectory) || !_fileSystem.directory_exists(rollbackDirectory))
{
return;
}
FaultTolerance.try_catch_with_logging_exception(
() => _fileSystem.delete_directory_if_exists(rollbackDirectory, recursive: true),
"Attempted to remove '{0}' but had an error:".format_with(rollbackDirectory),
logWarningInsteadOfError: true);
}
public ChocolateyPackageInformation get_package_information(IPackage package)
{
var packageInformation = new ChocolateyPackageInformation(package);
if (package == null)
{
this.Log().Debug("No package information as package is null.");
return(packageInformation);
}
var pkgStorePath = _fileSystem.combine_paths(ApplicationParameters.ChocolateyPackageInfoStoreLocation, "{0}.{1}".format_with(package.Id, package.Version.to_string()));
if (!_fileSystem.directory_exists(pkgStorePath))
{
return(packageInformation);
}
var deserializationErrorMessage = @"
A corrupt .registry file exists at {0}.
Open this file in a text editor, and remove/escape any characters that
are regarded as illegal within XML strings not surrounded by CData.
These are typically the characters &, `<`, and `>`. Again, this
is an XML document, so you will see many < and > characters, so just
focus exclusively in the string values not surrounded by CData. Once
these have been corrected, rename the .registry.bad file to .registry.
Once saved, try running the same Chocolatey command that was just
executed, so verify problem is fixed.
NOTE: It will not be possible to rename the file in Windows Explorer.
Instead, you can use the following PowerShell command:
Move-Item .\.registry.bad .\.registry
".format_with(_fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_BAD_FILE));
try
{
if (_fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_BAD_FILE)))
{
this.Log().Warn(deserializationErrorMessage);
}
else
{
packageInformation.RegistrySnapshot = _registryService.read_from_file(_fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_FILE));
}
}
catch (Exception)
{
FaultTolerance.try_catch_with_logging_exception(
() =>
{
this.Log().Warn(deserializationErrorMessage);
// rename the bad registry file so that it isn't processed again
_fileSystem.move_file(_fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_FILE), _fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_BAD_FILE));
},
"Unable to read registry snapshot file for {0} (located at {1})".format_with(package.Id, _fileSystem.combine_paths(pkgStorePath, REGISTRY_SNAPSHOT_FILE)),
throwError: false,
logWarningInsteadOfError: true,
isSilent: true
);
}
FaultTolerance.try_catch_with_logging_exception(
() =>
{
packageInformation.FilesSnapshot = _filesService.read_from_file(_fileSystem.combine_paths(pkgStorePath, FILES_SNAPSHOT_FILE));
},
"Unable to read files snapshot file",
throwError: false,
logWarningInsteadOfError: true,
isSilent: true
);
packageInformation.HasSilentUninstall = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, SILENT_UNINSTALLER_FILE));
packageInformation.IsSideBySide = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, SIDE_BY_SIDE_FILE));
packageInformation.IsPinned = _fileSystem.file_exists(_fileSystem.combine_paths(pkgStorePath, PIN_FILE));
var argsFile = _fileSystem.combine_paths(pkgStorePath, ARGS_FILE);
if (_fileSystem.file_exists(argsFile))
{
packageInformation.Arguments = _fileSystem.read_file(argsFile);
}
var extraInfoFile = _fileSystem.combine_paths(pkgStorePath, EXTRA_FILE);
if (_fileSystem.file_exists(extraInfoFile))
{
packageInformation.ExtraInformation = _fileSystem.read_file(extraInfoFile);
}
var versionOverrideFile = _fileSystem.combine_paths(pkgStorePath, VERSION_OVERRIDE_FILE);
if (_fileSystem.file_exists(versionOverrideFile))
{
FaultTolerance.try_catch_with_logging_exception(
() =>
{
packageInformation.VersionOverride = new SemanticVersion(_fileSystem.read_file(versionOverrideFile).trim_safe());
},
"Unable to read version override file",
throwError: false,
logWarningInsteadOfError: true
);
}
return(packageInformation);
}
public bool run_action(ChocolateyConfiguration configuration, PackageResult packageResult, CommandNameType command)
{
var installerRun = false;
var packageDirectory = packageResult.InstallLocation;
if (packageDirectory.is_equal_to(ApplicationParameters.InstallLocation) || packageDirectory.is_equal_to(ApplicationParameters.PackagesLocation))
{
packageResult.Messages.Add(
new ResultMessage(
ResultType.Error,
"Install location is not specific enough, cannot run PowerShell script:{0} Erroneous install location captured as '{1}'".format_with(Environment.NewLine, packageResult.InstallLocation)
)
);
return(false);
}
if (!_fileSystem.directory_exists(packageDirectory))
{
packageResult.Messages.Add(new ResultMessage(ResultType.Error, "Package install not found:'{0}'".format_with(packageDirectory)));
return(installerRun);
}
var chocoPowerShellScript = get_script_for_action(packageResult, command);
if (!string.IsNullOrEmpty(chocoPowerShellScript))
{
var failure = false;
var package = packageResult.Package;
prepare_powershell_environment(package, configuration, packageDirectory);
this.Log().Debug(ChocolateyLoggers.Important, "Contents of '{0}':".format_with(chocoPowerShellScript));
string chocoPowerShellScriptContents = _fileSystem.read_file(chocoPowerShellScript);
this.Log().Debug(chocoPowerShellScriptContents.escape_curly_braces());
bool shouldRun = !configuration.PromptForConfirmation;
if (!shouldRun)
{
this.Log().Info(ChocolateyLoggers.Important, () => "The package {0} wants to run '{1}'.".format_with(package.Id, _fileSystem.get_file_name(chocoPowerShellScript)));
this.Log().Info(ChocolateyLoggers.Important, () => "Note: If you don't run this script, the installation will fail.");
this.Log().Info(ChocolateyLoggers.Important, () => @"Note: To confirm automatically next time, use '-y' or consider:");
this.Log().Info(ChocolateyLoggers.Important, () => @"choco feature enable -n allowGlobalConfirmation");
var selection = InteractivePrompt.prompt_for_confirmation(@"Do you want to run the script?",
new[] { "yes", "no", "print" },
defaultChoice: null,
requireAnswer: true,
allowShortAnswer: true,
shortPrompt: true
);
if (selection.is_equal_to("print"))
{
this.Log().Info(ChocolateyLoggers.Important, "------ BEGIN SCRIPT ------");
this.Log().Info(() => "{0}{1}{0}".format_with(Environment.NewLine, chocoPowerShellScriptContents.escape_curly_braces()));
this.Log().Info(ChocolateyLoggers.Important, "------- END SCRIPT -------");
selection = InteractivePrompt.prompt_for_confirmation(@"Do you want to run this script?",
new[] { "yes", "no" },
defaultChoice: null,
requireAnswer: true,
allowShortAnswer: true,
shortPrompt: true
);
}
if (selection.is_equal_to("yes"))
{
shouldRun = true;
}
if (selection.is_equal_to("no"))
{
//MSI ERROR_INSTALL_USEREXIT - 1602 - https://support.microsoft.com/en-us/kb/304888 / https://msdn.microsoft.com/en-us/library/aa376931.aspx
//ERROR_INSTALL_CANCEL - 15608 - https://msdn.microsoft.com/en-us/library/windows/desktop/ms681384.aspx
Environment.ExitCode = 15608;
packageResult.Messages.Add(new ResultMessage(ResultType.Error, "User canceled powershell portion of installation for '{0}'.{1} Specify -n to skip automated script actions.".format_with(chocoPowerShellScript, Environment.NewLine)));
}
}
if (shouldRun)
{
installerRun = true;
if (configuration.Features.UsePowerShellHost)
{
add_assembly_resolver();
}
var result = new PowerShellExecutionResults
{
ExitCode = -1
};
try
{
result = configuration.Features.UsePowerShellHost
? Execute.with_timeout(configuration.CommandExecutionTimeoutSeconds).command(() => run_host(configuration, chocoPowerShellScript, null), result)
: run_external_powershell(configuration, chocoPowerShellScript);
}
catch (Exception ex)
{
this.Log().Error(ex.Message.escape_curly_braces());
result.ExitCode = -1;
}
if (configuration.Features.UsePowerShellHost)
{
remove_assembly_resolver();
}
if (result.StandardErrorWritten && configuration.Features.FailOnStandardError)
{
failure = true;
}
else if (result.StandardErrorWritten && result.ExitCode == 0)
{
this.Log().Warn(
() =>
@"Only an exit code of non-zero will fail the package by default. Set
`--failonstderr` if you want error messages to also fail a script. See
`choco -h` for details.");
}
if (result.ExitCode != 0)
{
Environment.ExitCode = result.ExitCode;
packageResult.ExitCode = result.ExitCode;
}
// 0 - most widely used success exit code
// MSI valid exit codes
// 1605 - (uninstall) - the product is not found, could have already been uninstalled
// 1614 (uninstall) - the product is uninstalled
// 1641 - restart initiated
// 3010 - restart required
var validExitCodes = new List <int> {
0, 1605, 1614, 1641, 3010
};
if (!validExitCodes.Contains(result.ExitCode))
{
failure = true;
}
if (!configuration.Features.UsePackageExitCodes)
{
Environment.ExitCode = failure ? 1 : 0;
}
if (failure)
{
packageResult.Messages.Add(new ResultMessage(ResultType.Error, "Error while running '{0}'.{1} See log for details.".format_with(chocoPowerShellScript, Environment.NewLine)));
}
packageResult.Messages.Add(new ResultMessage(ResultType.Note, "Ran '{0}'".format_with(chocoPowerShellScript)));
}
}
return(installerRun);
}
public void generate(ChocolateyConfiguration configuration)
{
var logger = ChocolateyLoggers.Normal;
if (configuration.QuietOutput)
{
logger = ChocolateyLoggers.LogFileOnly;
}
var packageLocation = _fileSystem.combine_paths(configuration.OutputDirectory ?? _fileSystem.get_current_directory(), configuration.NewCommand.Name);
if (_fileSystem.directory_exists(packageLocation) && !configuration.Force)
{
throw new ApplicationException(
"The location for the template already exists. You can:{0} 1. Remove '{1}'{0} 2. Use --force{0} 3. Specify a different name".format_with(Environment.NewLine, packageLocation));
}
if (configuration.RegularOutput)
{
this.Log().Info(logger, () => "Creating a new package specification at {0}".format_with(packageLocation));
}
try
{
_fileSystem.delete_directory_if_exists(packageLocation, recursive: true);
}
catch (Exception ex)
{
if (configuration.RegularOutput)
{
this.Log().Warn(() => "{0}".format_with(ex.Message));
}
}
_fileSystem.create_directory_if_not_exists(packageLocation);
var packageToolsLocation = _fileSystem.combine_paths(packageLocation, "tools");
_fileSystem.create_directory_if_not_exists(packageToolsLocation);
var tokens = new TemplateValues();
if (configuration.NewCommand.AutomaticPackage)
{
tokens.set_auto();
}
// now override those values
foreach (var property in configuration.NewCommand.TemplateProperties)
{
try
{
tokens.GetType().GetProperty(property.Key, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.IgnoreCase).SetValue(tokens, property.Value, null);
this.Log().Debug(() => "Set token for '{0}' to '{1}'".format_with(property.Key, property.Value));
}
catch (Exception)
{
if (configuration.RegularOutput)
{
this.Log().Debug("Property {0} will be added to additional properties.".format_with(property.Key));
}
tokens.AdditionalProperties.Add(property.Key, property.Value);
}
}
this.Log().Debug(() => "Token Values after merge:");
foreach (var propertyInfo in tokens.GetType().GetProperties())
{
this.Log().Debug(() => " {0}={1}".format_with(propertyInfo.Name, propertyInfo.GetValue(tokens, null)));
}
foreach (var additionalProperty in tokens.AdditionalProperties.or_empty_list_if_null())
{
this.Log().Debug(() => " {0}={1}".format_with(additionalProperty.Key, additionalProperty.Value));
}
// Attempt to set the name of the template that will be used to generate the new package
// If no template name has been passed at the command line, check to see if there is a defaultTemplateName set in the
// chocolatey.config file. If there is, and this template exists on disk, use it.
// Otherwise, revert to the built in default template.
// In addition, if the command line option to use the built-in template has been set, respect that
// and use the built in template.
var defaultTemplateName = configuration.DefaultTemplateName;
if (string.IsNullOrWhiteSpace(configuration.NewCommand.TemplateName) && !string.IsNullOrWhiteSpace(defaultTemplateName) && !configuration.NewCommand.UseOriginalTemplate)
{
var defaultTemplateNameLocation = _fileSystem.combine_paths(ApplicationParameters.TemplatesLocation, defaultTemplateName);
if (!_fileSystem.directory_exists(defaultTemplateNameLocation))
{
this.Log().Warn(() => "defaultTemplateName configuration value has been set to '{0}', but no template with that name exists in '{1}'. Reverting to default template.".format_with(defaultTemplateName, ApplicationParameters.TemplatesLocation));
}
else
{
this.Log().Debug(() => "Setting TemplateName to '{0}'".format_with(defaultTemplateName));
configuration.NewCommand.TemplateName = defaultTemplateName;
}
}
var defaultTemplateOverride = _fileSystem.combine_paths(ApplicationParameters.TemplatesLocation, "default");
if (string.IsNullOrWhiteSpace(configuration.NewCommand.TemplateName) && (!_fileSystem.directory_exists(defaultTemplateOverride) || configuration.NewCommand.UseOriginalTemplate))
{
generate_file_from_template(configuration, tokens, NuspecTemplate.Template, _fileSystem.combine_paths(packageLocation, "{0}.nuspec".format_with(tokens.PackageNameLower)), utf8WithoutBOM);
generate_file_from_template(configuration, tokens, ChocolateyInstallTemplate.Template, _fileSystem.combine_paths(packageToolsLocation, "chocolateyinstall.ps1"), Encoding.UTF8);
generate_file_from_template(configuration, tokens, ChocolateyBeforeModifyTemplate.Template, _fileSystem.combine_paths(packageToolsLocation, "chocolateybeforemodify.ps1"), Encoding.UTF8);
generate_file_from_template(configuration, tokens, ChocolateyUninstallTemplate.Template, _fileSystem.combine_paths(packageToolsLocation, "chocolateyuninstall.ps1"), Encoding.UTF8);
generate_file_from_template(configuration, tokens, ChocolateyLicenseFileTemplate.Template, _fileSystem.combine_paths(packageToolsLocation, "LICENSE.txt"), Encoding.UTF8);
generate_file_from_template(configuration, tokens, ChocolateyVerificationFileTemplate.Template, _fileSystem.combine_paths(packageToolsLocation, "VERIFICATION.txt"), Encoding.UTF8);
generate_file_from_template(configuration, tokens, ChocolateyReadMeTemplate.Template, _fileSystem.combine_paths(packageLocation, "ReadMe.md"), Encoding.UTF8);
generate_file_from_template(configuration, tokens, ChocolateyTodoTemplate.Template, _fileSystem.combine_paths(packageLocation, "_TODO.txt"), Encoding.UTF8);
}
else
{
configuration.NewCommand.TemplateName = string.IsNullOrWhiteSpace(configuration.NewCommand.TemplateName) ? "default" : configuration.NewCommand.TemplateName;
var templatePath = _fileSystem.combine_paths(ApplicationParameters.TemplatesLocation, configuration.NewCommand.TemplateName);
if (!_fileSystem.directory_exists(templatePath))
{
throw new ApplicationException("Unable to find path to requested template '{0}'. Path should be '{1}'".format_with(configuration.NewCommand.TemplateName, templatePath));
}
this.Log().Info(configuration.QuietOutput ? logger : ChocolateyLoggers.Important, "Generating package from custom template at '{0}'.".format_with(templatePath));
// Create directory structure from template so as to include empty directories
foreach (var directory in _fileSystem.get_directories(templatePath, "*.*", SearchOption.AllDirectories))
{
var packageDirectoryLocation = directory.Replace(templatePath, packageLocation);
this.Log().Debug("Creating directory {0}".format_with(packageDirectoryLocation));
_fileSystem.create_directory_if_not_exists(packageDirectoryLocation);
}
foreach (var file in _fileSystem.get_files(templatePath, "*.*", SearchOption.AllDirectories))
{
var packageFileLocation = file.Replace(templatePath, packageLocation);
var fileExtension = _fileSystem.get_file_extension(packageFileLocation);
if (fileExtension.is_equal_to(".nuspec"))
{
packageFileLocation = _fileSystem.combine_paths(packageLocation, "{0}.nuspec".format_with(tokens.PackageNameLower));
generate_file_from_template(configuration, tokens, _fileSystem.read_file(file), packageFileLocation, utf8WithoutBOM);
}
else if (_templateBinaryExtensions.Contains(fileExtension))
{
this.Log().Debug(" Treating template file ('{0}') as binary instead of replacing templated values.".format_with(_fileSystem.get_file_name(file)));
_fileSystem.copy_file(file, packageFileLocation, overwriteExisting: true);
}
else
{
generate_file_from_template(configuration, tokens, _fileSystem.read_file(file), packageFileLocation, Encoding.UTF8);
}
}
}
this.Log().Info(configuration.QuietOutput ? logger : ChocolateyLoggers.Important,
"Successfully generated {0}{1} package specification files{2} at '{3}'".format_with(
configuration.NewCommand.Name, configuration.NewCommand.AutomaticPackage ? " (automatic)" : string.Empty, Environment.NewLine, packageLocation));
}
