internal static bool UnInstallZipPackage(PackageSourceListRequest request, string fastPath)
{
string sourceLocation;
string id;
string displayName;
string version;
string path;
var package = request.GetFastReferenceComplex(fastPath);
if (!request.TryParseFastPathComplex(fastPath: fastPath, regex: PackageSourceListRequest.RegexFastPathComplex, location: out sourceLocation, id: out id, displayname: out displayName, version: out version, fastpath: out path))
{
request.Error(ErrorCategory.InvalidOperation, "package", Constants.Messages.UnableToUninstallPackage);
return(false);
}
if (!string.IsNullOrWhiteSpace(path) && Directory.Exists(path))
{
path.TryHardToDelete();
request.YieldFromSwidtag(package, path);
return(true);
}
else
{
request.Error(ErrorCategory.InvalidData, "folder {0} does not exist", path);
return(false);
}
}
internal static bool UnInstallZipPackage(PackageJson package, PackageSourceListRequest request, string fastPath)
{
string sourceLocation;
string id;
string displayName;
string version;
string path;
string providerName;
if (!request.TryParseFastPathComplex(fastPath: fastPath, regex: PackageSourceListRequest.RegexFastPathComplex, location: out sourceLocation, id: out id, displayname: out displayName, version: out version, fastpath: out path, providerName: out providerName))
{
request.Error(ErrorCategory.InvalidOperation, "package", Constants.Messages.UnableToUninstallPackage);
return(false);
}
if (request.AddToPath.Value)
{
request.Warning(Resources.Messages.AddOrRemovePath, Constants.ProviderName, "AddToPath", "Install-Package");
}
if (!string.IsNullOrWhiteSpace(path) && Directory.Exists(path))
{
//Try to delete the directory to see if we can. Error out if we donot have permission
if (Directory.Exists(path))
{
try {
Directory.Delete(path, true);
}
catch (System.UnauthorizedAccessException) {
request.WriteError(ErrorCategory.InvalidOperation, package.Name, Resources.Messages.UninstallFailed, "UnInstall-Package", "UnauthorizedAccessException. The requested operation likely requires elevation, i.e., launch PowerShell as administer");
}
}
path.TryHardToDelete();
var dir = Path.Combine(package.Destination, package.Name);
// delete an empty directory
if (Directory.Exists(dir) && (!Directory.GetDirectories(dir).Any()) && !(Directory.GetFiles(dir).Any()))
{
dir.TryHardToDelete();
}
request.YieldFromSwidtag(package, path);
RemoveEnvironmentVariable(request, path, SystemEnvironmentKey);
RemoveEnvironmentVariable(request, path, UserEnvironmentKey);
return(true);
}
else
{
request.WriteError(ErrorCategory.InvalidData, path, Resources.Messages.DirectoryNotExist, Constants.ProviderName, path);
return(false);
}
}
internal static bool InstallExePackage(PackageJson package, string fastPath, PackageSourceListRequest request)
{
ProgressTracker tracker = new ProgressTracker(request.StartProgress(0, Resources.Messages.Installing));
var providerType = package.Type.ToLowerInvariant();
var exePackage = Path.ChangeExtension(Path.GetTempFileName(), providerType);
if (!string.IsNullOrWhiteSpace(package.Destination))
{
request.Verbose(Resources.Messages.DestinationNotSupported, package.Type);
}
try {
WebDownloader.DownloadFile(package.Source, exePackage, request, tracker);
if (File.Exists(exePackage))
{
request.Verbose("Package: '{0}'", exePackage);
// validate the file
if (!WebDownloader.VerifyHash(exePackage, package, request))
{
return(false);
}
if (!request.ShouldContinueWithUntrustedPackageSource(package.Name, package.Source))
{
request.Warning(Constants.Messages.UserDeclinedUntrustedPackageInstall, package.Name);
return(false);
}
// Prepare the process to run
var processArguments = string.IsNullOrWhiteSpace(package.InstallArguments)
? "/VERYSILENT /CLOSEAPPLICATIONS /NORESTART /NOCANCEL /SP /qn"
: package.InstallArguments;
var start = new ProcessStartInfo {
FileName = exePackage,
Arguments = processArguments,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
//LoadUserProfile = true,
};
double percent = tracker.StartPercent;
Timer timer = null;
object timerLock = new object();
bool cleanUp = false;
Action cleanUpAction = () => {
lock (timerLock) {
// check whether clean up is already done before or not
if (!cleanUp)
{
try {
if (timer != null)
{
// stop timer
timer.Change(Timeout.Infinite, Timeout.Infinite);
// dispose it
timer.Dispose();
}
} catch {
}
cleanUp = true;
}
}
};
// Run the external process & wait for it to finish
using (var proc = Process.Start(start)) {
var timer1 = timer;
timer = new Timer(_ => {
percent += 0.025;
// percent between startProgress and endProgress
var progressPercent = tracker.ConvertPercentToProgress(percent);
if (progressPercent < 90)
{
request.Progress(tracker.ProgressID, (int)progressPercent, Resources.Messages.InstallingPackage, package.Source);
}
if (request.IsCanceled)
{
cleanUpAction();
}
}, null, 100, 3000);
proc.WaitForExit();
// Retrieve the app's exit code
var exitCode = proc.ExitCode;
if (exitCode != 0)
{
request.WriteError(ErrorCategory.InvalidOperation, fastPath, Resources.Messages.InstallFailed, package.Name, proc.StandardError.ReadToEnd());
request.CompleteProgress(tracker.ProgressID, false);
return(false);
}
else
{
request.CompleteProgress(tracker.ProgressID, true);
request.YieldFromSwidtag(package, fastPath);
request.Verbose(Resources.Messages.SuccessfullyInstalled, package.Name);
}
cleanUpAction();
}
return(true);
}
else
{
request.WriteError(ErrorCategory.InvalidOperation, Constants.ProviderName, Resources.Messages.FailedToDownload, Constants.ProviderName, package.Source);
}
return(false);
} catch (Exception ex) {
request.Error(ErrorCategory.InvalidOperation, "install-package", ex.Message);
ex.Dump(request);
return(false);
}
finally
{
if (File.Exists(exePackage))
{
exePackage.TryHardToDelete();
}
}
}
internal static string DownloadFile(string queryUrl, string destination, PackageSourceListRequest request, ProgressTracker progressTracker)
{
try
{
request.Debug(Resources.Messages.DebugInfoCallMethod, Constants.ProviderName, string.Format(System.Globalization.CultureInfo.InvariantCulture, "DownloadFile - url='{0}', destination='{1}'", queryUrl, destination));
if (string.IsNullOrWhiteSpace(destination))
{
throw new ArgumentNullException("destination");
}
// make sure that the parent folder is created first.
var folder = Path.GetDirectoryName(destination);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (File.Exists(destination))
{
destination.TryHardToDelete();
}
if (progressTracker == null)
{
progressTracker = new ProgressTracker(request.StartProgress(0, Resources.Messages.DownloadingPackage, queryUrl));
}
Uri uri;
if (!Uri.TryCreate(queryUrl, UriKind.Absolute, out uri))
{
request.Error(Internal.ErrorCategory.InvalidOperation, Resources.Messages.UnsupportedUriFormat, Constants.ProviderName, queryUrl);
return(null);
}
if (uri.IsFile)
{
// downloading from a file share
using (var input = File.OpenRead(queryUrl))
{
using (var output = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.Read))
{
request.Progress(progressTracker.ProgressID, progressTracker.StartPercent, Resources.Messages.Downloading);
input.CopyTo(output);
}
}
request.CompleteProgress(progressTracker.ProgressID, true);
}
else
{
//Downloading from url
var result = DownloadDataToFileAsync(destination, queryUrl, request, PathUtility.GetNetworkCredential(request.CredentialUsername, request.CredentialPassword), progressTracker).Result;
}
if (File.Exists(destination))
{
request.Verbose(Resources.Messages.CompletedDownload, queryUrl);
return(destination);
}
else
{
request.Error(Internal.ErrorCategory.InvalidOperation, Resources.Messages.FailedToDownload, Constants.ProviderName, queryUrl, destination);
return(null);
}
}
catch (Exception ex)
{
ex.Dump(request);
request.Warning(ex.Message);
return(null);
}
}
internal static PackageProvider FindProvider(PackageSourceListRequest request, string providerType, IHostApi hostApi, bool logError = false)
{
string providerName = null;
switch (providerType.ToLowerInvariant())
{
case Constants.MediaType.MsiPackage:
providerName = Constants.ProviderNames.Msi;
break;
case Constants.MediaType.MsuPackage:
providerName = Constants.ProviderNames.Msu;
break;
case Constants.MediaType.AppxPackage:
//TODO for future whenever needed to support appx packages
break;
case Constants.MediaType.NuGetPackage:
providerName = Constants.ProviderNames.NuGet;
break;
case Constants.MediaType.ZipPackage:
case Constants.MediaType.ExePackage:
providerName = Constants.ProviderNames.PSL;
break;
case Constants.MediaType.PsArtifacts:
providerName = Constants.ProviderNames.PowerShellGet;
break;
default:
request.Warning(Resources.Messages.UnsupportedProviderType, Constants.ProviderName, providerType);
break;
}
if (string.IsNullOrWhiteSpace(providerName))
{
return(null);
}
PackageProvider provider;
if (_packageProviders.ContainsKey(providerName))
{
provider = _packageProviders[providerName];
}
else
{
provider = request.PackageManagementService.SelectProviders(providerName, request).FirstOrDefault();
if (provider != null)
{
_packageProviders.AddOrSet(providerName, provider);
}
}
if (provider != null)
{
return(provider);
}
request.Verbose(Resources.Messages.ProviderNotFound, providerName);
if (logError)
{
request.Error(ErrorCategory.InvalidOperation, providerName, Resources.Messages.ProviderNotFound, providerName);
}
return(null);
}
internal static string DownloadFile(string queryUrl, string destination, PackageSourceListRequest request, ProgressTracker progressTracker)
{
try
{
request.Debug(Resources.Messages.DebugInfoCallMethod, Constants.ProviderName, string.Format(System.Globalization.CultureInfo.InvariantCulture, "DownloadFile - url='{0}', destination='{1}'", queryUrl, destination));
if (string.IsNullOrWhiteSpace(destination))
{
throw new ArgumentNullException("destination");
}
// make sure that the parent folder is created first.
var folder = Path.GetDirectoryName(destination);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (File.Exists(destination))
{
destination.TryHardToDelete();
}
if (progressTracker == null)
{
progressTracker = new ProgressTracker(request.StartProgress(0, Resources.Messages.DownloadingPackage, queryUrl));
}
Uri uri;
if (!Uri.TryCreate(queryUrl, UriKind.Absolute, out uri))
{
request.Error(Internal.ErrorCategory.InvalidOperation, Resources.Messages.UnsupportedUriFormat, Constants.ProviderName, queryUrl);
return null;
}
if (uri.IsFile)
{
// downloading from a file share
using (var input = File.OpenRead(queryUrl))
{
using (var output = new FileStream(destination, FileMode.Create, FileAccess.Write, FileShare.Read))
{
request.Progress(progressTracker.ProgressID, progressTracker.StartPercent, Resources.Messages.Downloading);
input.CopyTo(output);
}
}
request.CompleteProgress(progressTracker.ProgressID, true);
}
else
{
//Downloading from url
var result = DownloadDataToFileAsync(destination, queryUrl, request, PathUtility.GetNetworkCredential(request.CredentialUsername, request.CredentialPassword), progressTracker).Result;
}
if (File.Exists(destination))
{
request.Verbose(Resources.Messages.CompletedDownload, queryUrl);
return destination;
}
else
{
request.Error(Internal.ErrorCategory.InvalidOperation, Resources.Messages.FailedToDownload, Constants.ProviderName, queryUrl, destination);
return null;
}
}
catch (Exception ex)
{
ex.Dump(request);
request.Warning(ex.Message);
return null;
}
}
internal static bool InstallZipPackage(PackageJson package, string fastPath, PackageSourceListRequest request)
{
if (request.RemoveFromPath.Value)
{
request.Warning(Resources.Messages.AddOrRemovePath, Constants.ProviderName, "RemoveFromPath", "Uninstall-Package");
}
// download the exe package
var providerType = package.Type.ToLowerInvariant();
var file = Path.ChangeExtension(Path.GetTempFileName(), providerType);
if (string.IsNullOrWhiteSpace(package.Destination))
{
request.Error(ErrorCategory.InvalidOperation, Constants.ProviderName, Resources.Messages.DestinationRequired);
return(false);
}
WebDownloader.DownloadFile(package.Source, file, request, null);
if (!File.Exists(file))
{
return(false);
}
// validate the file
if (!WebDownloader.VerifyHash(file, package, request))
{
file.TryHardToDelete();
return(false);
}
if (!request.ShouldContinueWithUntrustedPackageSource(package.Name, package.Source))
{
request.Warning(Constants.Messages.UserDeclinedUntrustedPackageInstall, package.Name);
file.TryHardToDelete();
return(false);
}
Timer timer = null;
object timerLock = new object();
bool cleanUp = false;
ProgressTracker tracker = new ProgressTracker(request.StartProgress(0, "Installing Zip Package............"));
double percent = tracker.StartPercent;
Action cleanUpAction = () => {
lock (timerLock)
{
// check whether clean up is already done before or not
if (!cleanUp)
{
try
{
if (timer != null)
{
// stop timer
timer.Change(Timeout.Infinite, Timeout.Infinite);
timer.Dispose();
timer = null;
}
}
catch
{
}
cleanUp = true;
}
}
};
// extracted folder
string extractedFolder = string.Concat(file.GenerateTemporaryFilename());
var versionFolder = "";
try
{
timer = new Timer(_ =>
{
percent += 0.025;
var progressPercent = tracker.ConvertPercentToProgress(percent);
if (progressPercent < 90)
{
request.Progress(tracker.ProgressID, (int)progressPercent, string.Format(CultureInfo.CurrentCulture, "Copying files ..."));
}
if (request.IsCanceled)
{
cleanUpAction();
}
}, null, 0, 1000);
//unzip the file
ZipFile.ExtractToDirectory(file, extractedFolder);
if (Directory.Exists(extractedFolder))
{
versionFolder = Path.Combine(package.Destination, package.Name, package.Version);
// create the directory version folder if not exist
if (!Directory.Exists(versionFolder))
{
Directory.CreateDirectory(versionFolder);
}
// The package will be installed to destination\packageName\version\
// However, a few packages have a package name as its top level folder after zip.
// So the installed folder will look like this:
// \destination\foobarPackage\1.0.1\foobarPackage
// In this case we directly copy the files to \destination\foobarPackage\1.0.1.
var extractedTopLevelFolder = Directory.EnumerateDirectories(extractedFolder, "*", SearchOption.TopDirectoryOnly);
while (!Directory.GetFiles(extractedFolder).Any() && extractedTopLevelFolder.Count() == 1)
{
extractedFolder = extractedTopLevelFolder.FirstOrDefault();
//in case the zip contains version folder
extractedTopLevelFolder = Directory.EnumerateDirectories(extractedFolder, "*", SearchOption.TopDirectoryOnly);
}
FileUtility.CopyDirectory(extractedFolder, versionFolder, true);
request.YieldFromSwidtag(package, fastPath);
request.Verbose(Resources.Messages.SuccessfullyInstalledToDestination, package.Name, package.Destination);
AddEnvironmentVariable(request, versionFolder);
return(true);
}
else
{
request.Warning("Failed to download a Zip package {0} from {1}", package.Name, package.Source);
}
}
catch (Exception e)
{
request.Debug(e.StackTrace);
if (e is System.UnauthorizedAccessException)
{
request.WriteError(ErrorCategory.InvalidOperation, package.Name, Resources.Messages.InstallFailed, package.Name, "UnauthorizedAccessException. The requested operation likely requires elevation, i.e., launch PowerShell as administer");
}
else
{
request.WriteError(ErrorCategory.InvalidOperation, package.Name, Resources.Messages.InstallFailed, package.Name, e.Message);
}
if (!(e is UnauthorizedAccessException || e is IOException))
{
// something wrong, delete the version folder
versionFolder.TryHardToDelete();
}
}
finally
{
cleanUpAction();
file.TryHardToDelete();
extractedFolder.TryHardToDelete();
request.CompleteProgress(tracker.ProgressID, true);
}
return(false);
}
internal static bool InstallExePackage(PackageJson package, string fastPath, PackageSourceListRequest request) {
ProgressTracker tracker = new ProgressTracker(request.StartProgress(0, Resources.Messages.Installing));
var exePackage = Path.ChangeExtension(Path.GetTempFileName(), "exe");
WebDownloader.DownloadFile(package.Source, exePackage, request, tracker);
if (File.Exists(exePackage)) {
request.Verbose("Package: '{0}'", exePackage);
// validate the file
if (!WebDownloader.VerifyHash(exePackage,package, request))
{
return false;
}
if (!package.IsTrustedSource)
{
if (!request.ShouldContinueWithUntrustedPackageSource(package.Name, package.Source))
{
request.Warning(Constants.Messages.UserDeclinedUntrustedPackageInstall, package.Name);
return false;
}
}
// Prepare the process to run
var processArguments = string.IsNullOrWhiteSpace(package.InstallArguments)
? "/VERYSILENT /CLOSEAPPLICATIONS /NORESTART /NOCANCEL /SP /qn"
: package.InstallArguments;
var start = new ProcessStartInfo {
FileName = exePackage,
Arguments = processArguments,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
//LoadUserProfile = true,
};
double percent = tracker.StartPercent;
Timer timer = null;
object timerLock = new object();
bool cleanUp = false;
Action cleanUpAction = () => {
lock (timerLock) {
// check whether clean up is already done before or not
if (!cleanUp) {
try {
if (timer != null) {
// stop timer
timer.Change(Timeout.Infinite, Timeout.Infinite);
// dispose it
timer.Dispose();
}
} catch {
}
cleanUp = true;
}
}
};
// Run the external process & wait for it to finish
using (var proc = Process.Start(start)) {
var timer1 = timer;
timer = new Timer(_ => {
percent += 0.025;
// percent between startProgress and endProgress
var progressPercent = tracker.ConvertPercentToProgress(percent);
if (progressPercent < 90) {
request.Progress(tracker.ProgressID, (int)progressPercent, Resources.Messages.InstallingPackage, package.Source);
}
if (request.IsCanceled) {
cleanUpAction();
}
}, null, 100, 3000);
proc.WaitForExit();
// Retrieve the app's exit code
var exitCode = proc.ExitCode;
if (exitCode != 0) {
request.WriteError(ErrorCategory.InvalidOperation, fastPath, Resources.Messages.InstallFailed, package.Name, proc.StandardError.ReadToEnd());
request.CompleteProgress(tracker.ProgressID, false);
return false;
}
else {
request.CompleteProgress(tracker.ProgressID, true);
request.YieldFromSwidtag(package, fastPath);
request.Verbose(Resources.Messages.SuccessfullyInstalled, package.Name);
}
cleanUpAction();
}
return true;
}
else
{
request.Error(ErrorCategory.InvalidOperation, Resources.Messages.FailedToDownload, Constants.ProviderName, package.Source, exePackage);
}
return false;
}
internal static PackageProvider FindProvider(PackageSourceListRequest request, string providerType, IHostApi hostApi, bool logError = false) {
string providerName = null;
switch (providerType.ToLowerInvariant()) {
case Constants.MediaType.MsiPackage:
providerName = Constants.ProviderNames.Msi;
break;
case Constants.MediaType.MsuPackage:
providerName = Constants.ProviderNames.Msu;
break;
case Constants.MediaType.AppxPackage:
//TODO for future whenever needed to support appx packages
break;
case Constants.MediaType.NuGetPackage:
providerName = Constants.ProviderNames.NuGet;
break;
case Constants.MediaType.ZipPackage:
case Constants.MediaType.ExePackage:
providerName = Constants.ProviderNames.PSL;
break;
case Constants.MediaType.PsArtifacts:
providerName = Constants.ProviderNames.PowerShellGet;
break;
default:
request.Warning(Resources.Messages.UnsupportedProviderType, providerType);
break;
}
if (string.IsNullOrWhiteSpace(providerName)) {
return null;
}
PackageProvider provider;
if (_packageProviders.ContainsKey(providerName)) {
provider = _packageProviders[providerName];
} else {
provider = request.PackageManagementService.SelectProviders(providerName, request).FirstOrDefault();
if (provider != null) {
_packageProviders.AddOrSet(providerName, provider);
}
}
if (provider != null) {
return provider;
}
request.Verbose(Resources.Messages.ProviderNotFound, providerName);
if (logError) {
request.Error(ErrorCategory.InvalidOperation, providerName, Resources.Messages.ProviderNotFound, providerName);
}
return null;
}
internal static bool UnInstallZipPackage(PackageSourceListRequest request, string fastPath)
{
string sourceLocation;
string id;
string displayName;
string version;
string path;
var package = request.GetFastReferenceComplex(fastPath);
if (!request.TryParseFastPathComplex(fastPath: fastPath, regex: PackageSourceListRequest.RegexFastPathComplex, location: out sourceLocation, id: out id, displayname: out displayName, version: out version, fastpath: out path))
{
request.Error(ErrorCategory.InvalidOperation, "package", Constants.Messages.UnableToUninstallPackage);
return false;
}
if (!string.IsNullOrWhiteSpace(path) && Directory.Exists(path))
{
path.TryHardToDelete();
request.YieldFromSwidtag(package, path);
return true;
}
else
{
request.Error(ErrorCategory.InvalidData, "folder {0} does not exist", path);
return false;
}
}
