/// <summary> /// Initializes a new instance of the <see cref="PackageStore"/> class. /// </summary> /// <exception cref="System.InvalidOperationException">Unable to find a valid Xenko installation path</exception> private PackageStore(string installationPath = null, string defaultPackageName = "Xenko", string defaultPackageVersion = XenkoVersion.CurrentAsText) { // TODO: these are currently hardcoded to Xenko DefaultPackageName = defaultPackageName; DefaultPackageVersion = new PackageVersion(defaultPackageVersion); defaultPackageDirectory = DirectoryHelper.GetPackageDirectory(defaultPackageName); // 1. Try to use the specified installation path if (installationPath != null) { if (!DirectoryHelper.IsInstallationDirectory(installationPath)) { throw new ArgumentException("Invalid Xenko installation path [{0}]".ToFormat(installationPath), "installationPath"); } globalInstallationPath = installationPath; } // 2. Try to resolve an installation path from the path of this assembly // We need to be able to use the package manager from an official Xenko install as well as from a developer folder if (globalInstallationPath == null) { globalInstallationPath = DirectoryHelper.GetInstallationDirectory(DefaultPackageName); } // If there is no root, this is an error if (globalInstallationPath == null) { throw new InvalidOperationException("Unable to find a valid Xenko installation or dev path"); } // Preload default package var logger = new LoggerResult(); var defaultPackageFile = DirectoryHelper.GetPackageFile(defaultPackageDirectory, DefaultPackageName); defaultPackage = Package.Load(logger, defaultPackageFile, GetDefaultPackageLoadParameters()); if (defaultPackage == null) { throw new InvalidOperationException("Error while loading default package from [{0}]: {1}".ToFormat(defaultPackageFile, logger.ToText())); } defaultPackage.IsSystem = true; // A flag variable just to know if it is a bare bone development directory isDev = defaultPackageDirectory != null && DirectoryHelper.IsRootDevDirectory(defaultPackageDirectory); // Check if we are in a root directory with store/packages facilities if (NugetStore.IsStoreDirectory(globalInstallationPath)) { packagesDirectory = UPath.Combine(globalInstallationPath, (UDirectory)NugetStore.DefaultGamePackagesDirectory); store = new NugetStore(globalInstallationPath); } else { // We should exit from here if NuGet is not configured. MessageBox.Show($"Unexpected installation. Cannot find a proper NuGet configuration for [{defaultPackageName}] in [{globalInstallationPath}]", "Installation Error", MessageBoxButtons.OK, MessageBoxIcon.Error); Environment.Exit(1); } }
/// <summary> /// Gets the paradox SDK dir. /// </summary> /// <param name="paradoxVersion">The paradox version. If null, it will get latest version.</param> /// <returns></returns> public static string FindParadoxSdkDir(string paradoxVersion = null) { // TODO: Almost duplicate of ParadoxCommandsProxy.FindParadoxSdkDir!! // TODO: Maybe move it in some common class somewhere? (in this case it would be included with "Add as link" in VSPackage) var paradoxSdkDir = DirectoryHelper.GetInstallationDirectory("Paradox"); if (paradoxSdkDir == null) { paradoxSdkDir = Environment.GetEnvironmentVariable("SiliconStudioParadoxDir"); } if (paradoxSdkDir == null) { return null; } // Check if it is a dev directory if (File.Exists(Path.Combine(paradoxSdkDir, "build\\Paradox.sln"))) return paradoxSdkDir; // Check if we are in a root directory with store/packages facilities if (NugetStore.IsStoreDirectory(paradoxSdkDir)) { var store = new NugetStore(paradoxSdkDir); var paradoxPackages = store.GetPackagesInstalled(store.MainPackageId); var paradoxPackage = paradoxVersion != null ? (paradoxPackages.FirstOrDefault(p => p.Version.ToString() == paradoxVersion) ?? paradoxPackages.FirstOrDefault(p => VersionWithoutSpecialPart(p.Version.ToString()) == VersionWithoutSpecialPart(paradoxVersion))) // If no exact match, try a second time without the special version tag (beta, alpha, etc...) : paradoxPackages.FirstOrDefault(); if (paradoxPackage == null) return null; var packageDirectory = store.PathResolver.GetPackageDirectory(paradoxPackage); return Path.Combine(paradoxSdkDir, store.RepositoryPath, packageDirectory); } return null; }
/// <summary> /// Gets the paradox SDK dir. /// </summary> /// <returns></returns> private static string FindParadoxSdkDir() { // TODO: Get the Paradox SDK from the current selected package // TODO: Maybe move it in some common class somewhere? (in this case it would be included with "Add as link" in VSPackage) var paradoxSdkDir = Environment.GetEnvironmentVariable("SiliconStudioParadoxDir"); if (paradoxSdkDir == null) { return null; } // Check if it is a dev directory if (File.Exists(Path.Combine(paradoxSdkDir, "build\\Paradox.sln"))) return paradoxSdkDir; // Check if we are in a root directory with store/packages facilities if (NugetStore.IsStoreDirectory(paradoxSdkDir)) { var store = new NugetStore(paradoxSdkDir); var paradoxPackage = store.GetLatestPackageInstalled(store.MainPackageId); if (paradoxPackage == null) return null; var packageDirectory = store.PathResolver.GetPackageDirectory(paradoxPackage); return Path.Combine(paradoxSdkDir, store.RepositoryPath, packageDirectory); } return null; }
private static bool TryLoadAssets(PackageSession session, ILogger log, Package package, PackageLoadParameters loadParameters) { // Already loaded if (package.State >= PackageState.AssetsReady) { return(true); } // Dependencies could not properly be loaded if (package.State < PackageState.DependenciesReady) { return(false); } // A package upgrade has previously been tried and denied, so let's keep the package in this state if (package.State == PackageState.UpgradeFailed) { return(false); } try { // First, check that dependencies have their assets loaded bool dependencyError = false; foreach (var dependency in package.FindDependencies(false, false)) { if (!TryLoadAssets(session, log, dependency, loadParameters)) { dependencyError = true; } } if (dependencyError) { return(false); } var pendingPackageUpgrades = new List <PendingPackageUpgrade>(); // Note: Default state is upgrade failed (for early exit on error/exceptions) // We will update to success as soon as loading is finished. package.State = PackageState.UpgradeFailed; // Process store dependencies for upgraders foreach (var packageDependency in package.Meta.Dependencies) { var dependencyPackage = session.Packages.Find(packageDependency); if (dependencyPackage == null) { continue; } // Check for upgraders var packageUpgrader = session.CheckPackageUpgrade(log, package, packageDependency, dependencyPackage); if (packageUpgrader != null) { pendingPackageUpgrades.Add(new PendingPackageUpgrade(packageUpgrader, packageDependency, dependencyPackage)); } } // Load list of assets var assetFiles = Package.ListAssetFiles(log, package, loadParameters.CancelToken); if (pendingPackageUpgrades.Count > 0) { var upgradeAllowed = true; // Need upgrades, let's ask user confirmation if (loadParameters.PackageUpgradeRequested != null) { upgradeAllowed = loadParameters.PackageUpgradeRequested(package, pendingPackageUpgrades); } if (!upgradeAllowed) { log.Error("Necessary package migration for [{0}] has not been allowed", package.Meta.Name); return(false); } // Perform upgrades foreach (var pendingPackageUpgrade in pendingPackageUpgrades) { var packageUpgrader = pendingPackageUpgrade.PackageUpgrader; var dependencyPackage = pendingPackageUpgrade.DependencyPackage; if (!packageUpgrader.Upgrade(session, log, package, pendingPackageUpgrade.Dependency, dependencyPackage, assetFiles)) { log.Error("Error while upgrading package [{0}] for [{1}] from version [{2}] to [{3}]", package.Meta.Name, dependencyPackage.Meta.Name, pendingPackageUpgrade.Dependency.Version, dependencyPackage.Meta.Version); return(false); } // Update dependency to reflect new requirement pendingPackageUpgrade.Dependency.Version = pendingPackageUpgrade.PackageUpgrader.Attribute.PackageUpdatedVersionRange; } // Mark package as dirty package.IsDirty = true; } // Process the package for assets var newLoadParameters = loadParameters.Clone(); newLoadParameters.AssetFiles = assetFiles; newLoadParameters.AssemblyContainer = session.assemblyContainer; // Default package version override newLoadParameters.ExtraCompileProperties = new Dictionary <string, string>(); var defaultPackageOverride = NugetStore.GetPackageVersionVariable(PackageStore.Instance.DefaultPackageName) + "Override"; var defaultPackageVersion = PackageStore.Instance.DefaultPackageVersion.Version; newLoadParameters.ExtraCompileProperties.Add(defaultPackageOverride, new Version(defaultPackageVersion.Major, defaultPackageVersion.Minor).ToString()); if (loadParameters.ExtraCompileProperties != null) { foreach (var property in loadParameters.ExtraCompileProperties) { newLoadParameters.ExtraCompileProperties[property.Key] = property.Value; } } // Load assemblies and assets package.LoadAssembliesAndAssets(log, newLoadParameters); // Validate assets from package package.ValidateAssets(newLoadParameters.GenerateNewAssetIds); // Mark package as ready package.State = PackageState.AssetsReady; // Freeze the package after loading the assets session.FreezePackage(package); return(true); } catch (Exception ex) { log.Error("Error while loading package [{0}]", ex, package); return(false); } }
/// <summary> /// Gets the paradox SDK dir. /// </summary> /// <returns></returns> private static PackageInfo FindParadoxSdkDir() { // Resolve the sdk version to load from the solution's package var packageInfo = new PackageInfo { ExpectedVersion = PackageSessionHelper.GetPackageVersion(solution) }; // TODO: Maybe move it in some common class somewhere? (in this case it would be included with "Add as link" in VSPackage) var paradoxSdkDir = Environment.GetEnvironmentVariable("SiliconStudioParadoxDir"); // Failed to locate paradox if (paradoxSdkDir == null) return packageInfo; // If we are in a dev directory, assume we have the right version if (File.Exists(Path.Combine(paradoxSdkDir, "build\\Paradox.sln"))) { packageInfo.SdkPath = paradoxSdkDir; packageInfo.LoadedVersion = packageInfo.ExpectedVersion; return packageInfo; } // Check if we are in a root directory with store/packages facilities if (NugetStore.IsStoreDirectory(paradoxSdkDir)) { var store = new NugetStore(paradoxSdkDir); IPackage paradoxPackage = null; // Try to find the package with the expected version if (packageInfo.ExpectedVersion != null && packageInfo.ExpectedVersion >= MinimumVersion) paradoxPackage = store.GetPackagesInstalled(store.MainPackageId).FirstOrDefault(package => GetVersion(package) == packageInfo.ExpectedVersion); // If the expected version is not found, get the latest package if (paradoxPackage == null) paradoxPackage = store.GetLatestPackageInstalled(store.MainPackageId); // If no package was found, return no sdk path if (paradoxPackage == null) return packageInfo; // Return the loaded version and the sdk path var packageDirectory = store.PathResolver.GetPackageDirectory(paradoxPackage); packageInfo.LoadedVersion = GetVersion(paradoxPackage); packageInfo.SdkPath = Path.Combine(paradoxSdkDir, store.RepositoryPath, packageDirectory); } return packageInfo; }
/// <summary> /// Initializes a new instance of the <see cref="PackageStore"/> class. /// </summary> /// <exception cref="System.InvalidOperationException">Unable to find a valid Paradox installation path</exception> private PackageStore(string installationPath = null, string defaultPackageName = "Paradox", string defaultPackageVersion = ParadoxVersion.CurrentAsText) { // 1. Try to use the specified installation path if (installationPath != null) { if (!IsRootDirectory(installationPath)) { throw new ArgumentException("Invalid Paradox installation path [{0}]".ToFormat(installationPath), "installationPath"); } globalInstallationPath = installationPath; } // TODO: these are currently hardcoded to Paradox DefaultPackageName = defaultPackageName; DefaultPackageVersion = new PackageVersion(defaultPackageVersion); // 2. Try to resolve an installation path from the path of this assembly // We need to be able to use the package manager from an official Paradox install as well as from a developer folder // Try to determine the root package manager from the current assembly var thisAssemblyLocation = typeof(PackageStore).Assembly.Location; var binDirectory = !string.IsNullOrWhiteSpace(thisAssemblyLocation) ? new FileInfo(thisAssemblyLocation).Directory : null; if (binDirectory != null && binDirectory.Parent != null && binDirectory.Parent.Parent != null) { var defaultPackageDirectoryTemp = binDirectory.Parent.Parent; // If we have a root directory, then store it as the default package directory if (IsPackageDirectory(defaultPackageDirectoryTemp.FullName, DefaultPackageName)) { defaultPackageDirectory = defaultPackageDirectoryTemp.FullName; } else { throw new InvalidOperationException("The current assembly [{0}] is not part of the package [{1}]".ToFormat(thisAssemblyLocation, DefaultPackageName)); } if (globalInstallationPath == null) { // Check if we have a regular distribution if (defaultPackageDirectoryTemp.Parent != null && IsRootDirectory(defaultPackageDirectoryTemp.Parent.FullName)) { globalInstallationPath = defaultPackageDirectoryTemp.Parent.FullName; } else if (IsRootDirectory(defaultPackageDirectory)) { // we have a dev distribution globalInstallationPath = defaultPackageDirectory; } } } // 3. Try from the environement variable if (globalInstallationPath == null) { var rootDirectory = Environment.GetEnvironmentVariable(DefaultEnvironmentSdkDir); if (!string.IsNullOrWhiteSpace(rootDirectory) && IsRootDirectory(rootDirectory)) { globalInstallationPath = rootDirectory; if (defaultPackageDirectory == null) { defaultPackageDirectory = globalInstallationPath; } } } // If there is no root, this is an error if (globalInstallationPath == null) { throw new InvalidOperationException("Unable to find a valid Paradox installation or dev path"); } // Preload default package var logger = new LoggerResult(); var defaultPackageFile = GetPackageFile(defaultPackageDirectory, DefaultPackageName); defaultPackage = Package.Load(logger, defaultPackageFile, GetDefaultPackageLoadParameters()); if (defaultPackage == null) { throw new InvalidOperationException("Error while loading default package from [{0}]: {1}".ToFormat(defaultPackageFile, logger.ToText())); } defaultPackage.IsSystem = true; // A flag variable just to know if it is a bare bone development directory isDev = defaultPackageDirectory != null && IsRootDevDirectory(defaultPackageDirectory); // Check if we are in a root directory with store/packages facilities if (NugetStore.IsStoreDirectory(globalInstallationPath)) { packagesDirectory = UPath.Combine(globalInstallationPath, (UDirectory)NugetStore.DefaultGamePackagesDirectory); store = new NugetStore(globalInstallationPath); } }
public LauncherApp() { clock = Stopwatch.StartNew(); IsProcessing = false; // TODO: Add a way to clear the cache more othen than the default nuget (>= 200 files) // Check config file DebugStep("Load store"); // Get the package name and executable to launch/update var thisExeDirectory = Path.GetDirectoryName(typeof(LauncherApp).Assembly.Location); store = new NugetStore(thisExeDirectory); store.Manager.Logger = this; store.SourceRepository.Logger = this; mainPackage = store.MainPackageId; vsixPackage = store.VSIXPluginId; SdkVersionManager = new SDKVersionManager(store.Manager, mainPackage, vsixPackage); mainExecutable = store.Settings.GetConfigValue(MainExecutableKey); if (string.IsNullOrWhiteSpace(mainExecutable)) { throw new LauncherAppException("Invalid configuration. Expecting [{0}] in config", MainExecutableKey); } var aggregateRepo = (AggregateRepository)store.Manager.SourceRepository; foreach (var repo in aggregateRepo.Repositories) { var progressProvider = repo as IProgressProvider; if (progressProvider != null) { progressProvider.ProgressAvailable += OnProgressAvailable; } } downloadThreads = new List<Thread>(); // Update the targets everytime the launcher is used in order to make sure targets are up-to-date // with packages installed (rewrite for example after a self-update) store.UpdateTargets(); }