private CompilationLibrary GetCompilationLibrary(DependencyLibrary library)
{
GetCommonLibraryProperties(library,
out string hash,
out HashSet <Dependency> libraryDependencies,
out bool serviceable,
out string path,
out string hashPath,
out SingleProjectInfo referenceProjectInfo);
List <string> assemblies = new List <string>();
if (library.Type == "project" && !(referenceProjectInfo is UnreferencedProjectInfo))
{
assemblies.Add(referenceProjectInfo.OutputName);
}
else if (_compileReferences != null && _compileReferences.TryGetValue(library.Name, out var compileReferences))
{
foreach (var compileReference in compileReferences)
{
assemblies.Add(compileReference.PathInPackage);
}
}
return(new CompilationLibrary(
type: library.Type,
name: library.Name,
version: library.Version.ToString(),
hash,
assemblies,
libraryDependencies,
serviceable,
path,
hashPath));
}
private void GetCommonLibraryProperties(DependencyLibrary library,
out string hash,
out HashSet <Dependency> dependencies,
out bool serviceable,
out string path,
out string hashPath,
out SingleProjectInfo referenceProjectInfo)
{
serviceable = true;
referenceProjectInfo = null;
dependencies = new HashSet <Dependency>();
List <LibraryDependency> libraryDependencies;
if (_libraryDependencies.TryGetValue(library.Name, out libraryDependencies))
{
foreach (var dependency in libraryDependencies)
{
if (_dependencyLibraries.TryGetValue(dependency.Name, out var libraryDependency))
{
if (!libraryDependency.ExcludeFromRuntime ||
(!libraryDependency.ExcludeFromCompilation && IncludeCompilationLibraries))
{
dependencies.Add(libraryDependency.Dependency);
}
}
}
}
hash = string.Empty;
path = null;
hashPath = null;
if (library.Type == "package")
{
// TEMPORARY: All packages are serviceable in RC2
// See https://github.com/dotnet/cli/issues/2569
serviceable = true;
if (!string.IsNullOrEmpty(library.Sha512))
{
hash = "sha512-" + library.Sha512;
hashPath = _versionFolderPathResolver.GetHashFileName(library.Name, library.Version);
}
path = library.Path;
}
else if (library.Type == "project")
{
serviceable = false;
referenceProjectInfo = GetProjectInfo(library);
foreach (var dependencyReference in referenceProjectInfo.DependencyReferences)
{
dependencies.Add(
new Dependency(
GetReferenceLibraryName(dependencyReference),
dependencyReference.Version));
}
}
}
public DependencyContextBuilder2 WithRuntimePackAssets(IEnumerable <RuntimePackAssetInfo> runtimePackAssets)
{
_runtimePackAssets = new Dictionary <string, List <RuntimePackAssetInfo> >();
foreach (var runtimePackGroup in runtimePackAssets.GroupBy(a => a.PackageName))
{
var dependencyLibrary = new DependencyLibrary("runtimepack." + runtimePackGroup.Key,
NuGetVersion.Parse(runtimePackGroup.First().PackageVersion),
"runtimepack");
_dependencyLibraries.Add(dependencyLibrary.Name, dependencyLibrary);
_runtimePackAssets[dependencyLibrary.Name] = runtimePackGroup.ToList();
}
return(this);
}
public DependencyContextBuilder(SingleProjectInfo mainProjectInfo, bool includeRuntimeFileVersions, RuntimeGraph runtimeGraph, ProjectContext projectContext)
{
_mainProjectInfo = mainProjectInfo;
_includeRuntimeFileVersions = includeRuntimeFileVersions;
_runtimeGraph = runtimeGraph;
var libraryLookup = new LockFileLookup(projectContext.LockFile);
_dependencyLibraries = projectContext.LockFileTarget.Libraries
.Select(lockFileTargetLibrary =>
{
var dependencyLibrary = new DependencyLibrary(lockFileTargetLibrary.Name, lockFileTargetLibrary.Version, lockFileTargetLibrary.Type);
LockFileLibrary library;
if (libraryLookup.TryGetLibrary(lockFileTargetLibrary, out library))
{
dependencyLibrary.Sha512 = library.Sha512;
dependencyLibrary.Path = library.Path;
dependencyLibrary.MSBuildProject = library.MSBuildProject;
}
return(dependencyLibrary);
}).ToDictionary(d => d.Name, StringComparer.OrdinalIgnoreCase);
_libraryDependencies = new Dictionary <string, List <LibraryDependency> >(StringComparer.OrdinalIgnoreCase);
foreach (var library in projectContext.LockFileTarget.Libraries)
{
_libraryDependencies[library.Name] = library.Dependencies
.Select(d => new LibraryDependency()
{
Name = d.Id,
MinVersion = d.VersionRange.MinVersion
}).ToList();
}
_mainProjectDependencies = projectContext.GetTopLevelDependencies().ToList();
_packagesToBeFiltered = projectContext.PackagesToBeFiltered;
_isFrameworkDependent = projectContext.IsFrameworkDependent;
_platformLibrary = projectContext.PlatformLibrary?.Name;
_dotnetFrameworkName = projectContext.LockFileTarget.TargetFramework.DotNetFrameworkName;
_runtimeIdentifier = projectContext.LockFileTarget.RuntimeIdentifier;
_isPortable = projectContext.IsPortable;
_usedLibraryNames = new HashSet <string>(_dependencyLibraries.Keys, StringComparer.OrdinalIgnoreCase);
}
public static IDependencyLibrary RegisterServiceDependencies()
{
DependencyLibrary library = new DependencyLibrary();
library.Include <IConnectionFactory>(new ConnectionFactory());
library.Include <IWebsiteState>(new WebsiteState());
library.Include <IFileReceiver>(new FileReceiver());
library.Include <IIconValidatorService>(new IconValidatorService());
library.MarkForBuild <GridBuildRequest>(typeof(GridBuildRequest));
library.MarkForBuild <GridCellsRequest>(typeof(GridCellsRequest));
library.MarkForBuild <GridSizeRequest>(typeof(GridSizeRequest));
library.MarkForBuild <GridUpdateRequest>(typeof(GridUpdateRequest));
library.MarkForBuild <IconByNameRequest>(typeof(IconByNameRequest));
library.MarkForBuild <IconListRequest>(typeof(IconListRequest));
library.MarkForBuild <IconUploadRequest>(typeof(IconUploadRequest));
library.MarkForBuild <LastGridBuildTimeRequest>(typeof(LastGridBuildTimeRequest));
library.Build();
return(library);
}
private SingleProjectInfo GetProjectInfo(DependencyLibrary library)
{
string projectPath = library.MSBuildProject;
if (string.IsNullOrEmpty(projectPath))
{
throw new BuildErrorException(Strings.CannotFindProjectInfo, library.Name);
}
string mainProjectDirectory = Path.GetDirectoryName(_mainProjectInfo.ProjectPath);
string fullProjectPath = Path.GetFullPath(Path.Combine(mainProjectDirectory, projectPath));
SingleProjectInfo referenceProjectInfo = null;
if (_referenceProjectInfos?.TryGetValue(fullProjectPath, out referenceProjectInfo) != true ||
referenceProjectInfo == null)
{
return(UnreferencedProjectInfo.Default);
}
return(referenceProjectInfo);
}
private RuntimeLibrary GetRuntimeLibrary(DependencyLibrary library)
{
GetCommonLibraryProperties(library,
out string hash,
out HashSet <Dependency> libraryDependencies,
out bool serviceable,
out string path,
out string hashPath,
out SingleProjectInfo referenceProjectInfo);
if (referenceProjectInfo is UnreferencedProjectInfo)
{
// unreferenced ProjectInfos will be added later as simple dll dependencies
return(null);
}
List <RuntimeAssetGroup> runtimeAssemblyGroups = new List <RuntimeAssetGroup>();
List <RuntimeAssetGroup> nativeLibraryGroups = new List <RuntimeAssetGroup>();
List <ResourceAssembly> resourceAssemblies = new List <ResourceAssembly>();
if (library.Type == "project" && !(referenceProjectInfo is UnreferencedProjectInfo))
{
runtimeAssemblyGroups.Add(new RuntimeAssetGroup(string.Empty, referenceProjectInfo.OutputName));
resourceAssemblies.AddRange(referenceProjectInfo.ResourceAssemblies
.Select(r => new ResourceAssembly(r.RelativePath, r.Culture)));
}
else
{
if (_resolvedNuGetFiles != null && _resolvedNuGetFiles.TryGetValue(library.Name, out var resolvedNuGetFiles))
{
var runtimeFiles = resolvedNuGetFiles.Where(f => f.Asset == AssetType.Runtime &&
!f.IsRuntimeTarget);
runtimeAssemblyGroups.Add(new RuntimeAssetGroup(string.Empty,
runtimeFiles.Select(CreateRuntimeFile)));
var nativeFiles = resolvedNuGetFiles.Where(f => f.Asset == AssetType.Native &&
!f.IsRuntimeTarget);
nativeLibraryGroups.Add(new RuntimeAssetGroup(string.Empty,
nativeFiles.Select(CreateRuntimeFile)));
var resourceFiles = resolvedNuGetFiles.Where(f => f.Asset == AssetType.Resources &&
!f.IsRuntimeTarget);
resourceAssemblies.AddRange(resourceFiles.Select(f => new ResourceAssembly(f.PathInPackage, f.Culture)));
var runtimeTargets = resolvedNuGetFiles.Where(f => f.IsRuntimeTarget)
.GroupBy(f => f.RuntimeIdentifier);
foreach (var runtimeIdentifierGroup in runtimeTargets)
{
var managedRuntimeTargetsFiles = runtimeIdentifierGroup.Where(f => f.Asset == AssetType.Runtime).ToList();
if (managedRuntimeTargetsFiles.Any())
{
runtimeAssemblyGroups.Add(new RuntimeAssetGroup(runtimeIdentifierGroup.Key,
managedRuntimeTargetsFiles.Select(CreateRuntimeFile)));
}
var nativeRuntimeTargetsFiles = runtimeIdentifierGroup.Where(f => f.Asset == AssetType.Native).ToList();
if (nativeRuntimeTargetsFiles.Any())
{
nativeLibraryGroups.Add(new RuntimeAssetGroup(runtimeIdentifierGroup.Key,
nativeRuntimeTargetsFiles.Select(CreateRuntimeFile)));
}
}
}
}
var runtimeLibrary = new RuntimeLibrary(
type: library.Type,
name: library.Name,
version: library.Version.ToString(),
hash: hash,
runtimeAssemblyGroups: runtimeAssemblyGroups,
nativeLibraryGroups: nativeLibraryGroups,
resourceAssemblies: resourceAssemblies,
dependencies: libraryDependencies,
path: path,
hashPath: hashPath,
runtimeStoreManifestName: GetRuntimeStoreManifestName(library.Name, library.Version.ToString()),
serviceable: serviceable);
return(runtimeLibrary);
}
