public PublishProject(
ProjectReferenceDependencyProvider projectReferenceDependencyProvider,
IProjectResolver projectResolver,
LibraryDescription libraryDescription)
{
_projectReferenceDependencyProvider = projectReferenceDependencyProvider;
_projectResolver = projectResolver;
_libraryDescription = libraryDescription;
}
private Item Resolve(
Dictionary <LibraryRange, Item> resolvedItems,
IEnumerable <IDependencyProvider> providers,
LibraryRange packageKey,
FrameworkName frameworkName)
{
Item item;
if (resolvedItems.TryGetValue(packageKey, out item))
{
return(item);
}
LibraryDescription match = null;
foreach (var dependencyProvider in providers)
{
match = dependencyProvider.GetDescription(packageKey, frameworkName);
if (match != null)
{
break;
}
}
if (match == null)
{
resolvedItems[packageKey] = null;
return(null);
}
if (resolvedItems.TryGetValue(match.Identity, out item))
{
return(item);
}
item = new Item()
{
Description = match,
Key = match.Identity,
Dependencies = match.Dependencies
};
resolvedItems[packageKey] = item;
resolvedItems[match.Identity] = item;
return(item);
}
internal static Resolution FromLibrary(LibraryDescription lib)
{
if (lib.Identity != null)
{
var url = "";
var commit = "";
var repoFile = Path.Combine(lib.Path, REPO_FILE_NAME);
if (File.Exists(repoFile))
{
var content = File.ReadAllText(repoFile);
var spec = JsonConvert.DeserializeObject<RepoJson>(content);
if (spec.Url.Contains("github"))
{
url = spec.Url;
commit = spec.Commit;
}
}
return new Resolution
{
Raw = new ResolutionIdentity
{
Name = lib.Identity.Name,
Version = lib.Identity.Version.ToString()
},
ResolvedTarget = new Target
{
Unit = lib.Identity.Name,
VersionString = lib.Identity.Version.ToString(),
RepoCloneURL = url,
RevSpec = commit
}
};
}
else
{
return new Resolution
{
Raw = new ResolutionIdentity
{
Name = lib.RequestedRange.Name,
Version = lib.RequestedRange.VersionRange.ToString()
},
Error = "Dependensy resolution failed"
};
}
}
private LibraryExport ExportAssemblyLibrary(LibraryDescription library)
{
if (string.IsNullOrEmpty(library.Path))
{
Logger.TraceError($"[{nameof(LibraryExporter)}] Failed to export: {library.Identity.Name}");
return null;
}
// We assume the path is to an assembly
return new LibraryExport(new MetadataFileReference(library.Identity.Name, library.Path));
}
private LibraryExport GetExport(LibraryDescription library, string aspect)
{
// Don't even try to export unresolved libraries
if(!library.Resolved)
{
return null;
}
if (string.Equals(LibraryTypes.Package, library.Type, StringComparison.Ordinal))
{
return ExportPackage((PackageDescription)library);
}
else if (string.Equals(LibraryTypes.Project, library.Type, StringComparison.Ordinal))
{
return ExportProject((ProjectDescription)library, aspect);
}
else
{
return ExportAssemblyLibrary(library);
}
}
private LibraryExport GetAllExports(
LibraryDescription projectLibrary,
string aspect,
Func<Library, bool> include)
{
var dependencyStopWatch = Stopwatch.StartNew();
Logger.TraceInformation($"[{nameof(LibraryExporter)}]: Resolving references for '{projectLibrary.Identity.Name}' {aspect}");
var references = new Dictionary<string, IMetadataReference>(StringComparer.OrdinalIgnoreCase);
var sourceReferences = new Dictionary<string, ISourceReference>(StringComparer.OrdinalIgnoreCase);
// Walk the dependency tree and resolve the library export for all references to this project
var queue = new Queue<Node>();
var processed = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
var rootNode = new Node
{
Library = _manager.GetLibrary(projectLibrary.Identity.Name)
};
queue.Enqueue(rootNode);
while (queue.Count > 0)
{
var node = queue.Dequeue();
// Skip it if we've already seen it
if (!processed.Add(node.Library.Name))
{
continue;
}
if (include(node.Library))
{
var libraryExport = GetExport(node.Library.Name);
if (libraryExport != null)
{
if (node.Parent == rootNode)
{
// Only export sources from first level dependencies
ProcessExport(libraryExport, references, sourceReferences);
}
else
{
// Skip source exports from anything else
ProcessExport(libraryExport, references, sourceReferences: null);
}
}
}
foreach (var dependency in node.Library.Dependencies)
{
var childNode = new Node
{
Library = _manager.GetLibrary(dependency),
Parent = node
};
queue.Enqueue(childNode);
}
}
dependencyStopWatch.Stop();
Logger.TraceInformation($"[{nameof(LibraryExporter)}]: Resolved {references.Count} references for '{projectLibrary.Identity.Name}' in {dependencyStopWatch.ElapsedMilliseconds}ms");
return new LibraryExport(
references.Values.ToList(),
sourceReferences.Values.ToList());
}
private LibraryExport ExportProject(LibraryDescription library, string aspect)
{
return ProjectExporter.ExportProject(
((ProjectDescription)library).Project,
_compilationEngine,
aspect,
_targetFramework,
_configuration);
}
private LibraryExport ExportPackage(LibraryDescription library)
{
var packageLibrary = (PackageDescription)library;
var references = new Dictionary<string, IMetadataReference>(StringComparer.OrdinalIgnoreCase);
if (!TryPopulateMetadataReferences(packageLibrary, _targetFramework, references))
{
return null;
}
// REVIEW: This requires more design
var sourceReferences = new List<ISourceReference>();
foreach (var sharedSource in GetSharedSources(packageLibrary, _targetFramework))
{
sourceReferences.Add(new SourceFileReference(sharedSource));
}
return new LibraryExport(references.Values.ToList(), sourceReferences);
}
private DiagnosticMessage ValidateDependency(LibraryDescription library, HashSet<string> projectCandidates)
{
if (!library.Resolved || projectCandidates == null)
{
return null;
}
var foundCandidate = projectCandidates.Contains(library.Identity.Name);
if ((library.Type == LibraryTypes.Project && !foundCandidate) ||
(library.Type == LibraryTypes.Package && foundCandidate))
{
library.Resolved = false;
library.Type = LibraryTypes.Unresolved;
return new DiagnosticMessage(
DiagnosticMonikers.NU1010,
$"The type of dependency {library.Identity.Name} was changed.",
library.RequestedRange.FileName,
DiagnosticMessageSeverity.Error,
library.RequestedRange.Line,
library.RequestedRange.Column,
library);
}
return null;
}
private static DependencyDescription CreateDependencyDescription(LibraryDescription library,
IEnumerable<DiagnosticMessage> diagnostics,
int protocolVersion)
{
var result = new DependencyDescription
{
Name = library.Identity.Name,
DisplayName = library.Identity.IsGacOrFrameworkReference ? library.RequestedRange.GetReferenceAssemblyName() : library.Identity.Name,
Version = library.Identity.Version?.ToString(),
Type = library.Type,
Resolved = library.Resolved,
Path = library.Path,
Dependencies = library.Dependencies.Select(dependency => new DependencyItem
{
Name = dependency.Name,
Version = dependency.Library?.Identity?.Version?.ToString()
}),
Errors = diagnostics.Where(d => d.Severity == DiagnosticMessageSeverity.Error)
.Select(d => new DiagnosticMessageView(d)),
Warnings = diagnostics.Where(d => d.Severity == DiagnosticMessageSeverity.Warning)
.Select(d => new DiagnosticMessageView(d))
};
if (protocolVersion < 3 && !library.Resolved)
{
result.Type = "Unresolved";
}
return result;
}
private static LibraryDependency CreateDependency(LibraryDescription libraryDescription)
{
return new LibraryDependency
{
LibraryRange = new LibraryRange(libraryDescription.Identity.Name, libraryDescription.Identity.IsGacOrFrameworkReference)
{
VersionRange = new SemanticVersionRange(libraryDescription.Identity.Version)
}
};
}
public PublishPackage(LibraryDescription libraryDescription)
{
_libraryDescription = libraryDescription;
}
