private static void PreLoadPackageDependencies(PackageSession session, ILogger log, Package package, PackageCollection loadedPackages, PackageLoadParameters loadParameters)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
if (log == null)
{
throw new ArgumentNullException("log");
}
if (package == null)
{
throw new ArgumentNullException("package");
}
if (loadParameters == null)
{
throw new ArgumentNullException("loadParameters");
}
// 1. Load store package
foreach (var packageDependency in package.Meta.Dependencies)
{
var loadedPackage = session.Packages.Find(packageDependency);
if (loadedPackage != null)
{
continue;
}
var file = PackageStore.Instance.GetPackageFileName(packageDependency.Name, packageDependency.Version);
if (file == null)
{
// TODO: We need to support automatic download of packages. This is not supported yet when only Paradox
// package is supposed to be installed, but It will be required for full store
log.Error("Unable to find package {0} not installed", packageDependency);
continue;
}
// Recursive load of the system package
PreLoadPackage(session, log, file, true, loadedPackages, loadParameters);
}
// 2. Load local packages
foreach (var packageReference in package.LocalDependencies)
{
// Check that the package was not already loaded, otherwise return the same instance
if (session.Packages.ContainsById(packageReference.Id))
{
continue;
}
// Expand the string of the location
var newLocation = (UFile)AssetRegistry.ExpandString(session, packageReference.Location);
var subPackageFilePath = package.RootDirectory != null?UPath.Combine(package.RootDirectory, newLocation) : newLocation;
// Recursive load
PreLoadPackage(session, log, subPackageFilePath.FullPath, false, loadedPackages, loadParameters);
}
}
/// <summary>
/// Serializes an <see cref="Asset" /> to the specified stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="asset">The asset object.</param>
/// <param name="log">The logger.</param>
/// <exception cref="System.ArgumentNullException">
/// stream
/// or
/// assetFileExtension
/// </exception>
public static void Save(Stream stream, object asset, ILogger log = null)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (asset == null)
{
return;
}
var assetFileExtension = AssetRegistry.GetDefaultExtension(asset.GetType());
if (assetFileExtension == null)
{
throw new ArgumentException("Unable to find a serializer for the specified asset. No asset file extension registered to AssetRegistry");
}
var serializer = FindSerializer(assetFileExtension);
if (serializer == null)
{
throw new InvalidOperationException("Unable to find a serializer for [{0}]".ToFormat(assetFileExtension));
}
serializer.Save(stream, asset, log);
}
/// <summary>
/// Serializes an <see cref="Asset" /> to the specified stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="asset">The asset object.</param>
/// <param name="yamlMetadata"></param>
/// <param name="log">The logger.</param>
/// <exception cref="System.ArgumentNullException">
/// stream
/// or
/// assetFileExtension
/// </exception>
public static void Save(Stream stream, object asset, AttachedYamlAssetMetadata yamlMetadata, ILogger log = null)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (asset == null)
{
return;
}
var assetFileExtension = AssetRegistry.GetDefaultExtension(asset.GetType());
if (assetFileExtension == null)
{
throw new ArgumentException("Unable to find a serializer for the specified asset. No asset file extension registered to AssetRegistry");
}
var serializer = FindSerializer(assetFileExtension);
if (serializer == null)
{
throw new InvalidOperationException($"Unable to find a serializer for [{assetFileExtension}]");
}
serializer.Save(stream, asset, yamlMetadata, log);
}
/// <summary>
/// Initializes a new instance of the <see cref="Asset"/> class.
/// </summary>
protected Asset()
{
Id = AssetId.New();
Tags = new TagCollection();
// Initializse asset with default versions (same code as in Package..ctor())
var defaultPackageVersion = AssetRegistry.GetCurrentFormatVersions(GetType());
if (defaultPackageVersion != null)
{
SerializedVersion = new Dictionary <string, PackageVersion>(defaultPackageVersion);
}
}
private static List <Tuple <UFile, UDirectory> > ListAssetFiles(ILogger log, Package package, CancellationToken?cancelToken)
{
var listFiles = new List <Tuple <UFile, UDirectory> >();
// TODO Check how to handle refresh correctly as a public API
if (package.RootDirectory == null)
{
throw new InvalidOperationException("Package RootDirectory is null");
}
if (!Directory.Exists(package.RootDirectory))
{
throw new InvalidOperationException("Package RootDirectory [{0}] does not exist".ToFormat(package.RootDirectory));
}
// Iterate on each source folders
foreach (var sourceFolder in package.GetDistinctAssetFolderPaths())
{
// Lookup all files
foreach (var directory in FileUtility.EnumerateDirectories(sourceFolder, SearchDirection.Down))
{
var files = directory.GetFiles();
foreach (var filePath in files)
{
// Don't load package via this method
if (filePath.FullName.EndsWith(PackageFileExtension))
{
continue;
}
// Make an absolute path from the root of this package
var fileUPath = new UFile(filePath.FullName);
if (fileUPath.GetFileExtension() == null)
{
continue;
}
// If this kind of file an asset file?
if (!AssetRegistry.IsAssetFileExtension(fileUPath.GetFileExtension()))
{
continue;
}
listFiles.Add(new Tuple <UFile, UDirectory>(fileUPath, sourceFolder));
}
}
}
return(listFiles);
}
internal AssetToImportMergeGroup(AssetToImportByImporter parent, AssetItem item)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
if (item == null)
{
throw new ArgumentNullException("item");
}
this.Parent = parent;
Item = item;
Merges = new List <AssetToImportMerge>();
Enabled = true;
var assetDescription = AssetRegistry.GetDescription(item.Asset.GetType());
Log = new LoggerResult(string.Format("Import {0} {1}", assetDescription != null ? assetDescription.DisplayName : "Asset", item));
}
PackageUpgrader CheckPackageUpgrade(ILogger log, Package dependentPackage, PackageDependency dependency, Package dependencyPackage)
{
// Don't do anything if source is a system (read-only) package for now
// We only want to process local packages
if (dependentPackage.IsSystem)
{
return(null);
}
// Check if package might need upgrading
var dependentPackagePreviousMinimumVersion = dependency.Version.MinVersion;
if (dependentPackagePreviousMinimumVersion < dependencyPackage.Meta.Version)
{
// Find upgrader for given package
// Note: If no upgrader is found, we assume it is still compatible with previous versions, so do nothing
var packageUpgrader = AssetRegistry.GetPackageUpgrader(dependencyPackage.Meta.Name);
if (packageUpgrader != null)
{
// Check if upgrade is necessary
if (dependency.Version.MinVersion >= packageUpgrader.Attribute.PackageUpdatedVersionRange.MinVersion)
{
return(null);
}
// Check if upgrade is allowed
if (dependency.Version.MinVersion < packageUpgrader.Attribute.PackageMinimumVersion)
{
// Throw an exception, because the package update is not allowed and can't be done
throw new InvalidOperationException(string.Format("Upgrading package [{0}] to use [{1}] from version [{2}] to [{3}] is not supported", dependentPackage.Meta.Name, dependencyPackage.Meta.Name, dependentPackagePreviousMinimumVersion, dependencyPackage.Meta.Version));
}
log.Info("Upgrading package [{0}] to use [{1}] from version [{2}] to [{3}] will be required", dependentPackage.Meta.Name, dependencyPackage.Meta.Name, dependentPackagePreviousMinimumVersion, dependencyPackage.Meta.Version);
return(packageUpgrader);
}
}
return(null);
}
/// <summary>
/// Fixes asset import that were imported by the previous method. Add a AssetImport.SourceHash and ImporterId
/// </summary>
/// <param name="item">The item.</param>
private static void FixAssetImport(AssetItem item)
{
// TODO: this whole method is a temporary migration. This should be removed in the next version
var assetImport = item.Asset as AssetImport;
if (assetImport == null || assetImport.Source == null)
{
return;
}
// If the asset has a source but no import base, then we are going to simulate an original import
if (assetImport.Base == null)
{
var fileExtension = assetImport.Source.GetFileExtension();
var assetImportBase = (AssetImport)AssetCloner.Clone(assetImport);
assetImportBase.SetAsRootImport();
assetImportBase.SetDefaults();
// Setup default importer
if (!String.IsNullOrEmpty(fileExtension))
{
var importerId = AssetRegistry.FindImporterByExtension(fileExtension).FirstOrDefault();
if (importerId != null)
{
assetImport.ImporterId = importerId.Id;
}
}
var assetImportTracked = assetImport as AssetImportTracked;
if (assetImportTracked != null)
{
assetImportTracked.SourceHash = ObjectId.Empty;
}
assetImport.Base = new AssetBase(assetImportBase);
item.IsDirty = true;
}
}
protected override bool CanVisit(object obj)
{
return(!AssetRegistry.IsContentType(obj?.GetType()) && base.CanVisit(obj));
}
public AssetUpgraderCollection(Type assetType, int currentVersion)
{
this.currentVersion = currentVersion;
AssetRegistry.AssertAssetType(assetType);
AssetType = assetType;
}
public static bool IsPackageFile(string filePath)
{
return(AssetRegistry.GetAssetTypeFromFileExtension(Path.GetExtension(filePath)) == typeof(Package));
}
public static bool MigrateAssetIfNeeded(AssetMigrationContext context, PackageLoadingAssetFile loadAsset)
{
var assetFullPath = loadAsset.FilePath.FullPath;
// Determine if asset was Yaml or not
var assetFileExtension = Path.GetExtension(assetFullPath);
if (assetFileExtension == null)
{
return(false);
}
assetFileExtension = assetFileExtension.ToLowerInvariant();
var serializer = AssetSerializer.FindSerializer(assetFileExtension);
if (!(serializer is AssetYamlSerializer))
{
return(false);
}
// We've got a Yaml asset, let's get expected and serialized versions
var serializedVersion = 0;
int expectedVersion;
Type assetType;
// Read from Yaml file the asset version and its type (to get expected version)
// Note: It tries to read as few as possible (SerializedVersion is expected to be right after Id, so it shouldn't try to read further than that)
using (var assetStream = loadAsset.OpenStream())
using (var streamReader = new StreamReader(assetStream))
{
var yamlEventReader = new EventReader(new Parser(streamReader));
// Skip header
yamlEventReader.Expect <StreamStart>();
yamlEventReader.Expect <DocumentStart>();
var mappingStart = yamlEventReader.Expect <MappingStart>();
var yamlSerializerSettings = YamlSerializer.GetSerializerSettings();
var tagTypeRegistry = yamlSerializerSettings.TagTypeRegistry;
bool typeAliased;
assetType = tagTypeRegistry.TypeFromTag(mappingStart.Tag, out typeAliased);
expectedVersion = AssetRegistry.GetCurrentFormatVersion(assetType);
Scalar assetKey;
while ((assetKey = yamlEventReader.Allow <Scalar>()) != null)
{
// Only allow Id before SerializedVersion
if (assetKey.Value == "Id")
{
yamlEventReader.Skip();
continue;
}
if (assetKey.Value == "SerializedVersion")
{
serializedVersion = Convert.ToInt32(yamlEventReader.Expect <Scalar>().Value, CultureInfo.InvariantCulture);
break;
}
}
}
if (serializedVersion > expectedVersion)
{
// Try to open an asset newer than what we support (probably generated by a newer Paradox)
throw new InvalidOperationException(string.Format("Asset of type {0} has been serialized with newer version {1}, but only version {2} is supported. Was this asset created with a newer version of Paradox?", assetType, serializedVersion, expectedVersion));
}
if (serializedVersion < expectedVersion)
{
// Perform asset upgrade
context.Log.Verbose("{0} needs update, from version {1} to version {2}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
// transform the stream into string.
string assetAsString;
using (var assetStream = loadAsset.OpenStream())
using (var assetStreamReader = new StreamReader(assetStream, Encoding.UTF8))
{
assetAsString = assetStreamReader.ReadToEnd();
}
// Load the asset as a YamlNode object
var input = new StringReader(assetAsString);
var yamlStream = new YamlStream();
yamlStream.Load(input);
var yamlRootNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
// Check if there is any asset updater
var assetUpgraders = AssetRegistry.GetAssetUpgraders(assetType);
if (assetUpgraders == null)
{
throw new InvalidOperationException(string.Format("Asset of type {0} should be updated from version {1} to {2}, but no asset migration path was found", assetType, serializedVersion, expectedVersion));
}
// Instantiate asset updaters
var currentVersion = serializedVersion;
while (currentVersion != expectedVersion)
{
int targetVersion;
// This will throw an exception if no upgrader is available for the given version, exiting the loop in case of error.
var upgrader = assetUpgraders.GetUpgrader(currentVersion, out targetVersion);
upgrader.Upgrade(context, currentVersion, targetVersion, yamlRootNode, loadAsset);
currentVersion = targetVersion;
}
// Make sure asset is updated to latest version
YamlNode serializedVersionNode;
var newSerializedVersion = 0;
if (yamlRootNode.Children.TryGetValue(new YamlScalarNode("SerializedVersion"), out serializedVersionNode))
{
newSerializedVersion = Convert.ToInt32(((YamlScalarNode)serializedVersionNode).Value);
}
if (newSerializedVersion != expectedVersion)
{
throw new InvalidOperationException(string.Format("Asset of type {0} was migrated, but still its new version {1} doesn't match expected version {2}.", assetType, newSerializedVersion, expectedVersion));
}
context.Log.Info("{0} updated from version {1} to version {2}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
var preferredIndent = YamlSerializer.GetSerializerSettings().PreferredIndent;
// Save asset back to disk
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream))
{
yamlStream.Save(streamWriter, true, preferredIndent);
}
loadAsset.AssetContent = memoryStream.ToArray();
}
return(true);
}
return(false);
}
public AssetUpgraderCollection(Type assetType, PackageVersion currentVersion)
{
this.currentVersion = currentVersion;
AssetRegistry.IsAssetType(assetType, true);
AssetType = assetType;
}
/// <summary>
/// Initializes a new instance of the <see cref="Asset"/> class.
/// </summary>
protected Asset()
{
Id = Guid.NewGuid();
Tags = new TagCollection();
SerializedVersion = AssetRegistry.GetCurrentFormatVersion(GetType());
}
public static bool MigrateAssetIfNeeded(AssetMigrationContext context, PackageLoadingAssetFile loadAsset, string dependencyName, PackageVersion untilVersion = null)
{
var assetFullPath = loadAsset.FilePath.FullPath;
// Determine if asset was Yaml or not
var assetFileExtension = Path.GetExtension(assetFullPath);
if (assetFileExtension == null)
{
return(false);
}
assetFileExtension = assetFileExtension.ToLowerInvariant();
var serializer = AssetSerializer.FindSerializer(assetFileExtension);
if (!(serializer is AssetYamlSerializer))
{
return(false);
}
// We've got a Yaml asset, let's get expected and serialized versions
var serializedVersion = PackageVersion.Zero;
PackageVersion expectedVersion;
Type assetType;
// Read from Yaml file the asset version and its type (to get expected version)
// Note: It tries to read as few as possible (SerializedVersion is expected to be right after Id, so it shouldn't try to read further than that)
using (var assetStream = loadAsset.OpenStream())
using (var streamReader = new StreamReader(assetStream))
{
var yamlEventReader = new EventReader(new Parser(streamReader));
// Skip header
yamlEventReader.Expect <StreamStart>();
yamlEventReader.Expect <DocumentStart>();
var mappingStart = yamlEventReader.Expect <MappingStart>();
var yamlSerializerSettings = YamlSerializer.GetSerializerSettings();
var tagTypeRegistry = yamlSerializerSettings.TagTypeRegistry;
bool typeAliased;
assetType = tagTypeRegistry.TypeFromTag(mappingStart.Tag, out typeAliased);
var expectedVersions = AssetRegistry.GetCurrentFormatVersions(assetType);
expectedVersion = expectedVersions?.FirstOrDefault(x => x.Key == dependencyName).Value ?? PackageVersion.Zero;
Scalar assetKey;
while ((assetKey = yamlEventReader.Allow <Scalar>()) != null)
{
// Only allow Id before SerializedVersion
if (assetKey.Value == nameof(Asset.Id))
{
yamlEventReader.Skip();
}
else if (assetKey.Value == nameof(Asset.SerializedVersion))
{
// Check for old format: only a scalar
var scalarVersion = yamlEventReader.Allow <Scalar>();
if (scalarVersion != null)
{
serializedVersion = PackageVersion.Parse("0.0." + Convert.ToInt32(scalarVersion.Value, CultureInfo.InvariantCulture));
// Let's update to new format
using (var yamlAsset = loadAsset.AsYamlAsset())
{
yamlAsset.DynamicRootNode.RemoveChild(nameof(Asset.SerializedVersion));
AssetUpgraderBase.SetSerializableVersion(yamlAsset.DynamicRootNode, dependencyName, serializedVersion);
var baseBranch = yamlAsset.DynamicRootNode[Asset.BaseProperty];
if (baseBranch != null)
{
var baseAsset = baseBranch["Asset"];
if (baseAsset != null)
{
baseAsset.RemoveChild(nameof(Asset.SerializedVersion));
AssetUpgraderBase.SetSerializableVersion(baseAsset, dependencyName, serializedVersion);
}
}
}
}
else
{
// New format: package => version mapping
yamlEventReader.Expect <MappingStart>();
while (!yamlEventReader.Accept <MappingEnd>())
{
var packageName = yamlEventReader.Expect <Scalar>().Value;
var packageVersion = PackageVersion.Parse(yamlEventReader.Expect <Scalar>().Value);
// For now, we handle only one dependency at a time
if (packageName == dependencyName)
{
serializedVersion = packageVersion;
}
}
yamlEventReader.Expect <MappingEnd>();
}
break;
}
else
{
// If anything else than Id or SerializedVersion, let's stop
break;
}
}
}
if (serializedVersion > expectedVersion)
{
// Try to open an asset newer than what we support (probably generated by a newer Xenko)
throw new InvalidOperationException($"Asset of type {assetType} has been serialized with newer version {serializedVersion}, but only version {expectedVersion} is supported. Was this asset created with a newer version of Xenko?");
}
if (serializedVersion < expectedVersion)
{
// Perform asset upgrade
context.Log.Verbose("{0} needs update, from version {1} to version {2}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
using (var yamlAsset = loadAsset.AsYamlAsset())
{
var yamlRootNode = yamlAsset.RootNode;
// Check if there is any asset updater
var assetUpgraders = AssetRegistry.GetAssetUpgraders(assetType, dependencyName);
if (assetUpgraders == null)
{
throw new InvalidOperationException($"Asset of type {assetType} should be updated from version {serializedVersion} to {expectedVersion}, but no asset migration path was found");
}
// Instantiate asset updaters
var currentVersion = serializedVersion;
while (currentVersion != expectedVersion)
{
PackageVersion targetVersion;
// This will throw an exception if no upgrader is available for the given version, exiting the loop in case of error.
var upgrader = assetUpgraders.GetUpgrader(currentVersion, out targetVersion);
// Stop if the next version would be higher than what is expected
if (untilVersion != null && targetVersion > untilVersion)
{
break;
}
upgrader.Upgrade(context, dependencyName, currentVersion, targetVersion, yamlRootNode, loadAsset);
currentVersion = targetVersion;
}
// Make sure asset is updated to latest version
YamlNode serializedVersionNode;
PackageVersion newSerializedVersion = null;
if (yamlRootNode.Children.TryGetValue(new YamlScalarNode(nameof(Asset.SerializedVersion)), out serializedVersionNode))
{
var newSerializedVersionForDefaultPackage = ((YamlMappingNode)serializedVersionNode).Children[new YamlScalarNode(dependencyName)];
newSerializedVersion = PackageVersion.Parse(((YamlScalarNode)newSerializedVersionForDefaultPackage).Value);
}
if (untilVersion == null && newSerializedVersion != expectedVersion)
{
throw new InvalidOperationException($"Asset of type {assetType} was migrated, but still its new version {newSerializedVersion} doesn't match expected version {expectedVersion}.");
}
context.Log.Info("{0} updated from version {1} to version {2}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
}
return(true);
}
return(false);
}
public static bool MigrateAssetIfNeeded(ILogger log, string assetFullPath)
{
// Determine if asset was Yaml or not
var assetFileExtension = Path.GetExtension(assetFullPath);
if (assetFileExtension == null)
{
return(false);
}
assetFileExtension = assetFileExtension.ToLowerInvariant();
var serializer = AssetSerializer.FindSerializer(assetFileExtension);
if (!(serializer is AssetYamlSerializer))
{
return(false);
}
// We've got a Yaml asset, let's get expected and serialized versions
var serializedVersion = 0;
var expectedVersion = 0;
Type assetType;
// Read from Yaml file the asset version and its type (to get expected version)
// Note: It tries to read as few as possible (SerializedVersion is expected to be right after Id, so it shouldn't try to read further than that)
using (var streamReader = new StreamReader(assetFullPath))
{
var yamlEventReader = new EventReader(new Parser(streamReader));
// Skip header
yamlEventReader.Expect <StreamStart>();
yamlEventReader.Expect <DocumentStart>();
var mappingStart = yamlEventReader.Expect <MappingStart>();
var yamlSerializerSettings = YamlSerializer.GetSerializerSettings();
var tagTypeRegistry = yamlSerializerSettings.TagTypeRegistry;
assetType = tagTypeRegistry.TypeFromTag(mappingStart.Tag);
expectedVersion = AssetRegistry.GetFormatVersion(assetType);
Scalar assetKey;
while ((assetKey = yamlEventReader.Allow <Scalar>()) != null)
{
// Only allow Id before SerializedVersion
if (assetKey.Value == "Id")
{
yamlEventReader.Skip();
continue;
}
if (assetKey.Value == "SerializedVersion")
{
serializedVersion = Convert.ToInt32(yamlEventReader.Expect <Scalar>().Value, CultureInfo.InvariantCulture);
break;
}
}
}
if (serializedVersion > expectedVersion)
{
// Try to open an asset newer than what we support (probably generated by a newer Paradox)
throw new InvalidOperationException(string.Format("Asset of type {0} has been serialized with newer version {1}, but only version {2} is supported. Was this asset created with a newer version of Paradox?", assetType, serializedVersion, expectedVersion));
}
if (serializedVersion < expectedVersion)
{
// Perform asset upgrade
log.Info("{0} needs update, from version {0} to version {1}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
// Load the asset as a YamlNode object
var input = new StringReader(File.ReadAllText(assetFullPath));
var yamlStream = new YamlStream();
yamlStream.Load(input);
var yamlRootNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
// Check if there is any asset updater
var assetUpdaterTypes = AssetRegistry.GetFormatVersionUpdaterTypes(assetType);
if (assetUpdaterTypes == null)
{
throw new InvalidOperationException(string.Format("Asset of type {0} should be updated from version {1} to {2}, but no asset migration path was found", assetType, serializedVersion, expectedVersion));
}
// Instantiate asset updaters
var assetUpgraders = assetUpdaterTypes.Select(x => (IAssetUpgrader)Activator.CreateInstance(x)).ToArray();
// TODO: Select best asset updater if more than one (need to check from what to what version they update, score, if multiple need to be chained, etc...)
// I think it's better to wait for some actual scenarios to implement this right the first time
if (assetUpgraders.Length != 1)
{
throw new InvalidOperationException(string.Format("Asset of type {0} has multiple migration paths, but selecting the right one is not implemented yet.", assetType));
}
// Perform upgrade
assetUpgraders[0].Upgrade(log, yamlRootNode);
// Make sure asset is updated to latest version
YamlNode serializedVersionNode;
serializedVersion = 0;
if (yamlRootNode.Children.TryGetValue(new YamlScalarNode("SerializedVersion"), out serializedVersionNode))
{
serializedVersion = Convert.ToInt32(((YamlScalarNode)serializedVersionNode).Value);
}
if (serializedVersion != expectedVersion)
{
throw new InvalidOperationException(string.Format("Asset of type {0} was migrated, but still its new version {1} doesn't match expected version {2}.", assetType, serializedVersion, expectedVersion));
}
var preferredIndent = YamlSerializer.GetSerializerSettings().PreferredIndent;
// Save asset back to disk
using (var streamWriter = new StreamWriter(assetFullPath))
yamlStream.Save(streamWriter, true, preferredIndent);
return(true);
}
return(false);
}
/// <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;
}
}