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 static IPackage BuildPackage(PackageBuilder builder, IFileSystem fileSystem, string outputPath = null)
{
ExcludeFiles(builder.Files);
// Track if the package file was already present on disk
bool isExistingPackage = fileSystem.file_exists(outputPath);
try
{
using (Stream stream = fileSystem.create_file(outputPath))
{
// Truncate if needed, as Mono fails to truncate
if (stream.Length > 0)
{
stream.SetLength(0);
}
builder.Save(stream);
}
}
catch
{
if (!isExistingPackage && fileSystem.file_exists(outputPath))
{
fileSystem.delete_file(outputPath);
}
throw;
}
return(new OptimizedZipPackage(outputPath));
}
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 IPackage download_package(string packageId, string packageVersion, string downloadLocation, IConfigurationSettings configuration)
{
var version = new SemanticVersion(0, 0, 0, 0);
if (!string.IsNullOrWhiteSpace(packageVersion))
{
version = new SemanticVersion(packageVersion);
}
var packageManager = get_package_manager(downloadLocation, configuration);
this.Log().Debug(() => "Searching for {0} v{1} to install from {2}.".format_with(packageId, version.to_string(), packageManager.SourceRepository.Source));
IPackage availablePackage = packageManager.SourceRepository.FindPackage(packageId, version, allowPrereleaseVersions: true, allowUnlisted: true);
if (availablePackage == null)
{
//todo: do something here
}
this.Log().Debug(() => "Installing {0} v{1} from {2}.".format_with(packageId, version.to_string(), packageManager.SourceRepository.Source));
packageManager.InstallPackage(availablePackage, ignoreDependencies: true, allowPrereleaseVersions: true);
var cachePackage = _fileSystem.combine_paths(Environment.GetEnvironmentVariable("LocalAppData"), "NuGet", "Cache", "{0}.{1}.nupkg".format_with(packageId, version.to_string()));
if (_fileSystem.file_exists(cachePackage))
{
_fileSystem.delete_file(cachePackage);
}
this.Log().Debug(() => "Returning {0} v{1} package.".format_with(packageId, version.to_string()));
return(packageManager.LocalRepository.FindPackage(packageId, version, allowPrereleaseVersions: true, allowUnlisted: true));
}
public static IPackage BuildPackage(PackageBuilder builder, IFileSystem fileSystem, string outputPath = null)
{
ExcludeFiles(builder.Files);
// Track if the package file was already present on disk
bool isExistingPackage = fileSystem.file_exists(outputPath);
try
{
using (Stream stream = fileSystem.create_file(outputPath))
{
builder.Save(stream);
}
}
catch
{
if (!isExistingPackage && fileSystem.file_exists(outputPath))
{
fileSystem.delete_file(outputPath);
}
throw;
}
return new OptimizedZipPackage(outputPath);
}
private IEnumerable <ChocolateyConfiguration> get_packages_from_config(string packageConfigFile, ChocolateyConfiguration config, ConcurrentDictionary <string, PackageResult> packageInstalls)
{
IList <ChocolateyConfiguration> packageConfigs = new List <ChocolateyConfiguration>();
if (!_fileSystem.file_exists(_fileSystem.get_full_path(packageConfigFile)))
{
var logMessage = "Could not find '{0}' in the location specified.".format_with(packageConfigFile);
this.Log().Error(ChocolateyLoggers.Important, logMessage);
var results = packageInstalls.GetOrAdd(packageConfigFile, new PackageResult(packageConfigFile, null, null));
results.Messages.Add(new ResultMessage(ResultType.Error, logMessage));
return(packageConfigs);
}
var settings = _xmlService.deserialize <PackagesConfigFileSettings>(_fileSystem.get_full_path(packageConfigFile));
foreach (var pkgSettings in settings.Packages.or_empty_list_if_null())
{
if (!pkgSettings.Disabled)
{
var packageConfig = config.deep_copy();
packageConfig.PackageNames = pkgSettings.Id;
packageConfig.Sources = string.IsNullOrWhiteSpace(pkgSettings.Source) ? packageConfig.Sources : pkgSettings.Source;
packageConfig.Version = pkgSettings.Version;
packageConfig.InstallArguments = string.IsNullOrWhiteSpace(pkgSettings.InstallArguments) ? packageConfig.InstallArguments : pkgSettings.InstallArguments;
packageConfig.PackageParameters = string.IsNullOrWhiteSpace(pkgSettings.PackageParameters) ? packageConfig.PackageParameters : pkgSettings.PackageParameters;
if (pkgSettings.ForceX86)
{
packageConfig.ForceX86 = true;
}
if (pkgSettings.AllowMultipleVersions)
{
packageConfig.AllowMultipleVersions = true;
}
if (pkgSettings.IgnoreDependencies)
{
packageConfig.IgnoreDependencies = true;
}
packageConfigs.Add(packageConfig);
}
}
return(packageConfigs);
}
public string validate_and_return_package_file(ChocolateyConfiguration config, string extension)
{
Func <IFileSystem, string> getLocalFiles = (fileSystem) =>
{
var filesFound = fileSystem.get_files(fileSystem.get_current_directory(), "*" + extension).or_empty_list_if_null();
Ensure.that(() => filesFound)
.meets((files) => files.Count() == 1,
(name, value) => { throw new FileNotFoundException("No {0} files (or more than 1) were found to build in '{1}'. Please specify the {0} file or try in a different directory.".format_with(extension, _fileSystem.get_current_directory())); });
return(filesFound.FirstOrDefault());
};
string filePath = !string.IsNullOrWhiteSpace(config.Input) ? config.Input : getLocalFiles.Invoke(_fileSystem);
Ensure.that(() => filePath).meets((file) => _fileSystem.get_file_extension(file).is_equal_to(extension) && _fileSystem.file_exists(file),
(name, value) => { throw new ArgumentException("File specified is either not found or not a {0} file. '{1}'".format_with(extension, value)); });
return(filePath);
}
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);
}
