mirrors/dotnet-installer
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Feature complete

Browse source
This commit is contained in:
piotrp 2016-03-27 22:24:20 -07:00 • committed by Piotr Puszkiewicz
parent d85e516c23
commit 6f37e87a42
6 changed files with 80 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/Microsoft.DotNet.Cli.Utils/CommandResolution/IPackagedCommandSpecFactory.cs
View file

@ -10,8 +10,8 @@ namespace Microsoft.DotNet.Cli.Utils
{
public interface IPackagedCommandSpecFactory
{
CommandSpec CreateCommandSpecFromLibrary(
LockFilePackageLibrary library,
CommandSpec CreateCommandSpecFromRuntimeAssembly(
LockFileTargetLibrary toolLibrary,
string commandName,
IEnumerable<string> commandArguments,
IEnumerable<string> allowedExtensions,

42
src/Microsoft.DotNet.Cli.Utils/CommandResolution/PackagedCommandSpecFactory.cs
View file

@ -2,20 +2,16 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using Microsoft.DotNet.ProjectModel;
using Microsoft.DotNet.ProjectModel.Graph;
using Microsoft.DotNet.ProjectModel.Compilation;
using Microsoft.Extensions.PlatformAbstractions;
using NuGet.Frameworks;
using NuGet.Packaging;
namespace Microsoft.DotNet.Cli.Utils
{
public class PackagedCommandSpecFactory : IPackagedCommandSpecFactory
{
public CommandSpec CreateCommandSpecFromLibrary(
LockFilePackageLibrary library,
public CommandSpec CreateCommandSpecFromRuntimeAssembly(
LockFileTargetLibrary toolLibrary,
string commandName,
IEnumerable<string> commandArguments,
IEnumerable<string> allowedExtensions,
@ -23,22 +19,22 @@ namespace Microsoft.DotNet.Cli.Utils
CommandResolutionStrategy commandResolutionStrategy,
string depsFilePath)
{
var packageDirectory = GetPackageDirectoryFullPath(library, nugetPackagesRoot);
if (!Directory.Exists(packageDirectory))
var toolAssembly = toolLibrary?.RuntimeAssemblies
.FirstOrDefault(r => Path.GetFileNameWithoutExtension(r.Path) == commandName);
if (toolAssembly == null)
{
return null;
}
var commandPath = GetCommandFilePath(nugetPackagesRoot, toolLibrary, toolAssembly);
var commandFile = GetCommandFileRelativePath(library, commandName, allowedExtensions);
if (commandFile == null)
if (!File.Exists(commandPath))
{
return null;
}
var commandPath = Path.Combine(packageDirectory, commandFile);
var isPortable = DetermineIfPortableApp(commandPath);
return CreateCommandSpecWrappingWithCorehostfDll(
@ -50,24 +46,14 @@ namespace Microsoft.DotNet.Cli.Utils
isPortable);
}
private string GetPackageDirectoryFullPath(LockFilePackageLibrary library, string nugetPackagesRoot)
private string GetCommandFilePath(string nugetPackagesRoot, LockFileTargetLibrary toolLibrary, LockFileItem runtimeAssembly)
{
var packageDirectory = new VersionFolderPathResolver(nugetPackagesRoot)
.GetInstallPath(library.Name, library.Version);
.GetInstallPath(toolLibrary.Name, toolLibrary.Version);
return packageDirectory;
}
var filePath = Path.Combine(packageDirectory, runtimeAssembly.Path);
private string GetCommandFileRelativePath(
LockFilePackageLibrary library,
string commandName,
IEnumerable<string> allowedExtensions)
{
// TODO: Should command names be case sensitive?
return library.Files
.Where(f => Path.GetFileNameWithoutExtension(f) == commandName)
.Where(e => allowedExtensions.Contains(Path.GetExtension(e)))
.FirstOrDefault();
return filePath;
}
private CommandSpec CreateCommandSpecWrappingWithCorehostfDll(
@ -102,7 +88,7 @@ namespace Microsoft.DotNet.Cli.Utils
string nugetPackagesRoot,
bool isPortable)
{
string host = string.Empty;
var host = string.Empty;
var arguments = new List<string>();
if (isPortable)

59
src/Microsoft.DotNet.Cli.Utils/CommandResolution/ProjectDependenciesCommandResolver.cs
View file

@ -2,12 +2,10 @@
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using Microsoft.DotNet.ProjectModel;
using Microsoft.DotNet.ProjectModel.Graph;
using Microsoft.Extensions.PlatformAbstractions;
using NuGet.Frameworks;
using NuGet.Packaging;
namespace Microsoft.DotNet.Cli.Utils
{
@ -16,8 +14,8 @@ namespace Microsoft.DotNet.Cli.Utils
private static readonly CommandResolutionStrategy s_commandResolutionStrategy =
CommandResolutionStrategy.ProjectDependenciesPackage;
private IEnvironmentProvider _environment;
private IPackagedCommandSpecFactory _packagedCommandSpecFactory;
private readonly IEnvironmentProvider _environment;
private readonly IPackagedCommandSpecFactory _packagedCommandSpecFactory;
public ProjectDependenciesCommandResolver(
IEnvironmentProvider environment,
@ -80,10 +78,10 @@ namespace Microsoft.DotNet.Cli.Utils
var depsFilePath =
projectContext.GetOutputPaths(configuration, buildBasePath, outputPath).RuntimeFiles.DepsJson;
var dependencyLibraries = GetAllDependencyLibraries(projectContext);
var toolLibrary = GetToolLibraryForContext(projectContext, commandName);
return ResolveFromDependencyLibraries(
dependencyLibraries,
return ResolveFromDependencyLibrary(
toolLibrary,
depsFilePath,
commandName,
allowedExtensions,
@ -91,43 +89,16 @@ namespace Microsoft.DotNet.Cli.Utils
projectContext);
}
private CommandSpec ResolveFromDependencyLibraries(
IEnumerable<LockFilePackageLibrary> dependencyLibraries,
string depsFilePath,
string commandName,
IEnumerable<string> allowedExtensions,
IEnumerable<string> commandArguments,
ProjectContext projectContext)
{
foreach (var dependencyLibrary in dependencyLibraries)
{
var commandSpec = ResolveFromDependencyLibrary(
dependencyLibrary,
depsFilePath,
commandName,
allowedExtensions,
commandArguments,
projectContext);
if (commandSpec != null)
{
return commandSpec;
}
}
return null;
}
private CommandSpec ResolveFromDependencyLibrary(
LockFilePackageLibrary dependencyLibrary,
LockFileTargetLibrary toolLibrary,
string depsFilePath,
string commandName,
IEnumerable<string> allowedExtensions,
IEnumerable<string> commandArguments,
ProjectContext projectContext)
{
return _packagedCommandSpecFactory.CreateCommandSpecFromLibrary(
dependencyLibrary,
return _packagedCommandSpecFactory.CreateCommandSpecFromRuntimeAssembly(
toolLibrary,
commandName,
commandArguments,
allowedExtensions,
@ -136,13 +107,15 @@ namespace Microsoft.DotNet.Cli.Utils
depsFilePath);
}
private IEnumerable<LockFilePackageLibrary> GetAllDependencyLibraries(
ProjectContext projectContext)
private LockFileTargetLibrary GetToolLibraryForContext(
ProjectContext projectContext, string commandName)
{
return projectContext.LibraryManager.GetLibraries()
.Where(l => l.GetType() == typeof(PackageDescription))
.Select(l => l as PackageDescription)
.Select(p => p.Library);
var toolLibrary = projectContext.LockFile.Targets
.FirstOrDefault(t => t.TargetFramework.GetShortFolderName()
.Equals(projectContext.TargetFramework.GetShortFolderName()))
?.Libraries.FirstOrDefault(l => l.Name == commandName);
return toolLibrary;
}
private ProjectContext GetProjectContextFromDirectory(string directory, NuGetFramework framework)

29
src/Microsoft.DotNet.Cli.Utils/CommandResolution/ProjectToolsCommandResolver.cs
View file

@ -95,28 +95,29 @@ namespace Microsoft.DotNet.Cli.Utils
}
private CommandSpec ResolveCommandSpecFromToolLibrary(
LibraryRange toolLibrary,
LibraryRange toolLibraryRange,
string commandName,
IEnumerable<string> args,
ProjectContext projectContext)
{
var nugetPackagesRoot = projectContext.PackagesDirectory;
var lockFile = GetToolLockFile(toolLibraryRange, nugetPackagesRoot);
var lockFile = GetToolLockFile(toolLibrary, nugetPackagesRoot);
var lockFilePackageLibrary = lockFile.PackageLibraries.FirstOrDefault(l => l.Name == toolLibrary.Name);
var toolLibrary = lockFile.Targets
.FirstOrDefault(t => t.TargetFramework.GetShortFolderName().Equals(s_toolPackageFramework.GetShortFolderName()))
?.Libraries.FirstOrDefault(l => l.Name == toolLibraryRange.Name);
if (toolLibrary == null)
{
return null;
}
var depsFileRoot = Path.GetDirectoryName(lockFile.LockFilePath);
var depsFilePath = GetToolDepsFilePath(toolLibrary, lockFile, depsFileRoot);
var toolProjectContext = new ProjectContextBuilder()
.WithLockFile(lockFile)
.WithTargetFramework(s_toolPackageFramework.ToString())
.Build();
var exporter = toolProjectContext.CreateExporter(Constants.DefaultConfiguration);
return _packagedCommandSpecFactory.CreateCommandSpecFromLibrary(
lockFilePackageLibrary,
var depsFilePath = GetToolDepsFilePath(toolLibraryRange, lockFile, depsFileRoot);
return _packagedCommandSpecFactory.CreateCommandSpecFromRuntimeAssembly(
toolLibrary,
commandName,
args,
_allowedCommandExtensions,