| protected InstallPackage ( IPackage package, FrameworkName targetFramework, bool ignoreDependencies, bool allowPrereleaseVersions ) : void | ||
| package | IPackage | |
| targetFramework | FrameworkName | |
| ignoreDependencies | bool | |
| allowPrereleaseVersions | bool | |
| Résultat | void | |
/// <summary>
/// Installs the specified package.
/// </summary>
/// <param name="name">The name.</param>
/// <returns>Null on error, otherwise the package belonging to the name.</returns>
public IPackage Install(string name)
{
try
{
IPackage package = Repo.FindPackage(name);
// important: the following line will throw an exception when debugging
// if using the official Nuget.Core dll.
// Run without debugging to avoid the exception and install the package
// more at http://nuget.codeplex.com/discussions/259099
// We include a custom nuget.core without SecurityTransparent to avoid the error.
if (package != null)
{
_packageManager.InstallPackage(package, true, false);
return(package);
}
}
catch (WebException ex)
{
// Timed out.
Debug.WriteLine(ex.Message);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
return(null);
}
private static void Main(string[] args)
{
bool removeDirectory;
string temporaryDirectory = GetTemporaryDirectory(out removeDirectory);
Console.WriteLine("Working directory: {0}", temporaryDirectory);
try
{
IPackageRepository sourceRepository = PackageRepositoryFactory.Default.CreateRepository("https://www.nuget.org/api/v2/");
PackageManager packageManager = new PackageManager(sourceRepository, temporaryDirectory);
packageManager.PackageInstalled += HandlePackageInstalled;
packageManager.InstallPackage("Microsoft.Bcl.Immutable", SemanticVersion.Parse("1.0.34"));
packageManager.InstallPackage("System.Collections.Immutable", SemanticVersion.Parse("1.1.33-beta"));
using (PEReader referenceAssembly = new PEReader(File.OpenRead(Path.Combine(temporaryDirectory, "Microsoft.Bcl.Immutable.1.0.34", "lib", "portable-net45+win8+wp8+wpa81", "System.Collections.Immutable.dll"))))
{
using (PEReader newAssembly = new PEReader(File.OpenRead(Path.Combine(temporaryDirectory, "System.Collections.Immutable.1.1.33-beta", "lib", "portable-net45+win8+wp8+wpa81", "System.Collections.Immutable.dll"))))
{
Analyzer analyzer = new Analyzer(referenceAssembly, newAssembly, null);
analyzer.Run();
}
}
}
finally
{
if (removeDirectory)
Directory.Delete(temporaryDirectory, true);
}
}
public static async Task<string> Install(this IPackage package, string source, string dest)
{
IPackageRepository packageRepository = new LocalPackageRepository(source);
IPackageManager packageManager = new PackageManager(packageRepository, dest);
var tcs = new TaskCompletionSource<string>();
var handler = new EventHandler<PackageOperationEventArgs>((sender, args) => tcs.SetResult(args.InstallPath));
packageManager.PackageInstalled += handler;
packageManager.InstallPackage(package, true, true);
packageManager.PackageInstalled -= handler;
if (await Task.WhenAny(tcs.Task, Task.Delay(5000)) == tcs.Task)
{
await tcs.Task;
return tcs.Task.Result;
}
else
{
throw new TimeoutException("Package install timeout");
}
}
/// <summary>
/// Install package
/// </summary>
/// <param name="pkgId"></param>
public static JsonResponse InstallPackage(string pkgId)
{
try
{
var packageManager = new NuGet.PackageManager(
_repository,
new DefaultPackagePathResolver(_feedUrl),
new PhysicalFileSystem(HttpContext.Current.Server.MapPath(Utils.ApplicationRelativeWebRoot + "App_Data/packages"))
);
var package = _repository.FindPackage(pkgId);
packageManager.InstallPackage(package, false);
FileSystem.CopyPackageFiles(package.Id, package.Version.ToString());
// reset cache
Blog.CurrentInstance.Cache.Remove("Installed-Themes");
}
catch (Exception ex)
{
Utils.Log("PackageManager.InstallPackage", ex);
return(new JsonResponse {
Success = false, Message = "Error installing package, see logs for details"
});
}
return(new JsonResponse {
Success = true, Message = "Package successfully installed"
});
}
static void Install(string pkgName, SemanticVersion version)
{
//Initialize the package manager
var packageManager = new PackageManager(Repository, Path);
//Download and unzip the package
packageManager.InstallPackage(pkgName, version);
}
public static void AddPackage(this DotNetProject project, IPackage package, IPackageRepository repository)
{
var packageManager = new PackageManager(repository, project.BaseDirectory);
packageManager.InstallPackage(package, false);
var projectSystem = new ProjectSystemWrapper(project);
var projectManager = new ProjectManager(repository, packageManager.PathResolver, projectSystem, packageManager.LocalRepository);
projectManager.AddPackageReference(package.Id);
project.NeedsReload = true;
}
public void EnsureNamespace(IAgora agora, string nsName, string package) {
if (!agora.GetRegistrations ().Any (reg => reg.Namespace == nsName)) {
//Connect to the official package repository
var repo = PackageRepositoryFactory.Default.CreateRepository(
//"https://packages.nuget.org/api/v2"
"https://www.myget.org/F/castoriadis/"
);
//Initialize the package manager
var entryAssembly = Assembly.GetEntryAssembly ();
var path = entryAssembly == null ? "." : Path.GetDirectoryName(entryAssembly.Location);
path = Path.Combine (path, nsName);
Directory.CreateDirectory (path);
var packageManager = new PackageManager(repo, path);
//Download and unzip the package
packageManager.InstallPackage(package, null, false, true);
// copy all EXEs and DLLs to the root install
var di = new DirectoryInfo (path);
new[]{"*.dll","*.exe"}.SelectMany(ext => di.GetFiles(ext, SearchOption.AllDirectories))
.ToList()
.ForEach(fi => {
var dest = Path.Combine(path, fi.Name);
if (Path.GetFullPath(dest) != fi.FullName) {
if (File.Exists(dest))
File.Delete(dest);
fi.CopyTo(dest);
}
});
// find the EXE
var exeFile = di.GetFiles ("*.exe").First ();
#if __MonoCS__
var module = Assembly.Load("Mono.Posix, Version=4.0.0.0, Culture=neutral, PublicKeyToken=0738eb9f132ed756");
var type = module.GetType("Mono.Unix.Native.Syscall");
var chmodMI = type.GetMethod("chmod");
chmodMI.Invoke(null, new object[]{exeFile.FullName, 4095u});
#endif
using (var proc = Process.Start(exeFile.FullName))
{
if (proc == null) {
// try to determine why...
throw new Exception ("The process coulnd't start.");
}
int waitTimes = 0;
for (var registered = agora.GetRegistrations ().Any (reg => reg.Namespace == nsName); !registered; registered = agora.GetRegistrations ().Any (reg => reg.Namespace == nsName)) {
Thread.Sleep (100);
if (++waitTimes > 50) {
proc.Kill ();
throw new Exception ("Couldn't register on time.");
}
}
}
}
}
public XamForms()
{
var packageUnzipPath = Environment.CurrentDirectory;
var retryPolicy = Policy
.Handle<Exception>()
.WaitAndRetry(
5,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(exception, timeSpan, context) =>
{
Log.Warning(
"An exception was thrown whilst retrieving or installing {packageName}: {exception}",
_packageName, exception);
});
retryPolicy.Execute(() =>
{
var repo = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2");
var packageManager = new PackageManager(repo, packageUnzipPath);
var package = repo.FindPackagesById(_packageName).Single(x => x.IsLatestVersion);
packageManager.InstallPackage(package.Id);
Log.Debug("Using Xamarin Forms {Version} released on {Published}", package.Version, package.Published);
Log.Debug("{ReleaseNotes}", package.ReleaseNotes);
});
var xamarinForms =
Directory.GetFiles(packageUnzipPath,
"Xamarin.Forms.Core.dll", SearchOption.AllDirectories);
var latestVersion = xamarinForms.Last();
Assemblies.Add(latestVersion);
if (PlatformHelper.IsRunningOnMono())
{
CecilSearchDirectories.Add(
@"/Library/Frameworks/Mono.framework/Versions/Current/lib/mono/xbuild-frameworks/.NETPortable/v4.5/Profile/Profile111");
}
else
{
CecilSearchDirectories.Add(@"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETPortable\v4.5\Profile\Profile111");
}
}
internal bool resolve(string packageName, string packageVersion, string remoteRepositoryUrl)
{
var repo = PackageRepositoryFactory.Default.CreateRepository(remoteRepositoryUrl);
var packageManager = new PackageManager(repo, pluginPath);
var package = repo.FindPackage(packageName, SemanticVersion.Parse(packageVersion), true, true);
bool ret;
if (package != null)
{
packageManager.InstallPackage(package, false, true);
ret = true;
}
else { ret = false; }
return ret;
}
private IPackage EnsurePackageInstalled(
IReadOnlyCollection <IPackage> localCacheInstalledPackages, NuGet.PackageManager currentPackageManager,
string packageId, SemanticVersion packageSemanticVersion,
Guid corrId)
{
if (localCacheInstalledPackages.All(p => p.Version != packageSemanticVersion))
{
this.LogPackageOperation(packageId, packageSemanticVersion, "Install in local cache", corrId);
currentPackageManager.InstallPackage(packageId, packageSemanticVersion);
}
else
{
this.LogPackageOperation(packageId, packageSemanticVersion, "Already in cache", corrId);
}
return(currentPackageManager.LocalRepository.FindPackage(packageId, packageSemanticVersion));
}
public void InstallPackage(PackageManager packageManager, Engine engine, bool updatePackages)
{
using (engine.Trace.WithIndent().Verbose("Installing package {0}{1} from {2}",
_packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, packageManager.SourceRepository.Source))
{
// Find the local package
IPackage localPackage = packageManager.LocalRepository.FindPackage(_packageId);
// Check if we're up to date
if (localPackage != null && _versionSpec.Satisfies(localPackage.Version) && !updatePackages)
{
engine.Trace.Verbose("Package {0}{1} is satisfied by version {2}, skipping",
_packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, localPackage.Version);
return;
}
// Find the source package
IPackage sourcePackage = packageManager.SourceRepository
.FindPackage(_packageId, _versionSpec, _allowPrereleaseVersions, _allowUnlisted);
if (sourcePackage == null)
{
engine.Trace.Warning("Package {0} {1} could not be found at {2}",
_packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, packageManager.SourceRepository.Source);
return;
}
// Check if we're up to date
if (localPackage != null && localPackage.Version >= sourcePackage.Version)
{
engine.Trace.Verbose("Package {0}{1} is up to date with version {2}, skipping",
_packageId, _versionSpec == null ? string.Empty : " " + _versionSpec, localPackage.Version);
return;
}
// Uninstall the old package (removing any content files)
if (localPackage != null)
{
packageManager.UninstallPackage(localPackage, true);
engine.Trace.Verbose("Uninstalled package {0} {1}", localPackage.Id, localPackage.Version);
}
// Install it
packageManager.InstallPackage(sourcePackage, false, _allowPrereleaseVersions);
engine.Trace.Verbose("Installed package {0} {1}", sourcePackage.Id, sourcePackage.Version);
}
}
/// <summary>
/// Attempts to download a NuGet package with the specified id and optional version
/// to the specified directory
/// </summary>
public NuGet.IPackage FetchPackage(string packageSource, string packageId, SemanticVersion version, string downloadDirectory)
{
if (string.IsNullOrWhiteSpace(packageSource))
{
throw new ArgumentNullException("url");
}
if (string.IsNullOrWhiteSpace(packageId))
{
throw new ArgumentNullException("packageId");
}
if (string.IsNullOrWhiteSpace(downloadDirectory))
{
throw new ArgumentNullException("downloadDirectory");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
logger.LogDebug(UIResources.NG_CreatingRepository, packageSource);
IPackageRepository repository = PackageRepositoryFactory.Default.CreateRepository(packageSource);
IPackage package = TryGetPackage(repository, packageId, version);
if (package != null)
{
Directory.CreateDirectory(downloadDirectory);
IPackageManager manager = new PackageManager(repository, downloadDirectory);
manager.Logger = new NuGetLoggerAdapter(this.logger);
try
{
manager.InstallPackage(package, false, false, false);
}
catch (InvalidOperationException e)
{
logger.LogError(UIResources.NG_ERROR_PackageInstallFail, e.Message);
return null;
}
}
return package;
}
private void FetchPackages()
{
if (Config.Packages != null)
{
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository("https://packages.nuget.org/api/v2");
PackageManager packageManager = new PackageManager(repo, Config.LibPath);
try
{
foreach (var package in Config.Packages)
{
packageManager.InstallPackage(package.PackageId, SemanticVersion.Parse(package.Version));
}
}
catch (Exception ex)
{
throw new NewProjectException("Could not fetch pacakges",ex);
}
}
}
public void ApproveNServiceBus()
{
var packages = new[]
{
"4.6.4", "5.0.0-beta0004"
};
var nugetCacheDirectory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NuGet", "Cache");
var repo = new AggregateRepository(new[]
{
PackageRepositoryFactory.Default.CreateRepository(nugetCacheDirectory),
PackageRepositoryFactory.Default.CreateRepository("https://www.nuget.org/api/v2"),
PackageRepositoryFactory.Default.CreateRepository("https://www.myget.org/F/particular/"),
});
var packageManager = new PackageManager(repo, "packages");
foreach (var v in packages)
{
if (!Directory.Exists(Path.Combine("packages", "NServiceBus." + v)))
packageManager.InstallPackage("NServiceBus", SemanticVersion.Parse(v));
}
var file1 = Path.Combine("packages", "NServiceBus." + packages[0], "lib", "net40", "NServiceBus.Core.dll");
var file2 = Path.Combine("packages", "NServiceBus." + packages[1], "lib", "net45", "NServiceBus.Core.dll");
var engine = new ComparerEngine();
var diff = engine.CreateDiff(file1, file2);
var stringBuilder = new StringWriter();
var formatter = new APIUpgradeToMarkdownFormatter();
formatter.WriteOut(diff, stringBuilder, new FormattingInfo(string.Empty, string.Empty));
Approvals.Verify(stringBuilder.ToString());
}
public override bool InstallPackage(string packageId, string version)
{
var installableRepository = GetInstallableRepository();
IPackage package;
if (string.IsNullOrEmpty(version))
{
package = installableRepository.FindPackage(packageId);
}
else
{
var semanticVersion = new SemanticVersion(version);
package = installableRepository.FindPackage(packageId, semanticVersion);
}
if (package == null)
{
return false;
}
var packageManager = new PackageManager(installableRepository, InstalledRepository);
packageManager.PackageInstalled += InstallPackage;
packageManager.InstallPackage(package, false, true);
return true;
}
public override bool InstallOrUpdatePackage(string packageId)
{
var installableRepository = GetInstallableRepository();
var installablePackage = installableRepository.FindPackage(packageId);
if (installablePackage == null)
{
return false;
}
var installedRepository = GetInstalledRepository();
var installedPackages = installedRepository.GetPackages().ToList();
var packageManager = new PackageManager(installableRepository, InstalledRepository);
packageManager.PackageInstalled += InstallPackage;
var installedPackage = installedPackages.FirstOrDefault(i => string.Equals(i.Id, packageId, StringComparison.OrdinalIgnoreCase));
if (installedPackage != null)
{
if (installedPackage.Version == installablePackage.Version)
{
packageManager.UninstallPackage(installedPackage, true);
packageManager.InstallPackage(installablePackage, false, true);
}
else
{
packageManager.UpdatePackage(installablePackage, false, true);
}
}
else
{
packageManager.InstallPackage(installablePackage, false, true);
}
return true;
}
public override void Execute()
{
var package = Package;
var packageManager = new PackageManager(PackageRepository, OutputDirectory);
packageManager.InstallPackage(package, IgnoreDependencies, AllowPrereleaseVersions);
}
/// <summary>
/// Attempts to download a NuGet package with the specified id and optional version
/// to the specified directory
/// </summary>
public IPackage FetchPackage(string packageId, SemanticVersion version, string localNuGetPath)
{
if (string.IsNullOrWhiteSpace(packageId))
{
throw new ArgumentNullException("packageId");
}
if (string.IsNullOrWhiteSpace(localNuGetPath))
{
throw new ArgumentNullException("localNuGetPath");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
logger.LogDebug(UIResources.NG_CreatingRepository, this.packageSource);
IPackageRepository repository = PackageRepositoryFactory.Default.CreateRepository(packageSource);
IPackage package = TryGetPackage(repository, packageId, version);
if (package != null)
{
Directory.CreateDirectory(localNuGetPath);
IPackageManager manager = new PackageManager(repository, localNuGetPath);
manager.Logger = new NuGetLoggerAdapter(this.logger);
try
{
// Prerelease packages enabled by default
manager.InstallPackage(package, false, true, false);
}
catch (InvalidOperationException e)
{
logger.LogError(UIResources.NG_ERROR_PackageInstallFail, e.Message);
return null;
}
}
return package;
}
/// <summary>
/// Executes the job
/// </summary>
/// <param name="targetInstanceId">
/// The target instance id.
/// </param>
public override void Execute(Guid targetInstanceId)
{
this.InitializePackages();
var packageRequestService = new SolutionPackageRequestService();
var packageRequests = new List<SolutionPackageRequest>();
foreach (var packageInfo in this.Packages)
{
packageRequests.AddRange(packageRequestService.EnumPackageRequests(packageInfo.Id, new VersionSpec(SemanticVersion.Parse(packageInfo.Version))));
}
var path = Path.Combine(Environment.ExpandEnvironmentVariables("%TMP%\\SharePoint.PackageManager"), targetInstanceId.ToString());
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var solutions = SPFarm.Local.Solutions.ToList();
var solutionPackageRequests = packageRequests.Distinct().SortByDependencies().ToList();
var i = 0;
var count = solutionPackageRequests.Count;
foreach (var packageRequest in solutionPackageRequests)
{
var package = packageRequest.Package;
var solution = solutions.Find(s => s.Name.ToLower().Equals(package.Id.ToLower()));
if (solution == null || solution.GetVersion().CompareTo(package.Version) != 0)
{
var packageManager = new PackageManager(packageRequest.Repository, path);
packageManager.InstallPackage(package, true, true);
var solutionFile = Path.Combine(Path.Combine(Path.Combine(path, package.GetFullName().Replace(" ", ".")), "content"), package.Id);
if (File.Exists(solutionFile))
{
if (solution != null)
{
solution.Upgrade(solutionFile);
}
else
{
solution = SPFarm.Local.Solutions.Add(solutionFile);
}
solution.SetVersion(package.Version);
}
}
this.UpdateProgress(Convert.ToInt32(++i / (count * 1.0d) * 100));
}
}
/// <summary>The initialize.</summary>
internal static void Initialize()
{
// Already initialized
if (packageVersion != null)
{
return;
}
DeleteOldPackages();
tempPackagesFolder = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
string installedPackages = Path.Combine(tempPackagesFolder, "Installed");
string packagesFolder = Path.Combine(tempPackagesFolder, "Packages");
Directory.CreateDirectory(installedPackages);
Directory.CreateDirectory(packagesFolder);
// Analyze StatusMonitor.nuget and find the dependency.
string nugetFolder = Path.GetDirectoryName(ExecutionEnvironment.StatusMonitorNugetPath);
IPackageRepository statusMonitorNugetRepo = PackageRepositoryFactory.Default.CreateRepository(nugetFolder);
IPackage package;
try
{
package = statusMonitorNugetRepo.FindPackage(StatusMonitorNugetId, (IVersionSpec)null, true, true);
}
catch (Exception ex)
{
throw new Exception(
string.Format(
"Could not find package '{0}' in '{1}': {2}",
StatusMonitorNugetId,
nugetFolder,
ex.Message),
ex);
}
PackageDependency dependency;
try
{
PackageDependencySet dependencySet = package.DependencySets.Single();
dependency = dependencySet.Dependencies.Single();
}
catch (Exception ex)
{
throw new Exception(string.Format("Dependency.Single threw an exception: '{0}'", ex.Message), ex);
}
// Copy to .\Packages folder
string statusMonitorNugetPath = ExecutionEnvironment.StatusMonitorNugetPath;
string nugetFileName = Path.GetFileName(statusMonitorNugetPath);
Debug.Assert(nugetFileName != null, "nugetFileName is null");
string outputPath = Path.Combine(packagesFolder, nugetFileName);
File.Copy(statusMonitorNugetPath, outputPath, true);
// Install all nugets which our StatusMonitor.nuget depends on. Download them from our own private nuget server
IPackageRepository packagesRepo =
PackageRepositoryFactory.Default.CreateRepository(NugetServerWithAllPackages);
var manager = new PackageManager(
packagesRepo,
new DefaultPackagePathResolver(installedPackages),
new PhysicalFileSystem(installedPackages));
try
{
manager.InstallPackage(dependency.Id, dependency.VersionSpec.MinVersion, false, true);
}
catch (Exception ex)
{
throw new Exception(
string.Format(
"Could not install package: '{0}', '{1}' from '{2}': {3}",
dependency.Id,
dependency.VersionSpec.MinVersion,
NugetServerWithAllPackages,
ex.Message),
ex);
}
// Copy all *.nupkg files to .\Packages folder
foreach (string newPath in Directory.GetFiles(installedPackages, "*.nupkg", SearchOption.AllDirectories))
{
string fileName = Path.GetFileName(newPath);
Debug.Assert(fileName != null, "fileName is null");
string output = Path.Combine(packagesFolder, fileName);
File.Copy(newPath, output, true);
}
// Now let StatusMonitor to download these packages
string arguments = string.Format(
"/c {0} download \"{1}\" \"{2}\"",
ExecutionEnvironment.StatusMonitorLauncherPath,
StatusMonitorInstallPath,
packagesFolder);
ProcessHelper.ExecuteProcess("cmd.exe", arguments, TimeSpan.FromMinutes(1));
// Get downloaded version
packageVersion = GetPackageVersion();
}
/// <summary>
/// </summary>
private int Run(Assembly integrationAgentAssembly, string integrationAgentExeFileName, string integrationAgentExeDirectory, string[] args)
{
var parameters = Program.ParseArguments(args);
var fileVersion = FileVersionInfo.GetVersionInfo(integrationAgentAssembly.Location).FileVersion;
if (parameters.ShowVersion || parameters.ShowHelp)
{
Console.WriteLine("IntegrationAgent v" + fileVersion);
}
if (parameters.ShowHelp)
{
Program.ShowHelp();
}
if (parameters.ShowVersion || parameters.ShowHelp)
{
return 0;
}
// Verify that assembly is signed and uses the correct key
var traceWriter = Program.CreateTraceWriter(parameters.TraceLevel);
traceWriter(TraceLevel.Verbose, "Checking assembly strong name.");
if (!integrationAgentAssembly.HasValidStrongName())
{
traceWriter(TraceLevel.Error, "Unsigned assembly!");
return 1;
}
traceWriter(TraceLevel.Verbose, "Verifying assembly signature.");
if (!integrationAgentAssembly.PublicKeyTokenEqualsTo(Token.Bytes))
{
traceWriter(TraceLevel.Error, "Invalid assembly!");
return 2;
}
// If no JSON config file name provided as paramter uses the application name
traceWriter(TraceLevel.Verbose, "Looking for JSON config file.");
var configFile = Path.Combine(integrationAgentExeDirectory, Path.GetFileNameWithoutExtension(integrationAgentExeFileName) + ".json");
if (!string.IsNullOrEmpty(parameters.Config))
{
if (!parameters.Config.EndsWith(".json"))
{
parameters.Config = parameters.Config + ".json";
}
configFile = Path.Combine(integrationAgentExeDirectory, parameters.Config);
}
// Check and reads the configuration file
var configuration = new Configuration();
if (File.Exists(configFile))
{
traceWriter(TraceLevel.Verbose, "Reading the JSON config file.");
var configJson = File.ReadAllText(configFile);
var jsonSerializer = new JavaScriptSerializer();
configuration = jsonSerializer.Deserialize<Configuration>(configJson) ?? configuration;
traceWriter(TraceLevel.Verbose, "JSON config file loaded.");
}
// Merges config file and command line parameters. Command line paramters have precedence.
configuration.package = parameters.Package ?? configuration.package;
configuration.token = parameters.Token ?? configuration.token;
configuration.repository = parameters.Repository ?? configuration.repository;
configuration.repositoryUsername = parameters.RepositoryUsername ?? configuration.repositoryUsername;
configuration.repositoryPassword = parameters.RepositoryPassword ?? configuration.repositoryPassword;
traceWriter(TraceLevel.Verbose, "Checking input parameters.");
if (string.IsNullOrWhiteSpace(configuration.package) && string.IsNullOrEmpty(configuration.token))
{
traceWriter(TraceLevel.Error, "Invalid configuration!");
return 3;
}
// Initializes NuGet repositories
traceWriter(TraceLevel.Verbose, "Initializing NuGet repositories.");
var nugetRepository = new DataServicePackageRepository(new Uri(NuGetRepository));
var aggregateRepository = new AggregateRepository(new[] { nugetRepository });
if (Uri.IsWellFormedUriString(configuration.repository, UriKind.Absolute))
{
if (!string.IsNullOrWhiteSpace(configuration.repositoryUsername) &&
!string.IsNullOrWhiteSpace(configuration.repositoryPassword))
{
HttpClient.DefaultCredentialProvider = new NugetCredentialProvider(
configuration.repositoryUsername, configuration.repositoryPassword);
}
var client = new HttpClient(new Uri(configuration.repository));
var customRepository = new DataServicePackageRepository(client);
aggregateRepository = new AggregateRepository(new[] { customRepository, nugetRepository });
}
// Perform auto-update if not disabled
if (!parameters.DisableUpdates)
{
traceWriter(TraceLevel.Verbose, "Checking for self update.");
var integrationAgentAssemblyName = integrationAgentAssembly.GetName();
var version = new SemanticVersion(integrationAgentAssemblyName.Version);
var package = aggregateRepository
.GetUpdates(new[] { new PackageName(integrationAgentAssemblyName.Name, version) }, includePrerelease: false, includeAllVersions: false)
.OrderBy(p => p.Version)
.LastOrDefault();
if (package != null && package.Version > version)
{
traceWriter(TraceLevel.Verbose, "Newer version found. Updating files.");
var filename = Path.GetFileName(integrationAgentExeFileName);
var file = package.GetFiles().FirstOrDefault(f => !string.IsNullOrEmpty(f.Path) && Path.GetFileName(f.Path).Equals(filename, StringComparison.OrdinalIgnoreCase));
if (file != null)
{
File.Delete(integrationAgentExeFileName + ".bak");
File.Move(integrationAgentExeFileName, integrationAgentExeFileName + ".bak");
using (Stream fromStream = file.GetStream(), toStream = File.Create(integrationAgentExeFileName))
{
fromStream.CopyTo(toStream);
}
Process.Start(integrationAgentExeFileName, string.Join(" ", args) + " -disableupdates");
Environment.Exit(0);
}
}
else
{
traceWriter(TraceLevel.Verbose, "Version is up to date.");
}
}
// Install the package to run including its dependencies
traceWriter(TraceLevel.Verbose, "Checking for execution package.");
var packagesPath = Path.Combine(integrationAgentExeDirectory, "packages");
var remotePackage = aggregateRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault();
var localRepository = new SharedPackageRepository(packagesPath);
if (!localRepository.Exists(remotePackage))
{
traceWriter(TraceLevel.Verbose, "Execution package not found localy. Installing remote.");
var packageManager = new PackageManager(aggregateRepository, packagesPath);
packageManager.InstallPackage(remotePackage, ignoreDependencies: false, allowPrereleaseVersions: false);
}
var localPackage = localRepository.FindPackagesById(configuration.package).OrderBy(p => p.Version).LastOrDefault();
if (localPackage == null)
{
traceWriter(TraceLevel.Error, "Package not found!");
return 4;
}
// Build a dictionary list of assemblies based on assembly fully qualified name for dynamically resolving from the loaded package
traceWriter(TraceLevel.Verbose, "Resolving execution package dependencies.");
var allAssemblies = localRepository
.GetPackages()
.ToArray()
.SelectMany(p => p.AssemblyReferences.Select(a =>
{
var path = Path.Combine(packagesPath, p.Id + "." + p.Version, a.Path);
var aname = AssemblyName.GetAssemblyName(path);
return new { key = aname.FullName, value = path };
}))
.DistinctBy(i => i.key)
.ToDictionary(i => i.key, i => i.value);
AppDomain.CurrentDomain.AssemblyResolve += (sender, eventArgs) =>
{
var aname = new AssemblyName(eventArgs.Name);
if (allAssemblies.ContainsKey(aname.FullName))
{
return Assembly.LoadFile(allAssemblies[aname.FullName]);
}
return null;
};
// Run the package export delegate if found
var assemblies = localPackage.AssemblyReferences.Select(a => new AssemblyCatalog(Path.Combine(packagesPath, localPackage.Id + "." + localPackage.Version, a.Path)));
using (var catalog = new AggregateCatalog(assemblies))
using (var container = new CompositionContainer(catalog))
{
traceWriter(TraceLevel.Verbose, "Resolving execution package entry point.");
container.SatisfyImportsOnce(this);
if (this.RunAssembly == null)
{
traceWriter(TraceLevel.Error, "Execution package extry point not found!");
return 5;
}
traceWriter(TraceLevel.Verbose, "Invoking execution package extry point.");
this.RunAssembly(configuration.token, traceWriter);
traceWriter(TraceLevel.Verbose, "Execution package finished successfully.");
return 0;
}
}
public override void Execute()
{
var package = Package;
var packageRepositories = _moduleCatalog.GetAllPackageRepositories(true).ToList();
var versionSpec = new VersionSpec
{
IsMinInclusive = true,
MinVersion = package.Version,
IsMaxInclusive = true,
MaxVersion = package.Version
};
var packagesToDownload = ResolveDependencies(package.Id, versionSpec, packageRepositories);
foreach (var packageToDownload in packagesToDownload)
{
Log.Debug("Installing package '{0}' from source '{1}'", packageToDownload.Package.Id, packageToDownload.PackageRepository.Source);
var packageManager = new PackageManager(packageToDownload.PackageRepository, OutputDirectory);
lock (_syncObj)
{
packageManager.InstallPackage(packageToDownload.Package, IgnoreDependencies, AllowPrereleaseVersions);
}
}
}
public ProjectRootElement Run(string project)
{
var source = lua [project + ".source"] as string;
if (source == null) source = "src";
var resources = lua [project + ".resources"] as string;
if (resources == null) resources = "res";
var root = ProjectRootElement.Create ();
root.AddImport ("$(MSBuildBinPath)\\Microsoft.CSharp.targets");
var properties = root.AddPropertyGroup ();
properties.AddProperty ("AssemblyName", lua.GetOptional(project + ".name", "project") as string);
properties.AddProperty ("ProductVersion", lua.GetOptional(project + ".version", "1.0.0") as string);
properties.AddProperty ("ProjectGuid", "{" + System.Guid.NewGuid ().ToString () + "}");
properties.AddProperty ("SchemaVersion", "2.0");
var luaproperties = lua[project + ".configuration"] as LuaTable;
if (luaproperties.Keys.Count > 0) {
foreach (string key in luaproperties.Keys) {
var val = luaproperties[key];
if (val is string) properties.AddProperty(key.ToFirstUpper(), val as string);
}
}
Logger.Default.Log(":", false, MainClass.COLOR).Log (project + ".dependencies");
PackageManager packages;
var packagedir = Path.Combine (MainClass.HOME, "packages");
try {
new WebClient().OpenRead("http://packages.nuget.org/api/v2");
packages = new PackageManager(PackageRepositoryFactory.Default.CreateRepository("http://packages.nuget.org/api/v2"), packagedir);
} catch (WebException e) {
packages = new PackageManager(PackageRepositoryFactory.Default.CreateRepository(packagedir), packagedir);
}
packages.PackageInstalled += delegate(object sender, PackageOperationEventArgs arg) {
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine (" [DONE]");
Console.ResetColor();
};
packages.PackageInstalling += delegate(object sender, PackageOperationEventArgs arg) {
Console.Write ("Installing " + arg.Package.GetFullName());
};
var references = root.AddItemGroup ();
var dependencies = lua [project + ".dependencies.system"];
if (dependencies != null) {
foreach (string dep in (dependencies as LuaTable).Values) {
references.AddItem("Reference", dep);
}
}
dependencies = lua [project + ".dependencies.nuget"];
if (dependencies != null) {
foreach (string dep in (dependencies as LuaTable).Values) {
IPackage dependency = null;
if (dep.IndexOf (':') > -1) {
var splitdep = dep.Split (':');
packages.InstallPackage (splitdep [0], SemanticVersion.Parse (splitdep [1]));
dependency = packages.LocalRepository.FindPackage (splitdep [0], SemanticVersion.Parse (splitdep [1]));
} else {
packages.InstallPackage (dep);
dependency = packages.LocalRepository.FindPackage (dep);
}
foreach (var reference in dependency.AssemblyReferences) {
foreach (var frmwrk in reference.SupportedFrameworks) {
if (frmwrk.Version == new Version (4, 0)) {
references
.AddItem ("Reference", Path.GetFileNameWithoutExtension (reference.Name))
.AddMetadata ("HintPath", Path.Combine (MainClass.HOME, "packages", dependency.Id + "." + dependency.Version.ToString (), reference.Path));
}
}
}
}
}
dependencies = lua [project + ".dependencies.project"];
if (dependencies != null) {
foreach (string dep in (dependencies as LuaTable).Values) {
var projPath = lua[dep + ".configuration.outputPath"];
if (projPath == null) continue;
var projName = lua[dep + ".name"];
if (projName == null) continue;
var projType = lua[dep + ".configuration.outputType"];
if (projType != null && (projType as string).ToLower() == "exe") continue;
Task.Call(dep + ".build");
references
.AddItem("Reference", dep)
.AddMetadata ("HintPath", Path.Combine (MainClass.CURRENT, dep, projPath as string, (projName as string) + ".dll"));
}
}
if (Directory.Exists (source)) {
var compile = root.AddItemGroup ();
foreach (var file in Directory.GetFiles (source, "*.cs", SearchOption.AllDirectories)) {
compile.AddItem ("Compile", Path.Combine(MainClass.CURRENT, file));
}
}
if (Directory.Exists (resources)) {
var none = root.AddItemGroup ();
foreach (var file in Directory.GetFiles (Path.Combine(MainClass.CURRENT, source), "*", SearchOption.AllDirectories)) {
none.AddItem ("None", file).AddMetadata ("CopyToOutputDirectory", "PreserveNewest");
}
}
ProjectInstance projectInstance = new ProjectInstance (root);
ConsoleLogger logger = new ConsoleLogger(LoggerVerbosity.Normal);
BuildManager manager = BuildManager.DefaultBuildManager;
var output = manager.Build(
new BuildParameters() { DetailedSummary = true, Loggers = new[] { logger } },
new BuildRequestData(projectInstance, projectInstance.DefaultTargets.ToArray()));
if (output.OverallResult.ToString ().ToLower ().Contains ("failure")) {
MainClass.Fail ("Compilation of project '" + project + "' failed");
}
return root;
}
/// <summary>
/// Executes a package installation.
/// </summary>
/// <param name="package">The package to install.</param>
/// <param name="packageRepository">The repository for the package.</param>
/// <param name="sourceLocation">The source location.</param>
/// <param name="targetPath">The path where to install the package.</param>
/// <returns>The package information.</returns>
protected PackageInfo ExecuteInstall(IPackage package, IPackageRepository packageRepository, string sourceLocation, string targetPath) {
// this logger is used to render NuGet's log on the notifier
var logger = new NugetLogger(_notifier);
bool installed = false;
// if we can access the parent directory, and the solution is inside, NuGet-install the package here
string solutionPath;
var installedPackagesPath = String.Empty;
if (TryGetSolutionPath(targetPath, out solutionPath)) {
installedPackagesPath = Path.Combine(solutionPath, PackagesPath);
try {
var packageManager = new NuGetPackageManager(
packageRepository,
new DefaultPackagePathResolver(sourceLocation),
new PhysicalFileSystem(installedPackagesPath) {Logger = logger}
) {Logger = logger};
packageManager.InstallPackage(package, true);
installed = true;
}
catch {
// installing the package at the solution level failed
}
}
// if the package got installed successfully, use it, otherwise use the previous repository
var sourceRepository = installed
? new LocalPackageRepository(installedPackagesPath)
: packageRepository;
var project = new FileBasedProjectSystem(targetPath) { Logger = logger };
var projectManager = new ProjectManager(
sourceRepository, // source repository for the package to install
new DefaultPackagePathResolver(targetPath),
project,
new ExtensionReferenceRepository(project, sourceRepository, _extensionManager)
) { Logger = logger };
// add the package to the project
projectManager.AddPackageReference(package.Id, package.Version);
return new PackageInfo {
ExtensionName = package.Title ?? package.Id,
ExtensionVersion = package.Version.ToString(),
ExtensionType = package.Id.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme)) ? DefaultExtensionTypes.Theme : DefaultExtensionTypes.Module,
ExtensionPath = targetPath
};
}
public void NuGetRestore(string directory, string packagesDirectory = null)
{
if (!Packages.Any ())
return;
IPackageRepository repo = PackageRepositoryFactory.Default.CreateRepository ("https://packages.nuget.org/api/v2");
PackageManager packageManager = new PackageManager (repo, Path.Combine (Root, "temp", "packages"));
foreach (var package in Packages) {
packageManager.InstallPackage (package.Id, new SemanticVersion (package.Version));
}
}
/// <summary>
/// Try to resolve the requested assembly via Nuget, locally and remote.
/// </summary>
internal Assembly NugetResolveEventHandler(object sender, ResolveEventArgs resolveEventArgs)
{
if (resolveEventArgs.Name.Contains("resources"))
{
return null;
}
var assemblyName = new AssemblyName(resolveEventArgs.Name);
Log.Debug().WriteLine("Trying to resolve {0}", assemblyName.Name);
try
{
var remoteRepository = PackageRepositoryFactory.Default.CreateRepository(RemotePackageSource);
// Create a package manager for managing our local repository
IPackageManager packageManager = new PackageManager(remoteRepository, LocalPackageSource);
var localRepository = packageManager.LocalRepository;
var localPackages = localRepository.FindPackagesById(assemblyName.Name);
var locatedPackage = FindPackage(assemblyName, localPackages);
if (locatedPackage == null)
{
// Search package via NuGet remote
var remotePackages = remoteRepository.FindPackagesById(assemblyName.Name);
locatedPackage = FindPackage(assemblyName, remotePackages);
if (locatedPackage != null)
{
packageManager.InstallPackage(locatedPackage.Id, locatedPackage.Version, true, false);
}
}
return ReturnAssemblyFromRepository(packageManager, assemblyName);
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex, "Problem using NuGet find an unresolved assembly");
}
return null;
}
public int InstallCommand()
{
if (Arguments.Count < 1){
Console.WriteLine ("muget: you must specify a package to install");
return 1;
}
var package = Arguments [0];
var version = Arguments.Count > 1 ? new Version (Arguments [1]) : null;
var pm = new PackageManager (PackageRepository, "packages"){
Logger = new Logger ()
};
pm.InstallPackage (package, version);
return 0;
}
/// <summary>
/// Downloads the specified package and installs it in the configured folder
/// </summary>
/// <param name="info">Pacakge informations</param>
private void DownloadPackage(PackageInfo info, ICollection<string> repositories)
{
Logger.Log(String.Format("Downloading package for {0} version {1} ... ", info.Name, info.Version));
var factory = new PackageRepositoryFactory();
IPackage package;
var globalRepo = new AggregateRepository(factory, repositories, true);
package = globalRepo.FindPackage(info.Name, SemanticVersion.Parse(info.Version), true, true);
if (package == null)
{
throw new InexistentPackageException(string.Format("Unable to find package {0} version {1}", info.Name, info.Version));
}
var manager = new PackageManager(
globalRepo,
new CustomPathResolver() { BasePath = info.InstallationDirectory },
new OverWritingPhysicalFilesystem(info.InstallationDirectory));
manager.InstallPackage(package, false, true);
Logger.Log(String.Format("Package for {0} version {1} downloaded ... ", info.Name, info.Version));
}
/// <summary>
/// Installs the plugin associated with the ID
/// </summary>
/// <param name="ID">The identifier.</param>
/// <returns>Returns true if it is installed successfully, false otherwise</returns>
public bool InstallPlugin(string ID)
{
Contract.Requires<ArgumentNullException>(!string.IsNullOrEmpty(ID), "ID");
string User = HttpContext.Current.Chain(x => x.User).Chain(x => x.Identity).Chain(x => x.Name, "");
Utilities.IO.Log.Get().LogMessage("Plugin {0} is being installed by {1}", MessageType.Debug, ID, User);
Plugin TempPlugin = PluginList.Get(ID);
if (TempPlugin != null)
UninstallPlugin(ID);
foreach (IPackageRepository Repo in PackageRepositories)
{
IPackage Package = Repo.FindPackage(ID);
if (Package != null)
{
new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "/App_Data/packages/" + Package.Id + "." + Package.Version.ToString() + "/lib").Create();
new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "/App_Data/packages/" + Package.Id + "." + Package.Version.ToString() + "/content").Create();
new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory + "/App_Data/packages/" + Package.Id + "." + Package.Version.ToString() + "/tools").Create();
var Manager = new PackageManager(Repo,
new DefaultPackagePathResolver(Repo.Source),
new PhysicalFileSystem(new DirectoryInfo(HttpContext.Current != null ?
HttpContext.Current.Server.MapPath("~/App_Data/packages") :
"./App_Data/packages").FullName));
Manager.InstallPackage(Package, false, true);
PluginList.Add(new Plugin(Package));
Package.DependencySets.ForEach(x => x.Dependencies.ForEach(y => InstallPlugin(y.Id)));
PluginList.Save();
break;
}
}
Utilities.IO.Log.Get().LogMessage("Plugin {0} has been installed by {1}", MessageType.Debug, ID, User);
return true;
}
/// <summary>
/// Executes a package installation.
/// </summary>
/// <param name="package">The package to install.</param>
/// <param name="packageRepository">The repository for the package.</param>
/// <param name="sourceLocation">The source location.</param>
/// <param name="targetPath">The path where to install the package.</param>
/// <returns>The package information.</returns>
protected PackageInfo ExecuteInstall(IPackage package, IPackageRepository packageRepository, string sourceLocation, string targetPath)
{
// this logger is used to render NuGet's log on the notifier
var logger = new NugetLogger(_notifier);
bool installed = false;
// if we can access the parent directory, and the solution is inside, NuGet-install the package here
string solutionPath;
var installedPackagesPath = String.Empty;
if (TryGetSolutionPath(targetPath, out solutionPath))
{
installedPackagesPath = Path.Combine(solutionPath, PackagesPath);
try {
var packageManager = new NuGetPackageManager(
packageRepository,
new DefaultPackagePathResolver(sourceLocation),
new PhysicalFileSystem(installedPackagesPath)
{
Logger = logger
}
)
{
Logger = logger
};
packageManager.InstallPackage(package, true);
installed = true;
}
catch {
// installing the package at the solution level failed
}
}
// if the package got installed successfully, use it, otherwise use the previous repository
var sourceRepository = installed
? new LocalPackageRepository(installedPackagesPath)
: packageRepository;
var project = new FileBasedProjectSystem(targetPath)
{
Logger = logger
};
var projectManager = new ProjectManager(
sourceRepository, // source repository for the package to install
new DefaultPackagePathResolver(targetPath),
project,
new ExtensionReferenceRepository(project, sourceRepository, _extensionManager)
)
{
Logger = logger
};
// add the package to the project
projectManager.AddPackageReference(package.Id, package.Version);
return(new PackageInfo {
ExtensionName = package.Title ?? package.Id,
ExtensionVersion = package.Version.ToString(),
ExtensionType = package.Id.StartsWith(PackagingSourceManager.GetExtensionPrefix(DefaultExtensionTypes.Theme)) ? DefaultExtensionTypes.Theme : DefaultExtensionTypes.Module,
ExtensionPath = targetPath
});
}
public void Register(Robot robot)
{
RememberConfiguredSources(robot);
RememberConfiguredAliases(robot);
RememberConfiguredAutoReset(robot);
robot.Respond(BuildCommand(new[] {List, Package, Source}),
msg => msg.Send(GetRememberedSources(robot).ToArray()));
robot.Respond(BuildCommand(new []{Add, Package, Source, ParamWithNoSpaces}), msg =>
{
var source = msg.Match[4].ToString(CultureInfo.InvariantCulture);
msg.Send(!AddSource(source, robot)
? "I already know about this one."
: "Consider it done.");
});
robot.Respond(BuildCommand(new []{Remove, Package, Source, ParamWithNoSpaces}), msg =>
{
var source = msg.Match[4].ToString(CultureInfo.InvariantCulture);
msg.Send(RemoveSource(source, robot)
? "I'll forget it immediately."
: "It's easy to forget what you never knew.");
});
robot.Respond(BuildCommand(new[] { Update, Package, ParamWithNoSpaces, Restart}, new[] {3}), msg =>
{
//ID of the package to be looked up
var packageId = msg.Match[3].ToString(CultureInfo.InvariantCulture);
string unaliasedPackageId;
var knownAliases = GetRememberedAliases(robot);
if (!knownAliases.TryGetValue(packageId.ToLower(), out unaliasedPackageId))
{
unaliasedPackageId = packageId;
}
msg.Send("Building repositories...");
IPackageRepository repo = BuildPackagesRepository(robot);
//Get the list of all NuGet packages with ID 'EntityFramework'
msg.Send("Finding package...");
List<IPackage> packages = repo.FindPackagesById(unaliasedPackageId).ToList();
IPackage latestPackageVersion;
if (packages.Any())
{
//try to get the "absolute latest version" and fall back to packages.Last() if none are marked as such
latestPackageVersion = packages.Any(p => p.IsAbsoluteLatestVersion)
? packages.First(p => p.IsAbsoluteLatestVersion)
: packages.Last();
msg.Send("Found it! Downloading...");
}
else
{
msg.Send("I couldn't find it...sorry!");
return;
}
//Initialize the package manager
string path = GetPackagesPath();
var packageManager = new PackageManager(repo, path);
//Download and unzip the package
packageManager.InstallPackage(latestPackageVersion, false, true);//TODO: allow these flags to be configurable? allow user to specify version?
msg.Send("Finished downloading...");
if (ShouldAutoResetAfterUpdate(robot) || (msg.Match.Length >= 5 && Regex.IsMatch(msg.Match[4], Restart)))
{
//They submitted the reset parameter or auto-reset is on.
msg.Send("Resetting...please wait.");
robot.Reset();
}
});
robot.Respond(BuildCommand(new []{List, Package, Alias}),
msg => msg.Send(GetRememberedAliases(robot).Select(kvp => string.Format("{0} = {1}", kvp.Key, kvp.Value)).ToArray()));
robot.Respond(BuildCommand(new []{Add, Package, Alias, ParamWithNoSpaces}), msg =>
{
var alias = msg.Match[4].ToString(CultureInfo.InvariantCulture);
AddAlias(alias, robot);
msg.Send("I'll be sure to remember that.");
});
robot.Respond(BuildCommand(new []{Remove, Package, Alias, ParamWithNoSpaces}), msg =>
{
var alias = msg.Match[4].ToString(CultureInfo.InvariantCulture);
RemoveAlias(alias, robot);
msg.Send("As you wish.");
});
}
public virtual void InstallOrUpdatePackage([NotNull] string packageId)
{
var availableRepository = GetAvailableRepository();
var availablePackage = availableRepository.FindPackage(packageId);
if (availablePackage == null)
{
throw new InvalidOperationException("Package not found: " + packageId);
}
var installedRepository = GetInstalledRepository();
var installedPackages = installedRepository.GetPackages().ToList();
var packageManager = new PackageManager(availableRepository, InstalledRepository);
packageManager.PackageInstalled += InstallPackage;
var installedPackage = installedPackages.FirstOrDefault(i => string.Equals(i.Id, packageId, StringComparison.OrdinalIgnoreCase));
if (installedPackage != null)
{
if (installedPackage.Version == availablePackage.Version)
{
packageManager.UninstallPackage(installedPackage, true);
packageManager.InstallPackage(availablePackage, false, true);
}
else
{
packageManager.UpdatePackage(availablePackage, false, true);
}
}
else
{
packageManager.InstallPackage(availablePackage, false, true);
}
}
public virtual void InstallPackage([NotNull] string packageId, [CanBeNull] SemanticVersion version)
{
var availableRepository = GetAvailableRepository();
var package = version == null ? availableRepository.FindPackage(packageId) : availableRepository.FindPackage(packageId, version);
if (package == null)
{
throw new InvalidOperationException("Package not found: " + packageId);
}
var packageManager = new PackageManager(availableRepository, InstalledRepository);
packageManager.PackageInstalled += InstallPackage;
packageManager.InstallPackage(package, false, true);
}
/// <summary>
/// Downloads a package to local folder and see if the download is successful. Used to individual tests which extend the download scenarios.
/// </summary>
/// <param name="packageId"></param>
/// <param name="version"></param>
public static void DownloadPackageAndVerify(string packageId, string version = "1.0.0")
{
ClientSDKHelper.ClearMachineCache();
ClientSDKHelper.ClearLocalPackageFolder(packageId);
var packageRepository = PackageRepositoryFactory.Default.CreateRepository(UrlHelper.V2FeedRootUrl);
var packageManager = new PackageManager(packageRepository, Environment.CurrentDirectory);
packageManager.InstallPackage(packageId, new SemanticVersion(version));
Assert.IsTrue(ClientSDKHelper.CheckIfPackageVersionInstalled(packageId, version),
"Package install failed. Either the file is not present on disk or it is corrupted. Check logs for details");
}
/// <summary>
/// Fetch, if not already downloaded, and install the package represented by
/// (<paramref name="packageId"/>, <paramref name="version"/>).
/// </summary>
/// <remarks>It is safe to call it concurrently be cause we operations are done using the FileLock.</remarks>
/// <param name="packageId">Name of package to install.</param>
/// <param name="version">Version of package to install.</param>
/// <param name="progress">Callbacks to report progress of downloads.</param>
public async Task InstallPackage(string packageId, PackageVersion version, ProgressReport progress)
{
using (GetLocalRepositoryLock())
{
currentProgressReport = progress;
try
{
var package = manager.LocalRepository.FindPackage(packageId, version.ToSemanticVersion(), null, allowPrereleaseVersions: true, allowUnlisted: true);
if (package == null)
{
// Let's search in our cache
try
{
package = MachineCache.Default.FindPackage(packageId, version.ToSemanticVersion(), allowPrereleaseVersions: true, allowUnlisted: true);
}
catch (InvalidDataException)
{
// Package is somehow corrupted. We ignore this and will redownload the file.
}
// It represents the name of the .nupkg in our cache
var sourceName = Path.Combine(CacheDirectory, PathResolver.GetPackageFileName(packageId, version.ToSemanticVersion()));
if (package == null)
{
// Always recreate cache in case it was deleted.
if (!Directory.Exists(CacheDirectory))
{
Directory.CreateDirectory(CacheDirectory);
}
package = manager.SourceRepository.FindPackage(packageId, version.ToSemanticVersion(), NullConstraintProvider.Instance, allowPrereleaseVersions: true, allowUnlisted: true);
if (package == null)
{
throw new ApplicationException("Cannot find package");
}
// Package has to be downloaded if it is a DataServicePackage which was not found in our cache.
if (package is DataServicePackage)
{
var downloadPackage = (DataServicePackage)package;
var url = downloadPackage.DownloadUrl;
var client = new WebClient();
var tcs = new TaskCompletionSource <bool>();
progress?.UpdateProgress(ProgressAction.Download, 0);
client.DownloadProgressChanged += (o, e) => progress?.UpdateProgress(ProgressAction.Download, e.ProgressPercentage);
client.DownloadFileCompleted += (o, e) => tcs.SetResult(true);
client.DownloadFileAsync(url, sourceName);
await tcs.Task;
progress?.UpdateProgress(ProgressAction.Download, 100);
}
}
progress?.UpdateProgress(ProgressAction.Install, -1);
manager.InstallPackage(package, ignoreDependencies: false, allowPrereleaseVersions: true);
OptimizedZipPackage.PurgeCache();
}
// Every time a new package is installed, we are updating the common targets
UpdateTargetsHelper();
}
finally
{
currentProgressReport = null;
}
}
}
