public Task RemoveFeed(string location, bool? session, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("remove-feed");
return;
}
// Note: This may need better lookup/matching for the location
// as location can be a fuzzy match.
if (session ?? false) {
// session feed specfied
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EditSessionFeeds)) {
PackageManagerMessages.Invoke.PermissionRequired("EditSessionFeeds");
return;
}
RemoveSessionFeed(location);
PackageManagerMessages.Invoke.FeedRemoved(location);
}
else {
// system feed specified
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EditSystemFeeds)) {
PackageManagerMessages.Invoke.PermissionRequired("EditSystemFeeds");
return;
}
RemoveSystemFeed(location);
PackageManagerMessages.Invoke.FeedRemoved(location);
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task ListFeeds(int? index, int? maxResults, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("list-feeds");
return;
}
var canFilterSession = PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EditSessionFeeds);
var canFilterSystem = PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EditSystemFeeds);
var activeSessionFeeds = SessionCache<PackageFeed>.Value.SessionValues;
var activeSystemFeeds = Cache<PackageFeed>.Value.Values;
var x = from feedLocation in SystemFeedLocations
let theFeed = activeSystemFeeds.Where(each => each.IsLocationMatch(feedLocation)).FirstOrDefault()
let validated = theFeed != null
select new {
feed = feedLocation,
LastScanned = validated ? theFeed.LastScanned : DateTime.FromFileTime(0),
session = false,
suppressed = canFilterSystem && BlockedScanLocations.Contains(feedLocation),
validated,
};
var y = from feedLocation in SessionFeedLocations
let theFeed = activeSessionFeeds.Where(each => each.IsLocationMatch(feedLocation)).FirstOrDefault()
let validated = theFeed != null
select new {
feed = feedLocation,
LastScanned = validated ? theFeed.LastScanned : DateTime.FromFileTime(0),
session = true,
suppressed = canFilterSession && BlockedScanLocations.Contains(feedLocation),
validated,
};
var results = x.Union(y);
// paginate the results
if (index.HasValue) {
results = results.Skip(index.Value);
}
if (maxResults.HasValue) {
results = results.Take(maxResults.Value);
}
if (results.Any()) {
foreach (var f in results) {
PackageManagerMessages.Invoke.FeedDetails(f.feed, f.LastScanned, f.session, f.suppressed, f.validated);
}
}
else {
PackageManagerMessages.Invoke.NoFeedsFound();
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task RecognizeFile(string canonicalName, string localLocation, string remoteLocation, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (string.IsNullOrEmpty(localLocation)) {
PackageManagerMessages.Invoke.Error("recognize-file", "local-location", "parameter 'local-location' is required to recognize a file");
return;
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("recognize-file");
return;
}
var location = PackageManagerSession.Invoke.GetCanonicalizedPath(localLocation);
if (location.StartsWith(@"\\")) {
// a local unc path was passed. This isn't allowed--we need a file on a local volume that
// the user has access to.
PackageManagerMessages.Invoke.Error("recognize-file", "local-location",
"local-location '{0}' appears to be a file on a remote server('{1}') . Recognized files must be local".format(localLocation, location));
return;
}
if (!File.Exists(location)) {
PackageManagerMessages.Invoke.FileNotFound(location);
return;
}
// if there is a continuation task for the canonical name that goes along with this,
// we should continue with that task, and get the heck out of here.
//
if (!canonicalName.IsNullOrEmpty()) {
var continuationTask = SessionCache<Task<Recognizer.RecognitionInfo>>.Value[canonicalName];
SessionCache<Task<Recognizer.RecognitionInfo>>.Value.Clear(canonicalName);
if (continuationTask != null) {
var state = continuationTask.AsyncState as RequestRemoteFileState;
if (state != null) {
state.LocalLocation = localLocation;
}
continuationTask.Start();
return;
}
}
// otherwise, we'll call the recognizer
Recognizer.Recognize(location).ContinueWith(antecedent => {
if (antecedent.IsFaulted) {
PackageManagerMessages.Invoke.FileNotRecognized(location, "Unexpected error recognizing file.");
return;
}
if (antecedent.Result.IsPackageFile) {
var package = Package.GetPackageFromFilename(location);
// mark it download 100%
package.PackageSessionData.DownloadProgress = 100;
SessionPackageFeed.Instance.Add(package);
PackageManagerMessages.Invoke.PackageInformation(package, Enumerable.Empty<Package>());
PackageManagerMessages.Invoke.Recognized(localLocation);
return;
}
if (antecedent.Result.IsPackageFeed) {
PackageManagerMessages.Invoke.FeedAdded(location);
PackageManagerMessages.Invoke.Recognized(location);
}
// if this isn't a package file, then there is something odd going on here.
// we don't accept non-package files willy-nilly.
PackageManagerMessages.Invoke.FileNotRecognized(location, "File isn't a package, and doesn't appear to have been requested. ");
return;
}, TaskContinuationOptions.AttachedToParent);
}, TaskCreationOptions.AttachedToParent);
return t;
}
/// <summary>
/// Main install process
/// </summary>
internal void StartInstall()
{
_messages = new PackageManagerMessages {
UnexpectedFailure = UnexpectedFailure,
NoPackagesFound = NoPackagesFound,
PermissionRequired = OperationRequiresPermission,
Error = MessageArgumentError,
RequireRemoteFile =
(canonicalName, remoteLocations, localFolder, force) =>
Downloader.GetRemoteFile(
canonicalName, remoteLocations, localFolder, force, new RemoteFileMessages {
Progress = (itemUri, percent) => {
"Downloading {0}".format(itemUri.AbsoluteUri).PrintProgressBar(percent);
},
}, _messages),
OperationCancelled = CancellationRequested,
PackageSatisfiedBy = (original, satisfiedBy) => {
original.SatisfiedBy = satisfiedBy;
},
PackageBlocked = BlockedPackage,
UnknownPackage = UnknownPackage,
};
LoadPackageDetails();
}
public Task InstallPackage(string canonicalName, bool? autoUpgrade, bool? force, bool? download, bool? pretend, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
var overallProgress = 0.0;
var eachTaskIsWorth = 0.0;
var numberOfPackagesToInstall = 0;
var numberOfPackagesToDownload = 0;
using (var manualResetEvent = new ManualResetEvent(true)) {
try {
lock (manualResetEvents) {
manualResetEvents.Add(manualResetEvent);
}
var packagesTriedToDownloadThisTask = new List<Package>();
var package = GetSinglePackage(canonicalName, "install-package");
if (package == null) {
PackageManagerMessages.Invoke.UnknownPackage(canonicalName);
return;
}
// is the user authorized to install this?
var highestInstalledPackage =
SearchForInstalledPackages(package.Name, null, package.Architecture, package.PublicKeyToken).HighestPackages();
if (highestInstalledPackage.Any() && highestInstalledPackage.FirstOrDefault().Version < package.Version) {
if (package.IsBlocked) {
PackageManagerMessages.Invoke.PackageBlocked(canonicalName);
return;
}
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.UpdatePackage)) {
PackageManagerMessages.Invoke.PermissionRequired("UpdatePackage");
return;
}
}
else {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.InstallPackage)) {
PackageManagerMessages.Invoke.PermissionRequired("InstallPackage");
return;
}
}
// mark the package as the client requested.
package.PackageSessionData.DoNotSupercede = (false == autoUpgrade);
package.PackageSessionData.UpgradeAsNeeded = (true == autoUpgrade);
package.PackageSessionData.IsClientSpecified = true;
// the resolve-acquire-install-loop
do {
// if the world changes, this will get set somewhere between here and the
// other end of the do-loop.
manualResetEvent.Reset();
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
IEnumerable<Package> installGraph = null;
try {
installGraph = GenerateInstallGraph(package).ToArray();
}
catch (OperationCompletedBeforeResultException) {
// we encountered an unresolvable condition in the install graph.
// messages should have already been sent.
PackageManagerMessages.Invoke.FailedPackageInstall(canonicalName, package.InternalPackageData.LocalLocation,
"One or more dependencies are unable to be resolved.");
return;
}
// seems like a good time to check if we're supposed to bail...
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
if (download == false && pretend == true) {
// we can just return a bunch of foundpackage messages, since we're not going to be
// actually installing anything, nor trying to download anything.
foreach( var p in installGraph) {
PackageManagerMessages.Invoke.PackageInformation(package, Enumerable.Empty<Package>());
}
return;
}
// we've got an install graph.
// let's see if we've got all the files
var missingFiles = from p in installGraph where !p.InternalPackageData.HasLocalLocation select p;
if( download == true ) {
// we want to try downloading all the files that we're missing, regardless if we've tried before.
// unless we've already tried in this task once.
foreach( var p in missingFiles.Where( each => packagesTriedToDownloadThisTask.Contains(each)) ) {
packagesTriedToDownloadThisTask.Add(p);
p.PackageSessionData.CouldNotDownload = false;
}
}
if( numberOfPackagesToInstall != installGraph.Count() || numberOfPackagesToDownload != missingFiles.Count() ) {
// recalculate the rest of the install progress based on the new install graph.
numberOfPackagesToInstall = installGraph.Count();
numberOfPackagesToDownload = missingFiles.Count();
eachTaskIsWorth = (1.0 - overallProgress)/(numberOfPackagesToInstall + numberOfPackagesToDownload);
}
if (missingFiles.Any()) {
// we've got some packages to install that don't have files.
foreach (var p in missingFiles.Where(p => !p.PackageSessionData.HasRequestedDownload)) {
PackageManagerMessages.Invoke.RequireRemoteFile(p.CanonicalName,
p.InternalPackageData.RemoteLocations , PackageManagerSettings.CoAppCacheDirectory, false);
p.PackageSessionData.HasRequestedDownload = true;
}
}
else {
if( pretend == true ) {
// we can just return a bunch of found-package messages, since we're not going to be
// actually installing anything, and everything we needed is downloaded.
foreach (var p in installGraph) {
PackageManagerMessages.Invoke.PackageInformation(p, Enumerable.Empty<Package>());
}
return;
}
var failed = false;
// no missing files? Check
// complete install graph? Check
foreach (var p in installGraph) {
var pkg = p;
// seems like a good time to check if we're supposed to bail...
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
var validLocation = package.PackageSessionData.LocalValidatedLocation;
try {
if (!pkg.IsInstalled) {
if (string.IsNullOrEmpty(validLocation)) {
// can't find a valid location
PackageManagerMessages.Invoke.FailedPackageInstall(pkg.CanonicalName, pkg.InternalPackageData.LocalLocation, "Can not find local valid package");
pkg.PackageSessionData.PackageFailedInstall = true;
}
else {
var lastProgress = 0;
// GS01: We should put a softer lock here to keep the client aware that packages
// are being installed on other threads...
lock (typeof (MSIBase)) {
if (EngineService.DoesTheServiceNeedARestart) {
// something has changed where we need restart the service before we can continue.
// and the one place we don't wanna be when we issue a shutdown in in Install :) ...
EngineService.RestartService();
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
pkg.Install(percentage => {
overallProgress += ((percentage - lastProgress) *eachTaskIsWorth)/100;
lastProgress = percentage;
PackageManagerMessages.Invoke.InstallingPackageProgress(pkg.CanonicalName, percentage, (int)(overallProgress*100));
});
}
overallProgress += ((100 - lastProgress)*eachTaskIsWorth)/100;
PackageManagerMessages.Invoke.InstallingPackageProgress(pkg.CanonicalName, 100,(int)(overallProgress*100));
PackageManagerMessages.Invoke.InstalledPackage(pkg.CanonicalName);
}
}
}
catch (Exception e ) /* (PackageInstallFailedException pife) */ {
Logger.Error("FAILED INSTALL");
Logger.Error(e);
PackageManagerMessages.Invoke.FailedPackageInstall(pkg.CanonicalName, validLocation, "Package failed to install.");
pkg.PackageSessionData.PackageFailedInstall = true;
if (!pkg.PackageSessionData.AllowedToSupercede) {
throw new OperationCompletedBeforeResultException(); // user specified packge as critical.
}
failed = true;
break;
}
}
if (!failed) {
// W00T ... We did it!
// check for restart required...
if (EngineService.DoesTheServiceNeedARestart) {
// something has changed where we need restart the service before we can continue.
// and the one place we don't wanna be when we issue a shutdown in in Install :) ...
EngineService.RestartService();
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
return;
}
// otherwise, let's run it thru again. maybe it'll come together.
}
//----------------------------------------------------------------------------
// wait until either the manualResetEvent is set, but check every second or so
// to see if the client has cancelled the operation.
while (!manualResetEvent.WaitOne(500)) {
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("install-package");
return;
}
// we can also use this opportunity to update progress on any outstanding download tasks.
overallProgress += missingFiles.Sum(missingFile => ((missingFile.PackageSessionData.DownloadProgressDelta*eachTaskIsWorth)/100));
}
} while (true);
}
catch (OperationCompletedBeforeResultException) {
// can't continue with options given.
return;
}
finally {
// remove manualResetEvent from the mre list
lock (manualResetEvents) {
manualResetEvents.Remove(manualResetEvent);
}
}
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task SuppressFeed(string location, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("suppress-feed");
return;
}
var suppressedFeeds = SessionCache<List<string>>.Value["suppressed-feeds"] ?? new List<string>();
lock (suppressedFeeds) {
if (!suppressedFeeds.Contains(location)) {
suppressedFeeds.Add(location);
SessionCache<List<string>>.Value["suppressed-feeds"] = suppressedFeeds;
}
}
PackageManagerMessages.Invoke.FeedSuppressed(location);
}, TaskCreationOptions.AttachedToParent);
return t;
}
/// <summary>
/// The (non-static) startup method
/// </summary>
/// <param name="args">The command line arguments.</param>
/// <returns>Process return code.</returns>
/// <remarks></remarks>
protected override int Main(IEnumerable<string> args)
{
_messages = new PackageManagerMessages {
UnexpectedFailure = UnexpectedFailure,
NoPackagesFound = NoPackagesFound,
PermissionRequired = OperationRequiresPermission,
Error = MessageArgumentError,
RequireRemoteFile = (canonicalName, remoteLocations, localFolder, force ) => Downloader.GetRemoteFile(canonicalName, remoteLocations, localFolder, force, new RemoteFileMessages {
Progress = (itemUri, percent) => {
"Downloading {0}".format(itemUri.AbsoluteUri).PrintProgressBar(percent);
}, Completed = (itemUri) => {
Console.WriteLine();
}
} ,_messages),
OperationCancelled = CancellationRequested,
PackageSatisfiedBy = (original, satisfiedBy) => {
original.SatisfiedBy = satisfiedBy;
},
PackageBlocked = BlockedPackage,
UnknownPackage = UnknownPackage,
};
try {
#region command line parsing
var options = args.Where(each => each.StartsWith("--")).Switches();
var parameters = args.Where(each => !each.StartsWith("--")).Parameters();
foreach (var arg in options.Keys) {
var argumentParameters = options[arg];
var last = argumentParameters.LastOrDefault();
var lastAsBool = string.IsNullOrEmpty(last) || last.IsTrue();
switch (arg) {
/* options */
case "min-version":
_minVersion = last.VersionStringToUInt64();
break;
case "max-version":
_maxVersion = last.VersionStringToUInt64();
break;
case "installed":
_installed = lastAsBool;
break;
case "active":
_active = lastAsBool;
break;
case "required":
_required = lastAsBool;
break;
case "blocked":
_blocked = lastAsBool;
break;
case "latest":
_latest = lastAsBool;
break;
case "force":
_force = lastAsBool;
break;
case "force-scan":
_forceScan = lastAsBool;
break;
case "download":
_download = lastAsBool;
break;
case "pretend":
_pretend= lastAsBool;
break;
case "auto-upgrade":
_autoUpgrade = lastAsBool;
break;
case "use-feed":
_location = last;
break;
case "pause":
_pause = lastAsBool;
break;
case "verbose":
_verbose = lastAsBool;
Logger.Errors = true;
Logger.Messages = true;
Logger.Warnings = true;
break;
case "dependencies":
case "deps":
_dependencies = lastAsBool;
break;
/* global switches */
case "load-config":
// all ready done, but don't get too picky.
break;
case "nologo":
this.Assembly().SetLogo(string.Empty);
break;
case "terse":
this.Assembly().SetLogo(string.Empty);
_terse = true;
_verbose = false;
break;
case "help":
return Help();
default:
throw new ConsoleException(Resources.UnknownParameter, arg);
}
}
Logo();
if (parameters.Count() < 1) {
throw new ConsoleException(Resources.MissingCommand);
}
#endregion
Task task = null;
var command = parameters.FirstOrDefault();
parameters = parameters.Skip(1);
if (ConsoleExtensions.InputRedirected) {
// grab the contents of the input stream and use that as parameters
var lines = Console.In.ReadToEnd().Split(new[] {
'\r', '\n'
}, StringSplitOptions.RemoveEmptyEntries).Select(each => each.Split(new[] {
'#'
}, StringSplitOptions.RemoveEmptyEntries)[0]).Select(each => each.Trim());
parameters = parameters.Union(lines.Where(each => !each.StartsWith("#"))).ToArray();
}
if (ConsoleExtensions.OutputRedirected) {
this.Assembly().SetLogo(string.Empty);
_terse = true;
_verbose = false;
}
if (command.IsNullOrEmpty()) {
return Help();
}
Verbose("# Connecting to Service...");
_pm.ConnectAndWait("coapp-cli-client", null, 5000);
Verbose("# Connected to Service...");
if( _verbose) {
_pm.SetLogging(true, true, true);
}
if (command.EndsWith(".msi") && File.Exists(command) && parameters.IsNullOrEmpty()) {
// assume install if the only thing given is a filename.
task =
_pm.GetPackages(command, _minVersion, _maxVersion, _dependencies , _installed, _active, _required, _blocked, _latest, _location, _forceScan, messages: _messages).
ContinueWith(antecedent => Install(antecedent.Result));
return 0;
}
if (!command.StartsWith("-")) {
command = command.ToLower();
}
switch (command) {
#if FALSE
case "download":
var remoteFileUri = new Uri(parameters.First());
// create the remote file reference
var remoteFile = new RemoteFile(remoteFileUri, CancellationTokenSource.Token);
var previewTask = remoteFile.Preview();
previewTask.Wait();
// Tell it to download it
var getTask = remoteFile.Get();
// monitor the progress.
remoteFile.DownloadProgress.Notification += progress => {
// this executes when the download progress value changes.
Console.Write(progress <= 100 ? "..{0}% " : "bytes: [{0}]", progress);
};
// when it's done, do this:
getTask.ContinueWith(t => {
// this executes when the Get() operation completes.
Console.WriteLine("File {0} has finished downloading", remoteFile.LocalFullPath);
},TaskContinuationOptions.AttachedToParent);
break;
case "verify-package":
var r = Verifier.HasValidSignature(parameters.First());
Console.WriteLine("Has Valid Signature: {0}", r);
Console.WriteLine("Name: {0}", Verifier.GetPublisherInformation(parameters.First())["PublisherName"]);
break;
#endif
case "-?":
return Help();
case "-l":
case "list":
case "list-package":
case "list-packages":
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, _installed, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages).ContinueWith(antecedent => ListPackages(antecedent.Result));
break;
case "-i":
case "install":
case "install-package":
case "install-packages":
if (parameters.Count() < 1) {
throw new ConsoleException(Resources.InstallRequiresPackageName);
}
// if you haven't specified this, we're gonna assume that you want the latest version
// this is overridden if the user specifies a version tho'
if( _latest == null ) {
_latest = true;
}
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, _installed, _active, _required, _blocked, _latest, _location, _forceScan, messages: _messages).
ContinueWith(antecedent => Install(antecedent.Result));
break;
case "-r":
case "remove":
case "uninstall":
case "remove-package":
case "remove-packages":
case "uninstall-package":
case "uninstall-packages":
if (parameters.Count() < 1) {
throw new ConsoleException(Resources.RemoveRequiresPackageName);
}
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion,_dependencies, true, _active, _required, _blocked, _latest,_location,_forceScan, messages: _messages).
ContinueWith(antecedent => Remove(antecedent.Result));
break;
case "-L":
case "feed":
case "feeds":
case "list-feed":
case "list-feeds":
task = ListFeeds();
break;
case "-u":
case "upgrade":
case "upgrade-package":
case "upgrade-packages":
case "update":
case "update-package":
case "update-packages":
if (parameters.Count() != 1) {
throw new ConsoleException(Resources.MissingParameterForUpgrade);
}
// if they didn't say to rescan (one way or the other), we're defaulting to yeah,
// because we really should force a rescan if we're updating
if( _forceScan == null ) {
_forceScan = true;
}
// should get all packages that are installed (using criteria),
// and then see if each one of those can be upgraded.
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, true, _active, _required, false, _latest ,_location,_forceScan, messages: _messages).
ContinueWith(antecedent => Upgrade(antecedent.Result));
break;
case "-A":
case "add-feed":
case "add-feeds":
case "add":
if (parameters.Count() < 1) {
throw new ConsoleException(Resources.AddFeedRequiresLocation);
}
task = AddFeed(parameters);
break;
case "-R":
case "remove-feed":
case "remove-feeds":
if (parameters.Count() < 1) {
throw new ConsoleException(Resources.DeleteFeedRequiresLocation);
}
task = DeleteFeed(parameters);
break;
case "-t":
case "trim-packages":
case "trim-package":
case "trim":
if (parameters.Count() != 0) {
throw new ConsoleException(Resources.TrimErrorMessage);
}
task = _pm.GetPackages("*", _minVersion, _maxVersion, _dependencies, true, false, false, _blocked, _latest, _location,
_forceScan, messages: _messages).ContinueWith(antecedent => Remove(antecedent.Result));
break;
case "-a":
case "activate":
case "activate-package":
case "activate-packages":
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, true, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages).
ContinueWith(antecedent => Activate(antecedent.Result));
break;
case "-g":
case "get-packageinfo":
case "info":
task = _pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, _installed, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages).ContinueWith(antecedent => GetPackageInfo(antecedent.Result));
break;
case "-b":
case "block-packages":
case "block-package":
case "block":
task =_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, true, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages). ContinueWith(antecedent => Block(antecedent.Result));
break;
case "-B":
case "unblock-packages":
case "unblock-package":
case "unblock":
task = _pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, true, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages).ContinueWith(antecedent => UnBlock(antecedent.Result));
break;
case "-m":
case "mark-packages":
case "mark-package":
case "mark":
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, true, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages).
ContinueWith(antecedent => Mark(antecedent.Result));
break;
case "-M":
case "unmark-packages":
case "unmark-package":
case "unmark":
task =
_pm.GetPackages(parameters, _minVersion, _maxVersion, _dependencies, true, _active, _required, _blocked, _latest, _location,_forceScan, messages: _messages).
ContinueWith(antecedent => UnMark(antecedent.Result));
break;
case "create-symlink":
if (parameters.Count() != 2) {
throw new ConsoleException("Create-symlink requires two parameters: existing-location and new-link");
}
task = _pm.CreateSymlink(parameters.First().GetFullPath(), parameters.Last().GetFullPath(), LinkType.Symlink);
break;
case "create-hardlink":
if (parameters.Count() != 2) {
throw new ConsoleException("Create-hardlink requires two parameters: existing-location and new-link");
}
task = _pm.CreateSymlink(parameters.First().GetFullPath(), parameters.Last().GetFullPath(), LinkType.Hardlink);
break;
case "create-shortcut":
if (parameters.Count() != 2) {
throw new ConsoleException("Create-shortcut requires two parameters: existing-location and new-link");
}
task = _pm.CreateSymlink(parameters.First().GetFullPath(), parameters.Last().GetFullPath(), LinkType.Shortcut);
break;
case "-p" :
case "list-policies":
case "list-policy":
case "policies":
ListPolicies();
break;
case "add-to-policy": {
if (parameters.Count() != 2) {
throw new ConsoleException("Add-to-policy requires at two parameters (policy name and account)");
}
var policyName = parameters.First();
var account = parameters.Last();
task = _pm.AddToPolicy(policyName, account, _messages).ContinueWith(antecedent => {
if( antecedent.IsFaulted ) {
throw antecedent.Exception;
}
_pm.GetPolicy(policyName, new PackageManagerMessages {
PolicyInformation = (polName, description, accounts) => {
Console.WriteLine("Policy: {0} -- {1} ", polName, description);
foreach (var acct in accounts) {
Console.WriteLine(" {0}", acct);
}
}
}.Extend(_messages)).Wait();
});
}
break;
case "remove-from-policy": {
if (parameters.Count() != 2) {
throw new ConsoleException("Remove-to-policy requires at two parameters (policy name and account)");
}
var policyName = parameters.First();
var account = parameters.Last();
task = _pm.RemoveFromPolicy(policyName, account, _messages).ContinueWith(antecedent => {
if (antecedent.IsFaulted) {
throw antecedent.Exception;
}
_pm.GetPolicy(policyName, new PackageManagerMessages {
PolicyInformation = (polName, description, accounts) => {
Console.WriteLine("Policy: {0} -- {1}", polName, description);
foreach (var acct in accounts) {
Console.WriteLine(" {0}", acct);
}
}
}.Extend(_messages)).Wait();
});
}
break;
default:
throw new ConsoleException(Resources.UnknownCommand, command);
}
if (task != null) {
task.ContinueWith(antecedent => {
if (!(antecedent.IsFaulted || antecedent.IsCanceled)) {
WaitForPackageManagerToComplete();
}
}).Wait();
}
if( _pause == true ) {
Console.ReadLine();
}
_pm.Disconnect();
if (_pause == true) {
Console.ReadLine();
}
}
catch (ConsoleException failure) {
Fail("{0}\r\n\r\n {1}", failure.Message, Resources.ForCommandLineHelp);
CancellationTokenSource.Cancel();
_pm.Disconnect();
}
return 0;
}
public Task VerifyFileSignature(string filename, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("verify-signature");
return;
}
if (string.IsNullOrEmpty(filename)) {
PackageManagerMessages.Invoke.Error("verify-signature", "filename", "parameter 'filename' is required to verify a file");
return;
}
var location = PackageManagerSession.Invoke.GetCanonicalizedPath(filename);
if (!File.Exists(location)) {
PackageManagerMessages.Invoke.FileNotFound(location);
return;
}
var r = Verifier.HasValidSignature(location);
if (r) {
PackageManagerMessages.Invoke.SignatureValidation(location, r, Verifier.GetPublisherInformation(location)["PublisherName"]);
}
else {
PackageManagerMessages.Invoke.SignatureValidation(location, false, null);
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task AddFeed(string location, bool? session, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("add-feed");
return;
}
if (session ?? false) {
// new feed is a session feed
// session feed specfied
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EditSessionFeeds)) {
PackageManagerMessages.Invoke.PermissionRequired("EditSessionFeeds");
return;
}
// check if it is already a system feed
if (SystemFeedLocations.Contains(location)) {
PackageManagerMessages.Invoke.Warning("add-feed", "location", "location '{0}' is already a system feed".format(location));
return;
}
if (SessionFeedLocations.Contains(location)) {
PackageManagerMessages.Invoke.Warning("add-feed", "location", "location '{0}' is already a session feed".format(location));
return;
}
AddSessionFeed(location);
PackageManagerMessages.Invoke.FeedAdded(location);
// add feed to the session feeds.
PackageFeed.GetPackageFeedFromLocation(location).ContinueWith(antecedent => {
var foundFeed = antecedent.Result;
if (foundFeed != null) {
if (foundFeed != SessionPackageFeed.Instance || foundFeed != InstalledPackageFeed.Instance ) {
SessionCache<PackageFeed>.Value[location] = foundFeed;
}
}
else {
PackageManagerMessages.Invoke.Error("add-feed", "location",
"failed to recognize location '{0}' as a valid package feed".format(location));
LogMessage("Feed {0} was unable to load.", location);
}
}, TaskContinuationOptions.AttachedToParent);
}
else {
// new feed is a system feed
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EditSystemFeeds)) {
PackageManagerMessages.Invoke.PermissionRequired("EditSystemFeeds");
return;
}
if (SystemFeedLocations.Contains(location)) {
PackageManagerMessages.Invoke.Warning("add-feed", "location", "location '{0}' is already a system feed".format(location));
return;
}
AddSystemFeed(location);
PackageManagerMessages.Invoke.FeedAdded(location);
// add feed to the system feeds.
PackageFeed.GetPackageFeedFromLocation(location).ContinueWith(antecedent => {
var foundFeed = antecedent.Result;
if (foundFeed != null) {
if (foundFeed != SessionPackageFeed.Instance || foundFeed != InstalledPackageFeed.Instance) {
Cache<PackageFeed>.Value[location] = foundFeed;
}
}
else {
PackageManagerMessages.Invoke.Error("add-feed", "location",
"failed to recognize location '{0}' as a valid package feed".format(location));
LogMessage("Feed {0} was unable to load.", location);
}
}, TaskContinuationOptions.AttachedToParent);
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
protected override void BeginProcessing()
{
BackRef = this;
output = new List<object>();
// Remoting...
if (!ComputerName.IsNullOrEmpty())
{
Remotes = new List<Runspace>();
Remote.ConnectionGenerator Gen = new Remote.ConnectionGenerator(UseSSL, Credential, Port);
foreach (string comp in ComputerName)
{
Remotes.Add(Gen.Generate(comp, Timeout, true));
}
}
// Not remoting...
else
{
PM = PackageManager.Instance;
PM.ConnectAndWait("PSClient", SessionID, Timeout ?? 5000);
messages = new PackageManagerMessages
{
UnexpectedFailure = UnexpectedFailure,
NoPackagesFound = NoPackagesFound,
PermissionRequired = OperationRequiresPermission,
Error = MessageArgumentError,
RequireRemoteFile = GetRemoteFile,
OperationCancelled = CancellationRequested,
PackageInformation = PackageInfo,
PackageDetails = PackageDetail,
FeedDetails = FeedInfo,
ScanningPackagesProgress = ScanProgress,
InstallingPackageProgress = InstallProgress,
RemovingPackageProgress = RemoveProgress,
InstalledPackage = InstallComplete,
RemovedPackage = RemoveComplete,
FailedPackageInstall = InstallFailed,
FailedPackageRemoval = RemoveFailed,
Warning = WarningMsg,
FeedAdded = NewFeed,
FeedRemoved = LostFeed,
FeedSuppressed = SupressedFeed,
NoFeedsFound = NoFeeds,
FileNotFound = NoFile,
PackageBlocked = BlockedPackage,
FileNotRecognized = NotRecognized,
Recognized = Recognized,
UnknownPackage = Unknown,
PackageHasPotentialUpgrades = PotentialUpgrades,
UnableToDownloadPackage = UnableToDownload,
UnableToInstallPackage = UnableToInstall,
UnableToResolveDependencies = UnableToResolveDeps,
PackageSatisfiedBy = Satisfied
};
}
}
protected override void ProcessRecord()
{
// Handle remoting
if (!ComputerName.IsNullOrEmpty())
{
Command com = new Command("Get-PackageInfo");
if (InputPackage != null) com.Parameters.Add("InputPackage", InputPackage);
if (CanonicalName != null) com.Parameters.Add("CanonicalName", CanonicalName);
if (Name != null) com.Parameters.Add("Name", Name);
if (Version != null) com.Parameters.Add("Version", Version);
if (Arch != null) com.Parameters.Add("Arch", Arch);
if (PublicKeyToken != null) com.Parameters.Add("PublicKeyToken", PublicKeyToken);
if (MinVersion != null) com.Parameters.Add("MinVersion", MinVersion);
if (MaxVersion != null) com.Parameters.Add("MaxVersion", MaxVersion);
if (Dependencies != null) com.Parameters.Add("Dependencies", Dependencies);
if (Installed != null) com.Parameters.Add("Installed", Installed);
if (Active != null) com.Parameters.Add("Active", Active);
if (Required != null) com.Parameters.Add("Required", Required);
if (Blocked != null) com.Parameters.Add("Blocked", Blocked);
if (Latest != null) com.Parameters.Add("Latest", Latest);
if (Index != null) com.Parameters.Add("Index", Index);
if (MaxResults != null) com.Parameters.Add("MaxResults", MaxResults);
if (Location != null) com.Parameters.Add("Location", Location);
if (ForceScan) com.Parameters.Add("ForceScan");
task = new Task(() =>
{
foreach (Runspace R in Remotes)
{
Task<Collection<PSObject>> T = new Task<Collection<PSObject>>(() =>
Remote.Exec(R, com));
T.ContinueWith(antecedent =>
output.AddRange(antecedent.Result), TaskContinuationOptions.AttachedToParent);
T.Start();
}
});
task.Start();
}
//Non-Remoting
else
{
Package Details = null;
PackageManagerMessages DetailMessages = new PackageManagerMessages()
{
PackageDetails = (P) =>
{
Details = P;
}
}.Extend(messages);
switch (ParameterSetName)
{
case "Package":
CanonicalName = InputPackage.CanonicalName;
goto case "Canonical";
case "Canonical":
task = PM.GetPackageDetails(InputPackage.CanonicalName, DetailMessages).ContinueWith((FP) =>
{
if
(
Details !=
null)
output
.
Add
(Details);
},
TaskContinuationOptions
.
AttachedToParent);
break;
case "Typed":
string search = Name + (Version != null ? "-" + Version : "") + (Arch != null ? "-" + Arch : "") +
(PublicKeyToken != null ? "-" + PublicKeyToken : "");
task = PM.GetPackages(search,
MinVersion != null ? MinVersion.VersionStringToUInt64() : (ulong?) null,
MaxVersion != null ? MaxVersion.VersionStringToUInt64() : (ulong?) null,
Dependencies, Installed, Active, Required, Blocked, Latest, Location,
ForceScan, messages)
.ContinueWith((FP) =>
{
String P;
IEnumerable<Package> PL = FP.Result;
int i = 0;
if (PL.Count() > 1)
{
Collection<ChoiceDescription> Choices = new Collection<ChoiceDescription>();
foreach (Package p in PL)
{
string desc = "";
desc += Selections[i++];
desc += p.Name + "-" + p.Version + "-" + p.Architecture;
Choices.Add(new ChoiceDescription(desc, p.CanonicalName));
}
int choice =
Host.UI.PromptForChoice(
"Multiple possible matches.",
"Please choose one of the following:",
Choices, 0);
P = Choices[choice].HelpMessage;
// do menu stuff here
}
else
{
P = PL.FirstOrDefault().CanonicalName;
}
PM.GetPackageDetails(P, DetailMessages)
.ContinueWith((FDP) =>
{
if (Details != null)
output.Add(Details);
},
TaskContinuationOptions.AttachedToParent);
});
break;
default:
Host.UI.WriteLine("Invalid input parameters.");
break;
}
}
}
protected override void ProcessRecord()
{
// Handle remoting
if (!ComputerName.IsNullOrEmpty())
{
Command com = new Command("Add-Feed");
if (Location != null) com.Parameters.Add("Location", Location);
if (SessionOnly) com.Parameters.Add("SessionOnly");
task = new Task(() =>
{
foreach (Runspace R in Remotes)
{
Task<Collection<PSObject>> T = new Task<Collection<PSObject>>(() => Remote.Exec(R, com));
T.ContinueWith(antecedent =>
output.AddRange(antecedent.Result), TaskContinuationOptions.AttachedToParent);
T.Start();
}
});
task.Start();
}
//Non-Remoting
else
{
PackageManagerMessages FeedMessages = new PackageManagerMessages()
{
FeedAdded = (S) => Host.UI.WriteLine("Feed Added: " + S)
}.Extend(messages);
task = PM.AddFeed(Location, SessionOnly, FeedMessages);
}
}
protected override void ProcessRecord()
{
// Handle remoting
if (!ComputerName.IsNullOrEmpty())
{
Command com = new Command("List-Feed");
if (Index != null) com.Parameters.Add("Index", Index);
if (MaxResults != null) com.Parameters.Add("MaxResults", MaxResults);
task = new Task(() =>
{
foreach (Runspace R in Remotes)
{
Task<Collection<PSObject>> T = new Task<Collection<PSObject>>(() =>
Remote.Exec(R, com));
T.ContinueWith(antecedent =>
output.AddRange(antecedent.Result), TaskContinuationOptions.AttachedToParent);
T.Start();
}
});
task.Start();
}
//Non-Remoting
else
{
PackageManagerMessages FeedMessages = new PackageManagerMessages()
{
FeedDetails = (Loc, Scanned, isSession, supressed, verified) => output
.Add(new Feed()
{
Location = Loc,
LastScanned = Scanned,
Session = isSession,
Supressed = supressed,
Verified = verified
})
}.Extend(messages);
task = PM.ListFeeds(Index, MaxResults, FeedMessages);
}
}
protected override void ProcessRecord()
{
// Handle remoting
if (!ComputerName.IsNullOrEmpty())
{
Command com = new Command("Install-Package");
if (InputPackage != null) com.Parameters.Add("InputPackage", InputPackage);
if (CanonicalName != null) com.Parameters.Add("CanonicalName", CanonicalName);
if (Name != null) com.Parameters.Add("Name", Name);
if (Version != null) com.Parameters.Add("Version", Version);
if (Arch != null) com.Parameters.Add("Arch", Arch);
if (PublicKeyToken != null) com.Parameters.Add("PublicKeyToken", PublicKeyToken);
if (MinVersion != null) com.Parameters.Add("MinVersion", MinVersion);
if (MaxVersion != null) com.Parameters.Add("MaxVersion", MaxVersion);
if (Dependencies != null) com.Parameters.Add("Dependencies", Dependencies);
if (Active != null) com.Parameters.Add("Active", Active);
if (Required != null) com.Parameters.Add("Required", Required);
if (Blocked != null) com.Parameters.Add("Blocked", Blocked);
if (Latest != null) com.Parameters.Add("Latest", Latest);
if (Index != null) com.Parameters.Add("Index", Index);
if (MaxResults != null) com.Parameters.Add("MaxResults", MaxResults);
if (Location != null) com.Parameters.Add("Location", Location);
if (ForceScan) com.Parameters.Add("ForceScan");
if (AutoUpgrade != null) com.Parameters.Add("AutoUpgrade", AutoUpgrade);
if (ForceInstall) com.Parameters.Add("ForceInstall");
if (ForceDownload) com.Parameters.Add("ForceDownload");
if (Pretend) com.Parameters.Add("Pretend");
task = new Task(() =>
{
foreach (Runspace R in Remotes)
{
Task<Collection<PSObject>> T = new Task<Collection<PSObject>>(() =>
Remote.Exec(R, com));
T.ContinueWith(antecedent =>
output.AddRange(antecedent.Result), TaskContinuationOptions.AttachedToParent);
T.Start();
}
});
task.Start();
}
//Non-Remoting
else
{
int ID_Counter = 1;
bool Running = true;
AutoResetEvent Inbound = new AutoResetEvent(false);
Dictionary<int, ProgressRecord> Recs = new Dictionary<int, ProgressRecord>();
Dictionary<String, int> Children = new Dictionary<string, int>();
PackageManagerMessages InstallMessages = new PackageManagerMessages()
{
InstallingPackageProgress = (N, P, T) =>
{
if (!Children.ContainsKey(N))
Children[N] = ID_Counter++;
ProgressRecord current = new ProgressRecord(Children[N], N, "Installing...");
current.PercentComplete = P;
current.CurrentOperation = "Installing package...";
current.SecondsRemaining = -1;
Recs[Children[N]] = current;
Inbound.Set();
},
InstalledPackage = (N) =>
{
ProgressRecord current = new ProgressRecord(Children[N], N, "Installing...");
current.PercentComplete = 100;
current.CurrentOperation = "Installing package...";
current.SecondsRemaining = -1;
Recs[Children[N]] = current;
Inbound.Set();
Children.Remove(N);
},
FailedPackageInstall = (name,file,reason) => Host.UI.WriteLine("Installation failed for package: "+name+", from file "+file+", for reason: "+reason)
}.Extend(messages);
switch (ParameterSetName)
{
case "Package":
CanonicalName = InputPackage.CanonicalName;
goto case "Canonical";
case "Canonical":
task = PM.InstallPackage(CanonicalName, AutoUpgrade, ForceInstall, ForceDownload, Pretend, InstallMessages).ContinueWith(antecedent =>
{
Running = false;
Inbound.Set();
}, TaskContinuationOptions.AttachedToParent);
break;
case "Typed":
string search = Name + (Version != null ? "-" + Version : "") + (Arch != null ? "-" + Arch : "") + (PublicKeyToken != null ? "-" + PublicKeyToken : "");
task = PM.GetPackages(search, MinVersion != null ? MinVersion.VersionStringToUInt64() : (ulong?)null,
MaxVersion != null ? MaxVersion.VersionStringToUInt64() : (ulong?)null,
Dependencies, Installed, Active, Required, Blocked, Latest, Location, ForceScan,
messages).ContinueWith((FP) =>
{
String P;
IEnumerable<Package> PL = FP.Result;
int i = 0;
if (PL.Count() > 1)
{
Collection<System.Management.Automation.Host.ChoiceDescription> Choices = new Collection<ChoiceDescription>();
foreach (Package p in PL)
{
string desc = "";
desc += Selections[i++];
desc += p.Name + "-" + p.Version + "-" + p.Architecture;
Choices.Add(new ChoiceDescription(desc, p.CanonicalName));
}
int choice = Host.UI.PromptForChoice("Multiple possible matches.",
"Please choose one of the following:", Choices, 0);
P = Choices[choice].HelpMessage;
// do menu stuff here
}
else
{
P = PL.FirstOrDefault().CanonicalName;
}
PM.InstallPackage(P, AutoUpgrade, ForceInstall, ForceDownload, Pretend, InstallMessages);
}, TaskContinuationOptions.AttachedToParent).ContinueWith(antecedent =>
{
Running = false;
Inbound.Set();
});
break;
default:
Host.UI.WriteLine("Invalid input parameters.");
break;
}
do
{
Inbound.WaitOne();
if (Recs.Any())
foreach (KeyValuePair<int, ProgressRecord> PR in Recs)
{
WriteProgress(PR.Value);
if (PR.Value.PercentComplete >= 100)
Recs.Remove(PR.Key);
}
} while (Running);
}
}
public Task RemovePackage(string canonicalName, bool? force ,PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("remove-package");
return;
}
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.RemovePackage)) {
PackageManagerMessages.Invoke.PermissionRequired("RemovePackage");
return;
}
var package = GetSinglePackage(canonicalName, "remove-package");
if (package == null) {
PackageManagerMessages.Invoke.UnknownPackage(canonicalName);
return;
}
if (package.Name.Equals( "coapp.toolkit", StringComparison.CurrentCultureIgnoreCase ) && package.PublicKeyToken.Equals("820d50196d4e8857") && package.IsActive ) {
PackageManagerMessages.Invoke.Error("remove-package", "canonical-name", "Active CoApp Engine may not be removed");
return;
}
if (!package.IsInstalled) {
PackageManagerMessages.Invoke.Error("remove-package", "canonical-name", "package '{0}' is not installed.".format(canonicalName));
return;
}
if (package.IsBlocked) {
PackageManagerMessages.Invoke.PackageBlocked(canonicalName);
return;
}
if (true != force) {
UpdateIsRequestedFlags();
if (package.PackageSessionData.IsDependency) {
PackageManagerMessages.Invoke.FailedPackageRemoval(canonicalName,
"Package '{0}' is a required dependency of another package.".format(canonicalName));
return;
}
}
// seems like a good time to check if we're supposed to bail...
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("remove-package");
return;
}
try {
package.Remove((percentage) => PackageManagerMessages.Invoke.RemovingPackageProgress(package.CanonicalName, percentage));
PackageManagerMessages.Invoke.RemovingPackageProgress(canonicalName, 100);
PackageManagerMessages.Invoke.RemovedPackage(canonicalName);
}
catch (OperationCompletedBeforeResultException e) {
PackageManagerMessages.Invoke.FailedPackageRemoval(canonicalName, e.Message);
return;
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task DownloadProgress( string canonicalName , int? downloadProgress,PackageManagerMessages messages )
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
try {
// it takes a non-trivial amount of time to lookup a package by its name.
// so, we're going to cache the package in the session.
// of course if there isn't one, (because we're downloading soemthing we don't know what it's actualy canonical name is)
// we don't want to try looking up each time again, since that's the worst-case-scenario, we have to
// cache the fact that we have cached nothing.
// /facepalm.
Package package;
var cachedPackageName = SessionCache<string>.Value["cached-the-lookup" + canonicalName];
if( cachedPackageName == null ) {
SessionCache<string>.Value["cached-the-lookup" + canonicalName] = "yes";
package = GetSinglePackage(canonicalName, "download-progress", true);
if (package != null) {
SessionCache<Package>.Value[canonicalName] = package;
}
} else {
package = SessionCache<Package>.Value[ canonicalName];
}
if (package != null) {
package.PackageSessionData.DownloadProgress = Math.Max(package.PackageSessionData.DownloadProgress, downloadProgress.GetValueOrDefault());
}
} catch {
// suppress any exceptions... we just don't care!
}
SessionCache<string>.Value["busy" + canonicalName] = null;
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task SetPackage(string canonicalName, bool? active, bool? required, bool? blocked, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("set-package");
return;
}
var package = GetSinglePackage(canonicalName, "set-package");
if (package == null) {
PackageManagerMessages.Invoke.UnknownPackage(canonicalName);
return;
}
if (!package.IsInstalled) {
PackageManagerMessages.Invoke.Error("set-package", "canonical-name", "package '{0}' is not installed.".format(canonicalName));
return;
}
// seems like a good time to check if we're supposed to bail...
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("set-package");
return;
}
if (true == active) {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.ChangeActivePackage)) {
PackageManagerMessages.Invoke.PermissionRequired("ChangeActivePackage");
}
else {
package.SetPackageCurrent();
}
}
if (false == active) {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.ChangeActivePackage)) {
PackageManagerMessages.Invoke.PermissionRequired("ChangeActivePackage");
}
else {
SearchForInstalledPackages(package.Name, null, package.Architecture, package.PublicKeyToken).HighestPackages().FirstOrDefault().
SetPackageCurrent();
}
}
if (true == required) {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.ChangeRequiredState)) {
PackageManagerMessages.Invoke.PermissionRequired("ChangeRequiredState");
}
else {
package.IsRequired = true;
}
}
if (false == required) {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.ChangeRequiredState)) {
PackageManagerMessages.Invoke.PermissionRequired("ChangeRequiredState");
}
else {
package.IsRequired = false;
}
}
if (true == blocked) {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.ChangeBlockedState)) {
PackageManagerMessages.Invoke.PermissionRequired("ChangeBlockedState");
}
else {
package.IsBlocked = true;
}
}
if (false == blocked) {
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.ChangeBlockedState)) {
PackageManagerMessages.Invoke.PermissionRequired("ChangeBlockedState");
}
else {
package.IsBlocked = false;
}
}
PackageManagerMessages.Invoke.PackageInformation(package, Enumerable.Empty<Package>());
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task FindPackages( string canonicalName, string name, string version, string arch, string publicKeyToken,
bool? dependencies, bool? installed, bool? active, bool? required, bool? blocked, bool? latest,
int? index, int? maxResults, string location, bool? forceScan, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("find-package");
return;
}
if (!PackageManagerSession.Invoke.CheckForPermission(PermissionPolicy.EnumeratePackages)) {
PackageManagerMessages.Invoke.PermissionRequired("EnumeratePackages");
return;
}
UpdateIsRequestedFlags();
// get basic list of packages based on primary characteristics
if (!string.IsNullOrEmpty(canonicalName)) {
// if canonical name is passed, override name,version,pkt,arch with the parsed canonicalname.
var match = _canonicalNameParser.Match(canonicalName.ToLower());
if (!match.Success) {
PackageManagerMessages.Invoke.Error("find-packages", "canonical-name",
"Canonical name '{0}' does not appear to be a valid canonical name".format(canonicalName));
return;
}
name = match.Groups[1].Captures[0].Value;
version = match.Groups[2].Captures[0].Value;
arch = match.Groups[3].Captures[0].Value;
publicKeyToken = match.Groups[4].Captures[0].Value;
}
if( forceScan == true ) {
foreach( var feed in Feeds ) {
feed.Stale = true;
}
}
var results = SearchForPackages(name, version, arch, publicKeyToken, location);
// filter results of list based on secondary filters
results = from package in results
where
(installed == null || package.IsInstalled == installed) && (active == null || package.IsActive == active) &&
(required == null || package.IsRequired == required) && (blocked == null || package.IsBlocked == blocked)
select package;
// only the latest?
if (latest == true) {
results = results.HighestPackages();
}
// if the client has asked for the dependencies as well, include them in the result set.
// otherwise the client will get the names in
if (dependencies == true) {
// grab the dependencies too.
var deps = results.SelectMany(each => each.InternalPackageData.Dependencies).Distinct();
if (latest == true) {
deps = deps.HighestPackages();
}
results = results.Union(deps).Distinct();
}
// paginate the results
if (index.HasValue) {
results = results.Skip(index.Value);
}
if (maxResults.HasValue) {
results = results.Take(maxResults.Value);
}
if (results.Any()) {
foreach (var package in results) {
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("find-packages");
return;
}
// otherwise, we're installing a dependency, and we need something compatable.
var supercedents = (from p in SearchForPackages(package.Name, null, package.Architecture, package.PublicKeyToken)
where p.InternalPackageData.PolicyMinimumVersion <= package.Version && p.InternalPackageData.PolicyMaximumVersion >= package.Version
select p).OrderByDescending(p => p.Version).ToArray();
PackageManagerMessages.Invoke.PackageInformation(package, supercedents);
}
}
else {
PackageManagerMessages.Invoke.NoPackagesFound();
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task UnableToAcquire(string canonicalName, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("unable-to-acquire");
return;
}
if (canonicalName.IsNullOrEmpty()) {
PackageManagerMessages.Invoke.Error("unable-to-acquire", "canonical-name", "canonical-name is required.");
return;
}
// if there is a continuation task for the canonical name that goes along with this,
// we should continue with that task, and get the heck out of here.
//
var package = GetSinglePackage(canonicalName, null);
if (package != null) {
package.PackageSessionData.CouldNotDownload = true;
}
var continuationTask = SessionCache<Task<Recognizer.RecognitionInfo>>.Value[canonicalName];
SessionCache<Task<Recognizer.RecognitionInfo>>.Value.Clear(canonicalName);
Updated(); // notify threads that we're not going to be able to get that file.
if (continuationTask != null) {
var state = continuationTask.AsyncState as RequestRemoteFileState;
if (state != null) {
state.LocalLocation = null;
}
// the task can run,
continuationTask.Start();
return;
}
}, TaskCreationOptions.AttachedToParent);
return t;
}
public Task GetPackageDetails(string canonicalName, PackageManagerMessages messages)
{
var t = Task.Factory.StartNew(() => {
if (messages != null) {
messages.Register();
}
if (CancellationRequested) {
PackageManagerMessages.Invoke.OperationCancelled("get-package-details");
return;
}
var package = GetSinglePackage(canonicalName, "get-package-details");
if (package == null) {
return;
}
PackageManagerMessages.Invoke.PackageDetails(package);
}, TaskCreationOptions.AttachedToParent);
return t;
}
protected override int Main(IEnumerable<string> args)
{
_messages = new PackageManagerMessages {
UnexpectedFailure = UnexpectedFailure,
NoPackagesFound = NoPackagesFound,
PermissionRequired = OperationRequiresPermission,
Error = MessageArgumentError,
RequireRemoteFile =
(canonicalName, remoteLocations, localFolder, force) =>
Downloader.GetRemoteFile(canonicalName, remoteLocations, localFolder, force, new RemoteFileMessages {
Progress = (itemUri, percent) => { "Downloading {0}".format(itemUri.AbsoluteUri).PrintProgressBar(percent); },
}, _messages),
OperationCancelled = CancellationRequested,
PackageSatisfiedBy = (original, satisfiedBy) => { original.SatisfiedBy = satisfiedBy; },
PackageBlocked = BlockedPackage,
UnknownPackage = UnknownPackage,
};
Verbose("# Connecting to Service...");
_pm.ConnectAndWait("mkRepo tool", null, 5000);
Verbose("# Connected to Service...");
try {
#region command line parsing
var options = args.Where(each => each.StartsWith("--")).Switches();
var parameters = args.Where(each => !each.StartsWith("--")).Parameters();
foreach (var arg in options.Keys) {
var argumentParameters = options[arg];
var last = argumentParameters.LastOrDefault();
var lastAsBool = string.IsNullOrEmpty(last) || last.IsTrue();
switch (arg) {
/* options */
case "verbose":
_verbose = lastAsBool;
Logger.Errors = true;
Logger.Messages = true;
Logger.Warnings = true;
break;
/* global switches */
case "load-config":
// all ready done, but don't get too picky.
break;
case "nologo":
this.Assembly().SetLogo(string.Empty);
break;
case "help":
return Help();
case "output":
_output = last;
break;
case "input":
_input = last;
break;
case "feed-location":
try {
_feedLocation = new Uri(last);
} catch {
throw new ConsoleException("Feed Location '{0}' is not a valid URI ", last);
}
break;
case "base-url":
try {
_baseUrl = new Uri(last);
} catch {
throw new ConsoleException("Base Url Location '{0}' is not a valid URI ", last);
}
break;
default:
throw new ConsoleException(Resources.UnknownParameter, arg);
}
}
Logo();
#endregion
if (parameters.Count() < 1) {
throw new ConsoleException(Resources.MissingCommand);
}
_packages = parameters.Skip(1);
switch( parameters.FirstOrDefault() ) {
case "create" :
Logger.Message("Creating Feed ");
Create();
break;
default:
throw new ConsoleException(Resources.UnknownCommand, parameters.FirstOrDefault());
}
} catch (ConsoleException failure) {
Fail("{0}\r\n\r\n {1}", failure.Message, Resources.ForCommandLineHelp);
CancellationTokenSource.Cancel();
_pm.Disconnect();
}
return 0;
}
public static Task GetRemoteFile(string canonicalName, IEnumerable<string> locations, string targetFolder, bool forceDownload, RemoteFileMessages remoteFileMessages = null, PackageManagerMessages messages = null)
{
if ( messages == null ) {
messages = new PackageManagerMessages();
}
messages.Register();
if( remoteFileMessages !=null ) {
remoteFileMessages.Register();
}
var targetFilename = Path.Combine(targetFolder, canonicalName);
lock (_currentDownloads) {
if (_currentDownloads.ContainsKey(targetFilename)) {
return _currentDownloads[targetFilename];
}
if (File.Exists(targetFilename) && !forceDownload) {
PackageManager.Instance.RecognizeFile(canonicalName, targetFilename, "<file exists>", new PackageManagerMessages().Extend(messages));
return null;
}
// gotta download the file...
var task = Task.Factory.StartNew(() => {
foreach (var location in locations) {
try {
var uri = new Uri(location);
if (uri.IsFile) {
// try to copy the file local.
var remoteFile = uri.AbsoluteUri.CanonicalizePath();
// if this fails, we'll just move down the line.
File.Copy(remoteFile, targetFilename);
PackageManager.Instance.RecognizeFile(canonicalName, targetFilename, uri.AbsoluteUri,
new PackageManagerMessages().Extend(messages));
return;
}
Task progressTask = null;
var rf = RemoteFile.GetRemoteFile(uri, targetFilename);
rf.Get(new RemoteFileMessages {
Completed = (itemUri) => {
PackageManager.Instance.RecognizeFile(canonicalName, targetFilename, uri.AbsoluteUri, new PackageManagerMessages().Extend(messages));
if( remoteFileMessages != null ) {
remoteFileMessages.Completed(itemUri);
}
},
Failed = (itemUri) => {
if (File.Exists(targetFilename)) {
targetFilename.TryHardToDelete();
if( remoteFileMessages != null ) {
remoteFileMessages.Failed(itemUri);
}
}
},
Progress = (itemUri, percent) => {
if (progressTask == null) {
progressTask = PackageManager.Instance.DownloadProgress(canonicalName, percent);
progressTask.ContinueWith((antecedent) => { progressTask = null; });
}
if( remoteFileMessages != null ) {
remoteFileMessages.Progress(itemUri, percent);
}
}
}).Wait();
if (File.Exists(targetFilename)) {
return;
}
}
catch {
// bogus, dude.
// try the next one.
}
}
PackageManager.Instance.UnableToAcquire(canonicalName, new PackageManagerMessages());
}, TaskCreationOptions.AttachedToParent).ContinueWith(antecedent => {
lock (_currentDownloads) {
_currentDownloads.Remove(targetFilename);
}
}, TaskContinuationOptions.AttachedToParent);
_currentDownloads.Add(targetFilename, task);
return task;
}
}