/// <summary>
/// Get the default package IDs for the given version.
/// </summary>
/// <param name="metadata">Unity version</param>
/// <param name="cachePlatform">Name of platform</param>
public IEnumerable <string> GetDefaultPackages(VersionMetadata metadata, CachePlatform cachePlatform)
{
var packages = metadata.GetPackages(cachePlatform);
if (packages == null)
{
throw new ArgumentException($"Unity version contains no packages: {metadata.version}");
}
return(packages.Where(p => p.install).Select(p => p.name));
}
/// <summary>
/// Create a download and install queue from the given version and packages.
/// </summary>
/// <param name="metadata">The Unity version</param>
/// <param name="cachePlatform">Name of platform</param>
/// <param name="downloadPath">Location of the downloaded the packages</param>
/// <param name="packageIds">Packages to download and/or install</param>
/// <returns>The queue list with the created queue items</returns>
public Queue CreateQueue(VersionMetadata metadata, CachePlatform cachePlatform, string downloadPath, IEnumerable <PackageMetadata> packages)
{
if (!metadata.version.IsFullVersion)
{
throw new ArgumentException("VersionMetadata.version needs to contain a full Unity version", nameof(metadata));
}
var packageMetadata = metadata.GetPackages(cachePlatform);
if (packageMetadata == null || !packageMetadata.Any())
{
throw new ArgumentException("VersionMetadata.packages cannot be null or empty", nameof(metadata));
}
var items = new List <QueueItem>();
foreach (var package in packages)
{
var fullUrl = package.url;
if (metadata.baseUrl != null && !fullUrl.StartsWith("http"))
{
fullUrl = metadata.baseUrl + package.url;
}
var fileName = package.GetFileName();
Logger.LogDebug($"{package.name}: Using file name '{fileName}' for url '{fullUrl}'");
var outputPath = Path.Combine(downloadPath, fileName);
items.Add(new QueueItem()
{
package = package,
downloadUrl = new Uri(fullUrl),
filePath = outputPath,
retries = Configuration.retryCount
});
}
return(new Queue()
{
metadata = metadata,
items = items
});
}
/// <summary>
/// Resolve package patterns to package metadata.
/// This method also adds package dependencies.
/// </summary>
public IEnumerable <PackageMetadata> ResolvePackages(
VersionMetadata metadata,
CachePlatform cachePlatform,
IEnumerable <string> packages,
IList <string> notFound = null
)
{
var packageMetadata = metadata.GetPackages(cachePlatform);
var metas = new List <PackageMetadata>();
foreach (var pattern in packages)
{
var id = pattern;
bool fuzzy = false, addDependencies = true;
while (id.StartsWith("~") || id.StartsWith("="))
{
if (id.StartsWith("~"))
{
fuzzy = true;
id = id.Substring(1);
}
else if (id.StartsWith("="))
{
addDependencies = false;
id = id.Substring(1);
}
}
PackageMetadata resolved = default;
if (fuzzy)
{
// Contains lookup
foreach (var package in packageMetadata)
{
if (package.name.IndexOf(id, StringComparison.OrdinalIgnoreCase) >= 0)
{
if (resolved.name == null)
{
Logger.LogDebug($"Fuzzy lookup '{pattern}' matched package '{resolved.name}'");
resolved = package;
}
else
{
throw new Exception($"Fuzzy package match '{pattern}' is ambiguous between '{package.name}' and '{resolved.name}'");
}
}
}
}
else
{
// Exact lookup
resolved = metadata.GetPackage(cachePlatform, id);
}
if (resolved.name != null)
{
AddPackageWithDependencies(packageMetadata, metas, resolved, addDependencies);
}
else if (notFound != null)
{
notFound.Add(id);
}
}
return(metas);
}
