public static IEnumerable <PackageReference> GetAssemblyPackageReferences(
this PackageConfiguration configuration,
IEnumerable <string> assemblyNames,
IDictionary <string, PackageReference> packageMap)
{
var dependencies = new List <PackageReference>();
foreach (var assemblyName in assemblyNames)
{
var assemblyLocation = GetAssemblyLocation(configuration, assemblyName);
if (assemblyLocation != null)
{
var pathElements = assemblyLocation.Split(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
if (pathElements.Length > 1 && pathElements[0] == RepositoryPath)
{
if (packageMap.TryGetValue(pathElements[1], out PackageReference package))
{
dependencies.Add(package);
}
}
}
}
return(dependencies);
}
public static void RegisterPath(this PackageConfiguration configuration, string path)
{
if (!Directory.Exists(path))
{
return;
}
var platform = GetEnvironmentPlatform();
if (!configuration.LibraryFolders.Contains(path))
{
configuration.LibraryFolders.Add(path, platform);
}
else if (configuration.LibraryFolders[path].Platform != platform)
{
var message = string.Format("The library path '{0}' is already registered for a different platform.", path);
throw new InvalidOperationException(message);
}
foreach (var assemblyFile in Directory.GetFiles(path, "*.dll"))
{
AssemblyName assemblyName;
try { assemblyName = AssemblyName.GetAssemblyName(assemblyFile); }
catch (BadImageFormatException) { continue; }
catch (IOException) { continue; }
var locationKey = Tuple.Create(assemblyName.Name, assemblyName.ProcessorArchitecture);
if (!configuration.AssemblyLocations.Contains(locationKey))
{
configuration.AssemblyReferences.Add(assemblyName.Name);
configuration.AssemblyLocations.Add(assemblyName.Name, assemblyName.ProcessorArchitecture, assemblyFile);
}
}
}
public ScriptExtensions(PackageConfiguration configuration, string outputPath)
{
packageConfiguration = configuration;
packageMap = configuration.GetPackageReferenceMap();
assemblyFolder = new TempDirectory(outputPath);
ProjectFileName = Path.GetFullPath(DefaultProjectFileName);
}
static IEnumerable <PackageReference> GetMissingPackages(PackageConfiguration packageConfiguration, SourceRepository repository)
{
return(from package in packageConfiguration.Packages
let version = ParseVersion(package.Version)
where !repository.Exists(new PackageIdentity(package.Id, version))
select package);
}
public async Task RunAsync(
NuGetFramework projectFramework,
PackageConfiguration packageConfiguration,
string bootstrapperPath,
PackageIdentity bootstrapperPackage)
{
const string OldExtension = ".old";
var backupExePath = bootstrapperPath + OldExtension;
if (File.Exists(backupExePath))
{
try { File.Delete(backupExePath); }
catch { } // best effort
}
var missingPackages = GetMissingPackages(packageConfiguration, packageManager.LocalRepository).ToList();
if (missingPackages.Count > 0)
{
async Task RestoreMissingPackages()
{
using var monitor = new PackageConfigurationUpdater(
projectFramework,
packageConfiguration,
packageManager,
bootstrapperPath,
bootstrapperPackage);
foreach (var package in missingPackages)
{
await packageManager.StartRestorePackage(package.Id, ParseVersion(package.Version), projectFramework);
}
};
packageManager.RestorePackages = true;
try { await RunPackageOperationAsync(RestoreMissingPackages); }
finally { packageManager.RestorePackages = false; }
}
var editorPackage = packageManager.LocalRepository.FindLocalPackage(bootstrapperPackage.Id);
if (editorPackage == null || editorPackage.Identity.Version < bootstrapperPackage.Version)
{
async Task RestoreEditorPackage()
{
using var monitor = new PackageConfigurationUpdater(
projectFramework,
packageConfiguration,
packageManager,
bootstrapperPath,
bootstrapperPackage);
var package = await packageManager.StartInstallPackage(bootstrapperPackage.Id, bootstrapperPackage.Version, projectFramework);
editorPackage = packageManager.LocalRepository.GetLocalPackage(package.GetIdentity());
};
await RunPackageOperationAsync(RestoreEditorPackage);
}
}
public static void SetAssemblyResolve(PackageConfiguration configuration)
{
var platform = GetEnvironmentPlatform();
var configurationRoot = GetConfigurationRoot(configuration);
foreach (var libraryFolder in configuration.LibraryFolders)
{
if (libraryFolder.Platform == platform)
{
var libraryPath = libraryFolder.Path;
if (!Path.IsPathRooted(libraryPath))
{
libraryPath = Path.Combine(configurationRoot, libraryPath);
}
AddLibraryPath(libraryPath);
}
}
Dictionary <string, Assembly> assemblyLoadCache = null;
ResolveEventHandler assemblyResolveHandler = (sender, args) =>
{
var assemblyName = new AssemblyName(args.Name).Name;
var assemblyLocation = GetAssemblyLocation(configuration, assemblyName);
if (assemblyLocation != null)
{
Uri uri;
if (assemblyLocation.StartsWith(Uri.UriSchemeFile) && Uri.TryCreate(assemblyLocation, UriKind.Absolute, out uri))
{
Assembly assembly;
assemblyLoadCache = assemblyLoadCache ?? new Dictionary <string, Assembly>();
if (!assemblyLoadCache.TryGetValue(uri.LocalPath, out assembly))
{
var assemblyBytes = File.ReadAllBytes(uri.LocalPath);
assembly = Assembly.Load(assemblyBytes);
assemblyLoadCache.Add(uri.LocalPath, assembly);
}
return(assembly);
}
if (!Path.IsPathRooted(assemblyLocation))
{
assemblyLocation = Path.Combine(configurationRoot, assemblyLocation);
}
if (File.Exists(assemblyLocation))
{
return(Assembly.LoadFrom(assemblyLocation));
}
}
return(null);
};
AppDomain.CurrentDomain.AssemblyResolve += assemblyResolveHandler;
}
public static void Save(this PackageConfiguration configuration, string fileName = null)
{
if (fileName == null)
{
fileName = configuration.ConfigurationFile ?? GetDefaultConfigurationFilePath();
}
var serializer = new XmlSerializer(typeof(PackageConfiguration));
using (var writer = XmlWriter.Create(fileName, new XmlWriterSettings {
Indent = true
}))
{
serializer.Serialize(writer, configuration);
configuration.ConfigurationFile = fileName;
}
}
public static string GetAssemblyLocation(this PackageConfiguration configuration, string assemblyName)
{
var msilAssembly = Tuple.Create(assemblyName, ProcessorArchitecture.MSIL);
if (configuration.AssemblyLocations.Contains(msilAssembly))
{
return(configuration.AssemblyLocations[msilAssembly].Location);
}
var architectureSpecificAssembly = Tuple.Create(assemblyName, Environment.Is64BitProcess ? ProcessorArchitecture.Amd64 : ProcessorArchitecture.X86);
if (configuration.AssemblyLocations.Contains(architectureSpecificAssembly))
{
return(configuration.AssemblyLocations[architectureSpecificAssembly].Location);
}
return(null);
}
public PackageConfigurationUpdater(NuGetFramework projectFramework, PackageConfiguration configuration, IPackageManager manager, string bootstrapperPath = null, PackageIdentity bootstrapperName = null)
{
packageManager = manager ?? throw new ArgumentNullException(nameof(manager));
packageConfiguration = configuration ?? throw new ArgumentNullException(nameof(configuration));
bootstrapperFramework = projectFramework ?? throw new ArgumentNullException(nameof(projectFramework));
bootstrapperExePath = bootstrapperPath ?? string.Empty;
bootstrapperDirectory = Path.GetDirectoryName(bootstrapperExePath);
bootstrapperPackageId = bootstrapperName != null ? bootstrapperName.Id : string.Empty;
bootstrapperVersion = bootstrapperName?.Version;
configurationPlugin = new PackageConfigurationPlugin(this);
packageManager.PackageManagerPlugins.Add(configurationPlugin);
var galleryPath = Path.Combine(bootstrapperDirectory, GalleryDirectory);
var galleryPackageSource = new PackageSource(galleryPath);
galleryRepository = new SourceRepository(galleryPackageSource, Repository.Provider.GetCoreV3());
bootstrapperFramework = projectFramework;
}
public static IDictionary <string, PackageReference> GetPackageReferenceMap(this PackageConfiguration configuration)
{
var baseDirectory = Path.GetDirectoryName(configuration.ConfigurationFile);
var rootDirectory = Path.Combine(baseDirectory, RepositoryPath);
var pathResolver = new PackagePathResolver(rootDirectory);
var packageMap = new Dictionary <string, PackageReference>();
foreach (var package in configuration.Packages)
{
var identity = new PackageIdentity(package.Id, NuGetVersion.Parse(package.Version));
var packagePath = pathResolver.GetPackageDirectoryName(identity);
if (packagePath != null)
{
packageMap.Add(packagePath, package);
}
}
return(packageMap);
}
public static string GetConfigurationRoot(PackageConfiguration configuration = null)
{
return(configuration == null || string.IsNullOrWhiteSpace(configuration.ConfigurationFile)
? Path.GetDirectoryName(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile)
: Path.GetDirectoryName(configuration.ConfigurationFile));
}
public static ScriptExtensions CompileAssembly(
NuGetFramework projectFramework,
PackageConfiguration configuration,
string editorRepositoryPath,
bool includeDebugInformation)
{
var path = Environment.CurrentDirectory;
var configurationRoot = ConfigurationHelper.GetConfigurationRoot(configuration);
var scriptProjectFile = Path.Combine(path, Path.ChangeExtension(OutputAssemblyName, ProjectExtension));
if (!File.Exists(scriptProjectFile))
{
return(new ScriptExtensions(configuration, null));
}
var extensionsPath = Path.Combine(path, OutputAssemblyName);
if (!Directory.Exists(extensionsPath))
{
return(new ScriptExtensions(configuration, null));
}
var scriptFiles = Directory.GetFiles(extensionsPath, ScriptExtension, SearchOption.AllDirectories);
if (scriptFiles.Length == 0)
{
return(new ScriptExtensions(configuration, null));
}
var assemblyNames = new HashSet <string>();
var assemblyDirectory = Path.GetTempPath() + OutputAssemblyName + "." + Guid.NewGuid().ToString();
var scriptEnvironment = new ScriptExtensions(configuration, assemblyDirectory);
var packageSource = new PackageSource(editorRepositoryPath);
var packageRepository = new SourceRepository(packageSource, Repository.Provider.GetCoreV3());
var dependencyResource = packageRepository.GetResource <DependencyInfoResource>();
var localPackageResource = packageRepository.GetResource <FindLocalPackagesResource>();
using (var cacheContext = new SourceCacheContext())
{
var projectReferences = from id in scriptEnvironment.GetPackageReferences()
from assemblyReference in FindAssemblyReferences(
projectFramework,
dependencyResource,
localPackageResource,
cacheContext,
packageId: id)
select assemblyReference;
assemblyNames.AddRange(scriptEnvironment.GetAssemblyReferences());
assemblyNames.AddRange(projectReferences);
}
var assemblyFile = Path.Combine(assemblyDirectory, Path.ChangeExtension(OutputAssemblyName, DllExtension));
var assemblyReferences = (from fileName in assemblyNames
let assemblyName = Path.GetFileNameWithoutExtension(fileName)
let assemblyLocation = ConfigurationHelper.GetAssemblyLocation(configuration, assemblyName)
select assemblyLocation == null ? fileName :
Path.IsPathRooted(assemblyLocation) ? assemblyLocation :
Path.Combine(configurationRoot, assemblyLocation))
.ToArray();
var compilerParameters = new CompilerParameters(assemblyReferences, assemblyFile);
compilerParameters.GenerateExecutable = false;
compilerParameters.GenerateInMemory = false;
compilerParameters.IncludeDebugInformation = includeDebugInformation;
if (!includeDebugInformation)
{
compilerParameters.CompilerOptions = "/optimize";
}
using (var codeProvider = new CSharpCodeProvider())
{
var results = codeProvider.CompileAssemblyFromFile(compilerParameters, scriptFiles);
if (results.Errors.HasErrors)
{
try
{
Console.Error.WriteLine("--- Error building script extensions ---");
foreach (var error in results.Errors)
{
Console.Error.WriteLine(error);
}
}
finally { scriptEnvironment.Dispose(); }
return(new ScriptExtensions(configuration, null));
}
else
{
var assemblyName = AssemblyName.GetAssemblyName(assemblyFile);
configuration.AssemblyReferences.Add(assemblyName.Name);
configuration.AssemblyLocations.Add(assemblyName.Name, ProcessorArchitecture.MSIL, assemblyName.CodeBase);
scriptEnvironment.AssemblyName = assemblyName;
}
return(scriptEnvironment);
}
}
