public YamlAsset(PackageLoadingAssetFile packageLoadingAssetFile) : base(GetSafeStream(packageLoadingAssetFile))
{
this.packageLoadingAssetFile = packageLoadingAssetFile;
}
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 = AssetFileSerializer.FindSerializer(assetFileExtension);
if (!(serializer is YamlAssetSerializer))
{
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 tagTypeRegistry = AssetYamlSerializer.Default.GetSerializerSettings().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["~Base"];
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($"{Path.GetFullPath(assetFullPath)} needs update, from version {serializedVersion} to version {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.Verbose($"{Path.GetFullPath(assetFullPath)} updated from version {serializedVersion} to version {expectedVersion}");
}
return(true);
}
return(false);
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var rootPartIds = asset.Hierarchy.RootPartIds;
int i = 0;
foreach (dynamic rootPartId in rootPartIds)
{
rootPartIds[i++] = "ref!! " + rootPartId.ToString();
}
asset.Hierarchy.RootParts = rootPartIds;
asset.Hierarchy.RootPartIds = DynamicYamlEmpty.Default;
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var rootNode = (YamlNode)asset.Node;
var allScalarNodes = rootNode.AllNodes.OfType <YamlScalarNode>().ToList();
var nextIsId = false;
var inPublicUIElements = false;
foreach (var node in allScalarNodes)
{
var indexFirstSlash = node.Value.IndexOf('/');
Guid targetGuid = Guid.Empty;
if (indexFirstSlash == -1)
{
Guid.TryParseExact(node.Value, "D", out targetGuid);
}
else
{
Guid entityGuid;
if (Guid.TryParseExact(node.Value.Substring(0, indexFirstSlash), "D", out entityGuid))
{
Guid.TryParseExact(node.Value.Substring(indexFirstSlash + 1), "D", out targetGuid);
}
}
if (targetGuid != Guid.Empty && !nextIsId && !inPublicUIElements)
{
node.Value = "ref!! " + targetGuid;
}
else
{
if (nextIsId && targetGuid == Guid.Empty)
{
nextIsId = false;
}
if (inPublicUIElements && node.Value == "Hierarchy")
{
inPublicUIElements = false;
}
if (node.Value.Contains("Id"))
{
nextIsId = true;
}
if (node.Value == "PublicUIElements")
{
inPublicUIElements = true;
}
}
}
}
protected abstract void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint);
private void UpgradeBase(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, dynamic assetBase, PackageLoadingAssetFile assetFile)
{
var baseAsset = assetBase["Asset"];
if (baseAsset != null)
{
UpgradeAsset(context, currentVersion, targetVersion, baseAsset, assetFile, OverrideUpgraderHint.Base);
SetSerializableVersion(baseAsset, dependencyName, targetVersion);
}
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
// upgrade the asset
var baseBranch = asset["~Base"];
var basePartsBranch = asset["~BaseParts"] as DynamicYamlArray;
// Detect in what kind of override context we are
var overrideHint = (baseBranch != null || (basePartsBranch != null && basePartsBranch.Node.Children.Count > 0))
? OverrideUpgraderHint.Derived
: OverrideUpgraderHint.Unknown;
// Upgrade the asset
UpgradeAsset(context, currentVersion, targetVersion, asset, assetFile, overrideHint);
SetSerializableVersion(asset, dependencyName, targetVersion);
// Upgrade its base
if (baseBranch != null)
{
UpgradeBase(context, dependencyName, currentVersion, targetVersion, baseBranch, assetFile);
}
// Upgrade base parts
if (basePartsBranch != null)
{
foreach (dynamic assetBase in basePartsBranch)
{
UpgradeBase(context, dependencyName, currentVersion, targetVersion, assetBase, assetFile);
}
}
}
