public void InstallPackage_extract_package_success()
{
//given
var version10 = new Version(1, 0);
var packageDetails = new PackageDetails("TestNugetPackage", _nugetFeedFolder, version10);
var op = new InstallPackage();
var context = new DeploymentTaskContext
{
Folders = new ServiceFolders
{
DeployFolder = (FullPath)_targetPath
},
PackageDetails = packageDetails,
KeepOnUpdate = FileList.Empty
};
context.Parameters.Version = version10.ToString();
//when
op.Execute(context);
//then
string[] sampleFiles =
{
"TestNugetPackLib.dll",
};
var files = Directory
.GetFiles(_targetPath)
.Select(Path.GetFileName);
Assert.That(sampleFiles, Is.SubsetOf(files));
}
/// <summary>
/// Analyzes the transforms included in the patch package to find the ones that
/// are applicable to an install package.
/// </summary>
/// <param name="installPackage">The install package to validate the transforms against</param>
/// <returns>Array of valid transform names</returns>
/// <remarks>
/// The returned list does not include the "patch special transforms" that
/// are prefixed with "#" If a transform is valid, then its corresponding
/// special transform is assumed to be valid as well.
/// </remarks>
public string[] GetValidTransforms(InstallPackage installPackage)
{
ArrayList transformArray = new ArrayList();
string transformList = this.SummaryInfo.LastSavedBy;
foreach (string transform in transformList.Split(';', ':'))
{
if (transform.Length != 0 && !transform.StartsWith("#", StringComparison.Ordinal))
{
this.LogMessage("Checking validity of transform {0}", transform);
string tempTransformFile = null;
try
{
tempTransformFile = Path.GetTempFileName();
this.ExtractTransform(transform, tempTransformFile);
if (installPackage.IsTransformValid(tempTransformFile))
{
this.LogMessage("Found valid transform: {0}", transform);
transformArray.Add(transform);
}
}
finally
{
if (tempTransformFile != null && File.Exists(tempTransformFile))
{
try { File.Delete(tempTransformFile); }
catch (IOException) { }
}
}
}
}
return((string[])transformArray.ToArray(typeof(string)));
}
public void InstallPackage_extract_package_success()
{
//given
var version10 = new Version(1, 0);
var packageDetails = new PackageDetails("TestNugetPackage", _nugetFeedFolder, version10);
var op = new InstallPackage(_targetPath, packageDetails);
var stringWriter = new StringWriter();
var buildLog = new DeploymentTaskContext(stringWriter);
//when
op.Execute(buildLog);
//then
string[] sampleFiles =
{
"TestNugetPackLib.dll",
};
var files = Directory
.GetFiles(_targetPath)
.Select(Path.GetFileName);
Assert.That(sampleFiles, Is.SubsetOf(files));
}
private bool YieldPackage(InstallPackage package, string filename, Request request) {
/*
var properties = package.ExecuteStringQuery("SELECT `Property` FROM `Property` ");
foreach (var i in properties) {
Debug.WriteLine("Property {0} = {1}", i, package.Property[i]);
}
*/
if (request.YieldSoftwareIdentity(filename, package.Property["ProductName"], package.Property["ProductVersion"], "multipartnumeric", package.Property["Summary"], filename, filename, filename, Path.GetFileName(filename)) != null) {
var trusted = request.ProviderServices.IsSignedAndTrusted(filename, request);
if (request.AddMetadata(filename, "FromTrustedSource", trusted.ToString()) == null ) {
return false;
}
if (request.AddMetadata(filename, "ProductCode", package.Property["ProductCode"]) == null) {
return false;
}
if (request.AddTagId(package.Property["ProductCode"].Trim(new char[] { '{', '}' })) == null)
{
return false;
}
if (request.AddMetadata(filename, "UpgradeCode", package.Property["UpgradeCode"]) == null) {
return false;
}
return true;
}
return false;
}
/// <summary>
/// Finds packages given a locally-accessible filename
/// Package information must be returned using <c>request.YieldPackage(...)</c> function.
/// </summary>
/// <param name="file">the full path to the file to determine if it is a package</param>
/// <param name="id">
/// if this is greater than zero (and the number should have been generated using <c>StartFind(...)</c>,
/// the core is calling this multiple times to do a batch search request. The operation can be delayed until
/// <c>CompleteFind(...)</c> is called
/// </param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void FindPackageByFile(string file, int id, Request request)
{
if( request == null ) {
throw new ArgumentNullException("request");
}
if( string.IsNullOrWhiteSpace(file) ) {
throw new ArgumentNullException("file");
}
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::FindPackageByFile' '{1}','{2}'", ProviderName, file, id);
if (!file.FileExists()) {
request.Error(ErrorCategory.ObjectNotFound, file, Constants.Messages.UnableToResolvePackage, file);
return;
}
try {
var package = new InstallPackage(file, DatabaseOpenMode.ReadOnly);
YieldPackage(package, file, request);
package.Close();
} catch (Exception e) {
e.Dump();
// any exception at this point really just means that
request.Error(ErrorCategory.OpenError, file, Constants.Messages.UnableToResolvePackage, file);
}
}
private static string GetPreviousVersionInstallPath()
{
var retVal = String.Empty;
var products = ProductInstallation.GetProducts("{944871E7-9F8D-47B7-BE04-103E4C8F2254}", null, UserContexts.All);
var product = products?.FirstOrDefault();
var location = product?.LocalPackage;
if (location != null)
{
var package = new InstallPackage(location, DatabaseOpenMode.ReadOnly);
var componentId = package.Files.FirstOrDefault(kvp => kvp.Value.SourceName == "UO Bulk Order Deeds.exe").Key;
if (componentId != null)
{
var results = package.ExecuteQuery($"SELECT `ComponentId` FROM `Component` WHERE `Component` = 'C_{componentId}'");
var result = results?.Count > 0 ? results[0].ToString() : null;
if (result != null)
{
var componentInstallation = new ComponentInstallation(result);
var componentPath = componentInstallation.Path;
retVal = Path.GetDirectoryName(componentPath);
}
}
}
return(retVal);
}
private bool YieldPackage(InstallPackage package, string filename, Request request)
{
/*
* var properties = package.ExecuteStringQuery("SELECT `Property` FROM `Property` ");
* foreach (var i in properties) {
* Debug.WriteLine("Property {0} = {1}", i, package.Property[i]);
* }
*/
if (request.YieldSoftwareIdentity(filename, package.Property["ProductName"], package.Property["ProductVersion"], "multipartnumeric", package.Property["Summary"], filename, filename, filename, Path.GetFileName(filename)))
{
var trusted = request.GetPackageManagementService().As <IPackageManagementService>().ProviderServices.IsSignedAndTrusted(filename, "");
if (!request.YieldSoftwareMetadata(filename, "FromTrustedSource", trusted.ToString()))
{
return(false);
}
if (!request.YieldSoftwareMetadata(filename, "ProductCode", package.Property["ProductCode"]))
{
return(false);
}
if (!request.YieldSoftwareMetadata(filename, "UpgradeCode", package.Property["UpgradeCode"]))
{
return(false);
}
return(true);
}
return(false);
}
/// <summary>
/// Finds packages given a locally-accessible filename
/// Package information must be returned using <c>request.YieldPackage(...)</c> function.
/// </summary>
/// <param name="file">the full path to the file to determine if it is a package</param>
/// <param name="id">
/// if this is greater than zero (and the number should have been generated using <c>StartFind(...)</c>,
/// the core is calling this multiple times to do a batch search request. The operation can be delayed until
/// <c>CompleteFind(...)</c> is called
/// </param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void FindPackageByFile(string file, int id, Request request) {
if( request == null ) {
throw new ArgumentNullException("request");
}
if( string.IsNullOrWhiteSpace(file) ) {
throw new ArgumentNullException("file");
}
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::FindPackageByFile' '{1}','{2}'", ProviderName, file, id);
if (!file.FileExists()) {
request.Error(ErrorCategory.ObjectNotFound, file, Constants.Messages.UnableToResolvePackage, file);
return;
}
try {
var package = new InstallPackage(file, DatabaseOpenMode.ReadOnly);
YieldPackage(package, file, request);
package.Close();
} catch (Exception e) {
e.Dump();
// any exception at this point really just means that
request.Error(ErrorCategory.OpenError, file, Constants.Messages.UnableToResolvePackage, file);
}
}
private void MergeCubes(InstallPackage db)
{
if (!this.NoDefault)
{
string darice = ComponentSearcher.Find(ComponentSearcher.KnownComponent.Darice);
if (!string.IsNullOrEmpty(darice))
{
this.MergeCube(db, darice);
}
else
{
this.WriteWarning(Resources.Error_DefaultCubNotFound);
}
}
if (null != this.AdditionalCube)
{
foreach (string cube in this.ResolveFiles(this.AdditionalCube))
{
this.MergeCube(db, cube);
}
db.Commit();
}
}
/// <summary>
/// Finds packages given a locally-accessible filename
/// Package information must be returned using <c>request.YieldPackage(...)</c> function.
/// </summary>
/// <param name="file">the full path to the file to determine if it is a package</param>
/// <param name="id">
/// if this is greater than zero (and the number should have been generated using <c>StartFind(...)</c>,
/// the core is calling this multiple times to do a batch search request. The operation can be delayed until
/// <c>CompleteFind(...)</c> is called
/// </param>
/// <param name="requestImpl">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void FindPackageByFile(string file, int id, RequestImpl requestImpl)
{
try {
// create a strongly-typed request object.
using (var request = requestImpl.As <Request>()) {
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::FindPackageByFile' '{1}','{2}'", ProviderName, file, id);
if (!file.FileExists())
{
request.Error(ErrorCategory.ObjectNotFound, file, Constants.Messages.UnableToResolvePackage, file);
return;
}
try {
var package = new InstallPackage(file, DatabaseOpenMode.ReadOnly);
YieldPackage(package, file, request);
package.Close();
} catch (Exception e) {
e.Dump();
// any exception at this point really just means that
request.Error(ErrorCategory.OpenError, file, Constants.Messages.UnableToResolvePackage, file);
}
}
} catch (Exception e) {
// We shoudn't throw exceptions from here, it's not-optimal. And if the exception class wasn't properly Serializable, it'd cause other issues.
// Really this is just here as a precautionary to behave correctly.
// At the very least, we'll write it to the system debug channel, so a developer can find it if they are looking for it.
Debug.WriteLine("Unexpected Exception thrown in '{0}::FindPackageByFile' -- {1}\\{2}\r\n{3}", ProviderName, e.GetType().Name, e.Message, e.StackTrace);
}
}
static ICollection <string> FindFileKeys(InstallPackage pkg, ICollection <string> fileNames)
{
List <string> fileKeys = null;
if (fileNames != null)
{
fileKeys = new List <string>();
foreach (string fileName in fileNames)
{
string[] foundFileKeys = null;
if (fileName.IndexOfAny(new char[] { '*', '?' }) >= 0)
{
foundFileKeys = pkg.FindFiles(FilePatternToRegex(fileName));
}
else
{
foundFileKeys = pkg.FindFiles(fileName);
}
fileKeys.AddRange(foundFileKeys);
}
if (fileKeys.Count == 0)
{
throw new FileNotFoundException("Files not found in package.");
}
}
return(fileKeys);
}
private static bool DownloadAndInstallPackage(string packageName, string packageUrl, string downloadPath)
{
bool ok = true;
InstallPackage installPackage = new InstallPackage();
ok = DownloadFile(packageName, packageUrl, downloadPath);
if (ok)
{
try
{
installPackage = installPackage.LoadFromXML(Path.Combine(downloadPath, packageName));
}
catch
{
ok = false;
}
if (ok)
{
var downloadElements = installPackage.DownloadElementToArray();
foreach (var element in downloadElements)
{
ok = DownloadFile(element.FileName, Path.Combine(element.Url, element.Subdir), Path.Combine(downloadPath, element.Subdir));
if (!ok)
{
break;
}
}
}
}
return(ok);
}
protected Database OpenDatabase(string path)
{
var type = FileInfo.GetFileTypeInternal(path);
if (FileType.Package == type)
{
var db = new InstallPackage(path, DatabaseOpenMode.ReadOnly);
this.ApplyTransforms(db);
return(db);
}
else if (FileType.Patch == type)
{
return(new PatchPackage(path));
}
else
{
var message = string.Format(Resources.Error_InvalidStorage, path);
var ex = new PSNotSupportedException(message);
if (null != ex.ErrorRecord)
{
base.WriteError(ex.ErrorRecord);
}
return(null);
}
}
static void Main(string[] args)
{
using (var package = new InstallPackage(@"C:\test.msi", DatabaseOpenMode.ReadOnly))
{
package.ExtractFiles();
}
}
/// <summary>
/// Extracts files from an MSI database and rewrites the paths embedded in the source .wixpdb to the output .wixpdb.
/// </summary>
private void MeltProduct()
{
// print friendly message saying what file is being decompiled
Console.WriteLine("{0} / {1}", Path.GetFileName(this.inputFile), Path.GetFileName(this.inputPdbFile));
// extract files from the .msi (unless suppressed) and get the path map of File ids to target paths
string outputDirectory = this.exportBasePath ?? Environment.GetEnvironmentVariable("WIX_TEMP");
IDictionary <string, string> paths = null;
using (InstallPackage package = new InstallPackage(this.inputFile, DatabaseOpenMode.ReadOnly, null, outputDirectory))
{
if (!this.suppressExtraction)
{
package.ExtractFiles();
}
paths = package.Files.SourcePaths;
}
Pdb inputPdb = Pdb.Load(this.inputPdbFile, true, true);
Table wixFileTable = inputPdb.Output.Tables["WixFile"];
if (null != wixFileTable)
{
foreach (Row row in wixFileTable.Rows)
{
WixFileRow fileRow = row as WixFileRow;
if (null != fileRow)
{
string newPath;
if (paths.TryGetValue(fileRow.File, out newPath))
{
fileRow.Source = Path.Combine(outputDirectory, newPath);
}
}
}
}
string tempPath = Path.Combine(Environment.GetEnvironmentVariable("WIX_TEMP") ?? Path.GetTempPath(), Path.GetRandomFileName());
try
{
inputPdb.Save(this.outputFile, null, null, tempPath);
}
finally
{
if (this.tidy)
{
if (!AppCommon.DeleteDirectory(tempPath, this.messageHandler))
{
Console.WriteLine(MeltStrings.WAR_FailedToDeleteTempDir, tempPath);
}
}
else
{
Console.WriteLine(MeltStrings.INF_TempDirLocatedAt, tempPath);
}
}
}
private void InstallAdditionalPackages()
{
ThreadPool.QueueUserWorkItem((ctx) =>
{
InstallPackage installer = new InstallPackage();
installer.Run();
});
}
/// <summary>
/// Initializes a new instance of the <see cref="PatchApplicator"/> class.
/// </summary>
/// <param name="db">The <see cref="InstallPackage"/> to transform.</param>
internal PatchApplicator(InstallPackage db)
{
if (null == db)
{
throw new ArgumentNullException("db");
}
this.db = db;
this.sequencer = new PatchSequencer();
}
public void NoTransformViewChanges()
{
var package = Path.Combine(base.TestContext.DeploymentDirectory, "Example.msi");
using (var db = new InstallPackage(package, DatabaseOpenMode.ReadOnly))
{
var view = new TransformView(db);
Assert.AreEqual <int>(0, view.Tables.Count);
}
}
public static Response AsNewPackage(this IResponseFormatter formatter, InstallPackage package, PackageManifest manifest)
{
string fileName = Path.GetFileName(package.Path);
string url = string.Format("{0}/{1}", formatter.Context.Request.Url, fileName);
return(new Response
{
StatusCode = HttpStatusCode.Created
}
.WithHeader("Location", url));
}
public static void Main(string[] args)
{
currentDir = Directory.GetCurrentDirectory();
DirSearch(currentDir);
InstallPackage installSettings = new InstallPackage();
foreach (var element in downloadList)
{
installSettings.AddDownloadElement(element);
}
installSettings.SaveToXML(Path.Combine(currentDir, installFileName));
}
static void Main(string[] args)
{
string path = @"... myfile.msi";
using (InstallPackage package = new InstallPackage(path, DatabaseOpenMode.ReadOnly))
{
foreach (var kvp in package.Files.Where(f => Path.GetExtension(f.Value.TargetName) == ".dll"))
{
Console.WriteLine(kvp.Value.TargetName);
}
}
}
static void Main(string[] args)
{
using (var package = new InstallPackage("foo.msi", DatabaseOpenMode.ReadOnly))
{
foreach (var filePath in package.Files)
{
Console.WriteLine(filePath.Value);
}
Console.WriteLine("Finished");
Console.Read();
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Request.QueryString["force"] == "1")
{
InstallPackage.ResetInstallState();
}
ThreadPool.QueueUserWorkItem((ctx) =>
{
InstallPackage installer = new InstallPackage();
installer.Run();
});
}
/// <summary>
/// Extracts the files contained in the msi.
/// </summary>
/// <param name="msiFile">The msi file to extract.</param>
/// <param name="path">The path to extract the files to.</param>
/// <returns>List of files in MSI.</returns>
public string[] ExtractFilesInMsi(string msiFile, string path)
{
_ = msiFile ?? throw new ArgumentNullException(nameof(msiFile));
_ = path ?? throw new ArgumentNullException(nameof(path));
using (var package = new InstallPackage(msiFile, DatabaseOpenMode.ReadOnly, null, path))
{
package.ExtractFiles();
}
var msiFiles = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories);
return msiFiles;
}
private static InstallPackage Copy(InstallPackage db)
{
var temp = Path.ChangeExtension(Path.GetTempFileName(), ".msi");
File.Copy(db.FilePath, temp, true);
// Open a copy and schedule delete it when closed.
var copy = new InstallPackage(temp, DatabaseOpenMode.ReadOnly);
copy.DeleteOnClose(temp);
return(copy);
}
/// <summary>
/// Opens the package read-only and sets the <see cref="InstallCommandActionData.ProductCode"/> property.
/// </summary>
public void SetProductCode()
{
using (var db = new InstallPackage(this.Path, DatabaseOpenMode.ReadOnly))
{
if (db.Tables.Contains("Property"))
{
this.ProductCode = db.Property["ProductCode"];
}
else
{
this.ProductCode = null;
}
}
}
/// <summary>
/// Applies any applicable transforms from <see cref="Patch"/> and <see cref="Transform"/> to the given package.
/// </summary>
/// <param name="db">The <see cref="InstallPackage"/> database to which applicable transforms are applied.</param>
protected void ApplyTransforms(InstallPackage db)
{
// Apply transforms first since they likely apply to the unpatched product.
if (0 < this.Transform.Count())
{
this.Transform = this.ResolveFiles(this.Transform).ToArray();
foreach (string path in this.Transform)
{
try
{
db.ApplyTransform(path, PatchApplicator.IgnoreErrors);
db.ApplyTransform(path, PatchApplicator.IgnoreErrors | TransformErrors.ViewTransform);
}
catch (InstallerException ex)
{
using (var pse = new PSInstallerException(ex))
{
if (null != pse.ErrorRecord)
{
base.WriteError(pse.ErrorRecord);
}
}
}
}
db.Commit();
}
// Apply applicable patch transforms.
if (0 < this.Patch.Count())
{
this.Patch = this.ResolveFiles(this.Patch).ToArray();
var applicator = new PatchApplicator(db);
foreach (string path in this.Patch)
{
applicator.Add(path);
}
applicator.InapplicablePatch += (source, args) =>
{
var message = string.Format(CultureInfo.CurrentCulture, Resources.Error_InapplicablePatch, args.Patch, args.Product);
base.WriteVerbose(message);
};
// The applicator will commit the changes.
applicator.Apply();
}
}
public MsiManager(string msiFile)
{
_msiFile = msiFile;
var ispackage = Installer.VerifyPackage(msiFile);
if (!ispackage)
{
throw new ArgumentException("Not a valid MSI file", msiFile);
}
_installPackage = new InstallPackage(msiFile, DatabaseOpenMode.ReadOnly);
_productCode = _installPackage.Property["ProductCode"];
}
private dynamic InstallUploadPackage(dynamic o)
{
try
{
var file = Request.Files.FirstOrDefault();
var uploadPackage = this.Bind <InstallUploadPackage>();
if (file == null)
{
return(new Response {
StatusCode = HttpStatusCode.BadRequest
});
}
PackageManifest manifest;
try
{
var package = new InstallPackage
{
Path = _tempPackager.GetPackageToInstall(file.Value),
DisableIndexing = uploadPackage.DisableIndexing,
EnableSecurityInstall = uploadPackage.EnableSecurityInstall
};
manifest = _repository.AddPackage(package);
_installationRecorder.RecordInstall(uploadPackage.PackageId, uploadPackage.Description, DateTime.Now);
}
finally
{
_tempPackager.Dispose();
}
if (uploadPackage.DisableManifest)
{
// Skip manifest reporting. Nancy will return an empty message body.
manifest = null;
}
return(Response
.AsJson(manifest, HttpStatusCode.Created)
.WithHeader("Location", ShipServiceUrl.PackageLatestVersion));
}
catch (NotFoundException)
{
return(new Response
{
StatusCode = HttpStatusCode.NotFound
});
}
}
public static List <InstallPackage> GetInstallPackages()
{
var detectedPackages = new List <InstallPackage>();
var contentPath = Path.Combine(Origin.DataPath, "LocalContent");
if (Directory.Exists(contentPath))
{
var packages = Directory.GetFiles(contentPath, "*.mfst", SearchOption.AllDirectories);
foreach (var package in packages)
{
try
{
var installPackage = new InstallPackage();
var gameId = Path.GetFileNameWithoutExtension(package);
installPackage.OriginalId = gameId;
installPackage.ConvertedId = gameId;
if (!gameId.StartsWith("Origin"))
{
// Get game id by fixing file via adding : before integer part of the name
// for example OFB-EAST52017 converts to OFB-EAST:52017
var match = Regex.Match(gameId, @"^(.*?)(\d+)$");
if (!match.Success)
{
logger.Warn("Failed to get game id from file " + package);
continue;
}
gameId = match.Groups[1].Value + ":" + match.Groups[2].Value;
}
var subTypeIndex = gameId.IndexOf('@');
if (subTypeIndex >= 0)
{
installPackage.Source = gameId.Substring(subTypeIndex);
gameId = gameId.Substring(0, subTypeIndex);
}
installPackage.ConvertedId = gameId;
detectedPackages.Add(installPackage);
}
catch (Exception e) when(!Environment.IsDebugBuild)
{
logger.Error(e, $"Failed to parse Origin install pacakge {package}.");
}
}
}
return(detectedPackages);
}
public override bool Execute()
{
try
{
using (var package = new InstallPackage(InstallPackage, 0))
{
Value = package.Property[Property];
}
}
catch (Exception exception)
{
Log.LogErrorFromException(exception);
}
return(!Log.HasLoggedErrors);
}
/// <summary>
/// Installs a given package.
/// </summary>
/// <param name="fastPackageReference">A provider supplied identifier that specifies an exact package</param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void InstallPackage(string fastPackageReference, Request request) {
if( request == null ) {
throw new ArgumentNullException("request");
}
if( string.IsNullOrWhiteSpace(fastPackageReference) ) {
throw new ArgumentNullException("fastPackageReference");
}
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::InstallPackage' '{1}'", ProviderName, fastPackageReference);
var file = fastPackageReference.CanonicalizePath(false);
if (!file.FileExists()) {
request.Error(Microsoft.PackageManagement.Internal.ErrorCategory.OpenError, fastPackageReference, Constants.Messages.UnableToResolvePackage, fastPackageReference);
return;
}
string errorLogFolder = Path.GetTempPath() + Guid.NewGuid();
DirectoryInfo errorDir = Directory.CreateDirectory(errorLogFolder);
string errorLogPath = errorLogFolder + "\\msi.log";
try {
var package = new InstallPackage(file, DatabaseOpenMode.ReadOnly);
Installer.SetInternalUI(InstallUIOptions.UacOnly | InstallUIOptions.Silent);
// todo 1501: support additional parameters!
if (request.Sources != null && request.Sources.Any()) {
// The 'file' can be from a temp location downloaded by a chained provider. In that case, we can show
// the orignal package source specified in the request.Sources.
_progressId = request.StartProgress(0, Resources.Messages.InstallingMSIPackage, request.Sources.FirstOrDefault());
} else {
_progressId = request.StartProgress(0, Resources.Messages.InstallingMSIPackage, file);
}
var handler = CreateProgressHandler(request, Resources.Messages.Installing);
Installer.SetExternalUI(handler, InstallLogModes.Progress | InstallLogModes.Info);
Installer.EnableLog(InstallLogModes.Error, errorLogPath);
Installer.InstallProduct(file, "REBOOT=REALLYSUPPRESS");
Installer.SetInternalUI(InstallUIOptions.Default);
Installer.SetExternalUI(handler, InstallLogModes.None);
if (request.Sources != null && request.Sources.Any()) {
// The 'file' can be from a temp location downloaded by a chained provider. In that case, we can show
// the orignal package source specified in the request.Sources.
YieldPackage(package, request.Sources.FirstOrDefault(), request);
} else {
YieldPackage(package, file, request);
}
package.Close();
if (Installer.RebootRequired) {
request.Warning(Resources.Messages.InstallRequireReboot);
}
if (errorDir.Exists)
errorDir.Delete(true);
} catch (Exception e) {
e.Dump();
request.Error(Microsoft.PackageManagement.Internal.ErrorCategory.InvalidOperation, file, Constants.Messages.PackageFailedInstallErrorLog, file, errorLogPath);
}
request.CompleteProgress(_progressId, true);
}
private bool YieldPackage(InstallPackage package, string filename, Request request) {
/*
var properties = package.ExecuteStringQuery("SELECT `Property` FROM `Property` ");
foreach (var i in properties) {
Debug.WriteLine("Property {0} = {1}", i, package.Property[i]);
}
*/
if (request.YieldSoftwareIdentity(filename, package.Property["ProductName"], package.Property["ProductVersion"], "multipartnumeric", package.Property["Summary"], filename, filename, filename, Path.GetFileName(filename)) != null) {
var trusted = request.ProviderServices.IsSignedAndTrusted(filename, request);
if (request.AddMetadata(filename, "FromTrustedSource", trusted.ToString()) == null ) {
return false;
}
if (request.AddMetadata(filename, "ProductCode", package.Property["ProductCode"]) == null) {
return false;
}
if (request.AddMetadata(filename, "UpgradeCode", package.Property["UpgradeCode"]) == null) {
return false;
}
return true;
}
return false;
}
/// <summary>
/// Installs a given package.
/// </summary>
/// <param name="fastPackageReference">A provider supplied identifier that specifies an exact package</param>
/// <param name="request">
/// An object passed in from the CORE that contains functions that can be used to interact with
/// the CORE and HOST
/// </param>
public void InstallPackage(string fastPackageReference, Request request) {
if( request == null ) {
throw new ArgumentNullException("request");
}
if( string.IsNullOrWhiteSpace(fastPackageReference) ) {
throw new ArgumentNullException("fastPackageReference");
}
// Nice-to-have put a debug message in that tells what's going on.
request.Debug("Calling '{0}::InstallPackage' '{1}'", ProviderName, fastPackageReference);
var file = fastPackageReference.CanonicalizePath(false);
if (!file.FileExists()) {
request.Error(ErrorCategory.OpenError, fastPackageReference, Constants.Messages.UnableToResolvePackage, fastPackageReference);
return;
}
try {
var package = new InstallPackage(file, DatabaseOpenMode.ReadOnly);
Installer.SetInternalUI(InstallUIOptions.UacOnly | InstallUIOptions.Silent);
// todo 1501: support additional parameters!
var handler = CreateProgressHandler(request);
_progressId = request.StartProgress(0, "Installing MSI '{0}'", file);
Installer.SetExternalUI(handler, InstallLogModes.Progress | InstallLogModes.Info);
Installer.InstallProduct(file, "REBOOT=REALLYSUPPRESS");
Installer.SetInternalUI(InstallUIOptions.Default);
Installer.SetExternalUI(handler, InstallLogModes.None);
YieldPackage(package, file, request);
package.Close();
if (Installer.RebootRequired) {
request.Warning("Reboot is required to complete Installation.");
}
} catch (Exception e) {
e.Dump();
request.Error(ErrorCategory.InvalidOperation, file, Constants.Messages.UnableToResolvePackage, file);
}
request.CompleteProgress(_progressId, true);
}