/// <summary>
/// Loads the assembly references that were not loaded before.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="loadParametersArg">The load parameters argument.</param>
public void UpdateAssemblyReferences(ILogger log, PackageLoadParameters loadParametersArg = null)
{
if (State < PackageState.DependenciesReady)
{
return;
}
var loadParameters = loadParametersArg ?? PackageLoadParameters.Default();
LoadAssemblyReferencesForPackage(log, loadParameters);
}
/// <summary>
/// Adds an existing package to the current session.
/// </summary>
/// <param name="packagePath">The package path.</param>
/// <param name="logger">The session result.</param>
/// <param name="loadParametersArg">The load parameters argument.</param>
/// <exception cref="System.ArgumentNullException">packagePath</exception>
/// <exception cref="System.ArgumentException">Invalid relative path. Expecting an absolute package path;packagePath</exception>
/// <exception cref="System.IO.FileNotFoundException">Unable to find package</exception>
public Package AddExistingPackage(UFile packagePath, ILogger logger, PackageLoadParameters loadParametersArg = null)
{
if (packagePath == null)
{
throw new ArgumentNullException("packagePath");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (!packagePath.IsAbsolute)
{
throw new ArgumentException("Invalid relative path. Expecting an absolute package path", "packagePath");
}
if (!File.Exists(packagePath))
{
throw new FileNotFoundException("Unable to find package", packagePath);
}
var loadParameters = loadParametersArg ?? PackageLoadParameters.Default();
Package package;
try
{
// Enable reference analysis caching during loading
AssetReferenceAnalysis.EnableCaching = true;
var packagesLoaded = new PackageCollection();
package = PreLoadPackage(this, logger, packagePath, false, packagesLoaded, loadParameters);
// Load all missing references/dependencies
LoadMissingReferences(logger, loadParameters);
// Load assets
TryLoadAssets(this, logger, package, loadParameters);
// Run analysis after
foreach (var packageToAdd in packagesLoaded)
{
var analysis = new PackageAnalysis(packageToAdd, GetPackageAnalysisParametersForLoad());
analysis.Run(logger);
}
}
finally
{
// Disable reference analysis caching after loading
AssetReferenceAnalysis.EnableCaching = false;
}
return(package);
}
/// <summary>
/// Make sure packages have their assets loaded.
/// </summary>
/// <param name="log">The log.</param>
/// <param name="loadParametersArg">The load parameters argument.</param>
public void LoadMissingAssets(ILogger log, PackageLoadParameters loadParametersArg = null)
{
var loadParameters = loadParametersArg ?? PackageLoadParameters.Default();
var cancelToken = loadParameters.CancelToken;
// Make a copy of Packages as it can be modified by PreLoadPackageDependencies
var previousPackages = Packages.ToList();
foreach (var package in previousPackages)
{
// Output the session only if there is no cancellation
if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested)
{
return;
}
TryLoadAssets(this, log, package, loadParameters);
}
}
/// <summary>
/// Load only assembly references
/// </summary>
/// <param name="package">The package.</param>
/// <param name="log">The log.</param>
/// <param name="loadParametersArg">The load parameters argument.</param>
/// <returns></returns>
internal bool LoadAssemblies(ILogger log, PackageLoadParameters loadParametersArg)
{
var loadParameters = loadParametersArg ?? PackageLoadParameters.Default();
try
{
// Load assembly references
if (loadParameters.LoadAssemblyReferences)
{
LoadAssemblyReferencesForPackage(log, loadParameters);
}
return(true);
}
catch (Exception ex)
{
log.Error("Error while pre-loading package [{0}]", ex, FullPath);
return(false);
}
}
/// <summary>
/// Second part of the package loading process, when references, assets and package analysis is done.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="log">The log.</param>
/// <param name="loadParametersArg">The load parameters argument.</param>
/// <returns></returns>
internal bool LoadAssembliesAndAssets(ILogger log, PackageLoadParameters loadParametersArg)
{
var loadParameters = loadParametersArg ?? PackageLoadParameters.Default();
try
{
// Load assembly references
if (loadParameters.LoadAssemblyReferences)
{
LoadAssemblyReferencesForPackage(log, loadParameters);
}
// Load assets
if (loadParameters.AutoLoadTemporaryAssets)
{
LoadTemporaryAssets(log, loadParameters.AssetFiles, loadParameters.CancelToken);
}
// Convert UPath to absolute
if (loadParameters.ConvertUPathToAbsolute)
{
var analysis = new PackageAnalysis(this, new PackageAnalysisParameters()
{
ConvertUPathTo = UPathType.Absolute,
IsProcessingUPaths = true, // This is done already by Package.Load
SetDirtyFlagOnAssetWhenFixingAbsoluteUFile = true // When loading tag attributes that have an absolute file
});
analysis.Run(log);
}
// Load templates
LoadTemplates(log);
return(true);
}
catch (Exception ex)
{
log.Error("Error while pre-loading package [{0}]", ex, FullPath);
return(false);
}
}
/// <summary>
/// Loads only the package description but not assets or plugins.
/// </summary>
/// <param name="log">The log to receive error messages.</param>
/// <param name="filePath">The file path.</param>
/// <param name="loadParametersArg">The load parameters argument.</param>
/// <returns>A package.</returns>
/// <exception cref="System.ArgumentNullException">log
/// or
/// filePath</exception>
public static Package Load(ILogger log, string filePath, PackageLoadParameters loadParametersArg = null)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
if (filePath == null)
{
throw new ArgumentNullException("filePath");
}
filePath = FileUtility.GetAbsolutePath(filePath);
if (!File.Exists(filePath))
{
log.Error("Package file [{0}] was not found", filePath);
return(null);
}
var loadParameters = loadParametersArg ?? PackageLoadParameters.Default();
try
{
var package = AssetSerializer.Load <Package>(filePath);
package.FullPath = filePath;
package.IsDirty = false;
// Load assembly references
if (loadParameters.LoadAssemblyReferences)
{
package.LoadAssemblyReferencesForPackage(log, loadParameters);
}
// Load assets
if (loadParameters.AutoLoadTemporaryAssets)
{
package.LoadTemporaryAssets(log, loadParameters.CancelToken);
}
// Convert UPath to absolute
if (loadParameters.ConvertUPathToAbsolute)
{
var analysis = new PackageAnalysis(package, new PackageAnalysisParameters()
{
ConvertUPathTo = UPathType.Absolute,
IsProcessingUPaths = true, // This is done already by Package.Load
SetDirtyFlagOnAssetWhenFixingAbsoluteUFile = true // When loading tag attributes that have an absolute file
});
analysis.Run(log);
}
// Load templates
package.LoadTemplates(log);
return(package);
}
catch (Exception ex)
{
log.Error("Error while pre-loading package [{0}]", ex, filePath);
}
return(null);
}
/// <summary>
/// Loads a package from specified file path.
/// </summary>
/// <param name="filePath">The file path to a package file.</param>
/// <param name="sessionResult">The session result.</param>
/// <param name="loadParameters">The load parameters.</param>
/// <returns>A package.</returns>
/// <exception cref="System.ArgumentNullException">filePath</exception>
/// <exception cref="System.ArgumentException">File [{0}] must exist.ToFormat(filePath);filePath</exception>
public static void Load(string filePath, PackageSessionResult sessionResult, PackageLoadParameters loadParameters = null)
{
if (filePath == null)
{
throw new ArgumentNullException("filePath");
}
if (sessionResult == null)
{
throw new ArgumentNullException("sessionResult");
}
// Make sure with have valid parameters
loadParameters = loadParameters ?? PackageLoadParameters.Default();
// Make sure to use a full path.
filePath = FileUtility.GetAbsolutePath(filePath);
if (!File.Exists(filePath))
{
throw new ArgumentException("File [{0}] must exist".ToFormat(filePath), "filePath");
}
try
{
// Enable reference analysis caching during loading
AssetReferenceAnalysis.EnableCaching = true;
using (var profile = Profiler.Begin(PackageSessionProfilingKeys.Loading))
{
sessionResult.Clear();
sessionResult.Progress("Loading..", 0, 1);
var session = new PackageSession();
var packagePaths = new List <string>();
// If we have a solution, load all packages
if (PackageSessionHelper.IsSolutionFile(filePath))
{
PackageSessionHelper.LoadSolution(session, filePath, packagePaths, sessionResult);
}
else if (PackageSessionHelper.IsPackageFile(filePath))
{
packagePaths.Add(filePath);
}
else
{
sessionResult.Error("Unsupported file extension (only .sln or {0} are supported)", Package.PackageFileExtension);
return;
}
var cancelToken = loadParameters.CancelToken;
// Load all packages
var packagesLoaded = new PackageCollection();
foreach (var packageFilePath in packagePaths)
{
PreLoadPackage(session, sessionResult, packageFilePath, false, packagesLoaded, loadParameters);
// Output the session only if there is no cancellation
if (cancelToken.HasValue && cancelToken.Value.IsCancellationRequested)
{
return;
}
}
// Load all missing references/dependencies
session.LoadMissingReferences(sessionResult, loadParameters);
// Fix relative references
var analysis = new PackageSessionAnalysis(session, GetPackageAnalysisParametersForLoad());
var analysisResults = analysis.Run();
analysisResults.CopyTo(sessionResult);
// Run custom package session analysis
foreach (var type in AssetRegistry.GetPackageSessionAnalysisTypes())
{
var pkgAnalysis = (PackageSessionAnalysisBase)Activator.CreateInstance(type);
pkgAnalysis.Session = session;
var results = pkgAnalysis.Run();
results.CopyTo(sessionResult);
}
// Output the session only if there is no cancellation
if (!cancelToken.HasValue || !cancelToken.Value.IsCancellationRequested)
{
sessionResult.Session = session;
// Defer the initialization of the dependency manager
//session.DependencyManager.InitializeDeferred();
}
// The session is not dirty when loading it
session.IsDirty = false;
}
}
finally
{
// Disable reference analysis caching after loading
AssetReferenceAnalysis.EnableCaching = false;
}
}