public bool TryPrepareForPublish() { if (Framework != null) { NugetFramework = NuGetFramework.Parse(Framework); if (NugetFramework.IsUnsupported) { Reporter.Output.WriteLine($"Unsupported framework {Framework}.".Red()); return(false); } } ProjectContexts = ProjectContext.CreateContextForEachTarget(ProjectPath); ProjectContexts = GetMatchingProjectContexts(ProjectContexts, NugetFramework, Runtime); if (ProjectContexts.Count() == 0) { string errMsg = $"'{ProjectPath}' cannot be published for '{Framework ?? "<no framework provided>"}' '{Runtime ?? "<no runtime provided>"}'"; Reporter.Output.WriteLine(errMsg.Red()); return(false); } return(true); }
private static List <ProjectContext> LoadProjectContexts(string[] projectFiles) { var projectContexts = new List <ProjectContext>(); foreach (var file in projectFiles) { var fileTargetContexts = ProjectContext.CreateContextForEachTarget(file); projectContexts.AddRange(fileTargetContexts); } return(projectContexts); }
private IEnumerable <ProjectContext> TryCreateRuntimeContextsFromScriptFiles() { _logger.LogInformation($"Attempting to create runtime context from script files. Default target framework {_targetFrameWork.Value}"); try { var scriptProjectInfo = _scriptProjectProvider.CreateProject(_env.TargetDirectory, _targetFrameWork.Value); return(ProjectContext.CreateContextForEachTarget(Path.GetDirectoryName(scriptProjectInfo.PathToProjectJson))); } catch (Exception exception) { _logger.LogError(exception, "Unable to create runtime context from script files."); } return(null); }
private ProjectContext GetProjectContextFromDirectoryForFirstTarget(string projectRootPath) { if (projectRootPath == null) { return(null); } if (!File.Exists(Path.Combine(projectRootPath, Project.FileName))) { return(null); } var projectContext = ProjectContext.CreateContextForEachTarget(projectRootPath).FirstOrDefault(); return(projectContext); }
private IEnumerable <ProjectContext> SelectContexts(string projectPath, NuGetFramework framework, string runtime) { var allContexts = ProjectContext.CreateContextForEachTarget(projectPath).ToList(); var frameworks = framework == null? allContexts.Select(c => c.TargetFramework).Distinct().ToArray() : new[] { framework }; if (string.IsNullOrEmpty(runtime)) { // For each framework, find the best matching RID item var candidates = PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers(); return(frameworks.Select(f => FindBestTarget(f, allContexts, candidates))); } else { return(frameworks.SelectMany(f => allContexts.Where(c => Equals(c.TargetFramework, f) && string.Equals(c.RuntimeIdentifier, runtime, StringComparison.Ordinal)))); } }
public IEnumerable <RuntimeDependency> GetRuntimeDependencies(string projectFile) { var workingDirectory = Path.GetDirectoryName(projectFile); var runtimeContext = ProjectContext.CreateContextForEachTarget(workingDirectory).FirstOrDefault(); var projectExporter = runtimeContext.CreateExporter("release"); var runtimeIdentifier = RuntimeHelper.GetPlatformIdentifier(); var runtimeDependencies = new HashSet <RuntimeDependency>(); var projectDependencies = projectExporter.GetDependencies(); foreach (var projectDependency in projectDependencies) { var runtimeAssemblyGroups = projectDependency.RuntimeAssemblyGroups; foreach (var libraryAsset in runtimeAssemblyGroups.GetDefaultAssets()) { var runtimeAssemblyPath = libraryAsset.ResolvedPath; _logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'"); var runtimeDependency = new RuntimeDependency(libraryAsset.Name, libraryAsset.ResolvedPath); runtimeDependencies.Add(runtimeDependency); } foreach (var runtimeAssemblyGroup in runtimeAssemblyGroups) { if (!string.IsNullOrWhiteSpace(runtimeAssemblyGroup.Runtime) && runtimeAssemblyGroup.Runtime == runtimeIdentifier) { foreach (var runtimeAsset in runtimeAssemblyGroups.GetRuntimeAssets(runtimeIdentifier)) { var runtimeAssetPath = runtimeAsset.ResolvedPath; _logger.Verbose($"Discovered runtime asset dependency ('{runtimeIdentifier}') for '{runtimeAssetPath}'"); var runtimeDependency = new RuntimeDependency(runtimeAsset.Name, runtimeAsset.ResolvedPath); runtimeDependencies.Add(runtimeDependency); } } } } return(runtimeDependencies); }
private static IEnumerable <ProjectContext> SelectContexts(string projectPath, NuGetFramework framework, string runtime) { var allContexts = ProjectContext.CreateContextForEachTarget(projectPath); if (string.IsNullOrEmpty(runtime)) { // Nothing was specified, so figure out what the candidate runtime identifiers are and try each of them // Temporary until #619 is resolved foreach (var candidate in PlatformServices.Default.Runtime.GetAllCandidateRuntimeIdentifiers()) { var contexts = GetMatchingProjectContexts(allContexts, framework, candidate); if (contexts.Any()) { return(contexts); } } return(Enumerable.Empty <ProjectContext>()); } else { return(GetMatchingProjectContexts(allContexts, framework, runtime)); } }
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var runtimeIdentitfer = GetRuntimeIdentitifer(); _logger.Verbose($"Current runtime is '{runtimeIdentitfer}'."); var opts = CreateScriptOptions(context); var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier(); var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x => x.FullName.StartsWith("system.", StringComparison.OrdinalIgnoreCase) || x.FullName.StartsWith("microsoft.codeanalysis", StringComparison.OrdinalIgnoreCase) || x.FullName.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase)); foreach (var inheritedAssemblyName in inheritedAssemblyNames) { _logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName); var assembly = Assembly.Load(inheritedAssemblyName); opts = opts.AddReferences(assembly); } var runtimeContext = File.Exists(Path.Combine(context.WorkingDirectory, Project.FileName)) ? ProjectContext.CreateContextForEachTarget(context.WorkingDirectory).FirstOrDefault() : null; if (runtimeContext == null) { _logger.Verbose("Unable to find project context for CSX files. Will default to non-context usage."); var scriptProjectProvider = ScriptProjectProvider.Create(new LoggerFactory()); var scriptProjectInfo = scriptProjectProvider.CreateProject(context.WorkingDirectory, "netcoreapp1.1"); runtimeContext = ProjectContext.CreateContextForEachTarget(scriptProjectInfo.PathToProjectJson).FirstOrDefault(); } _logger.Verbose($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'."); var projectExporter = runtimeContext.CreateExporter(context.Configuration); var runtimeDependencies = new HashSet <string>(); var projectDependencies = projectExporter.GetDependencies(); foreach (var projectDependency in projectDependencies) { var runtimeAssemblyGroups = projectDependency.RuntimeAssemblyGroups; foreach (var libraryAsset in runtimeAssemblyGroups.GetDefaultAssets()) { var runtimeAssemblyPath = libraryAsset.ResolvedPath; _logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'"); runtimeDependencies.Add(runtimeAssemblyPath); } foreach (var runtimeAssemblyGroup in runtimeAssemblyGroups) { if (!string.IsNullOrWhiteSpace(runtimeAssemblyGroup.Runtime) && runtimeAssemblyGroup.Runtime == runtimeIdentitfer) { foreach (var runtimeAsset in runtimeAssemblyGroups.GetRuntimeAssets(GetRuntimeIdentitifer())) { var runtimeAssetPath = runtimeAsset.ResolvedPath; _logger.Verbose($"Discovered runtime asset dependency ('{runtimeIdentitfer}') for '{runtimeAssetPath}'"); runtimeDependencies.Add(runtimeAssetPath); } } } } foreach (var runtimeDep in runtimeDependencies) { _logger.Verbose("Adding reference to a runtime dependency => " + runtimeDep); opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep)); } var loader = new InteractiveAssemblyLoader(); var script = CSharpScript.Create <TReturn>(context.Code.ToString(), opts, typeof(THost), loader); var orderedDiagnostics = script.GetDiagnostics(SuppressedDiagnosticIds); if (orderedDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)) { foreach (var diagnostic in orderedDiagnostics) { _logger.Log(diagnostic.ToString()); } throw new CompilationErrorException("Script compilation failed due to one or more errors.", orderedDiagnostics.ToImmutableArray()); } return(new ScriptCompilationContext <TReturn>(script, context.Code, loader)); }
private static void RunScript(string file, string config, bool debugMode, List <string> scriptArgs) { if (debugMode) { Console.WriteLine($"Using debug mode."); Console.WriteLine($"Using configuration: {config}"); } if (!File.Exists(file)) { Console.WriteLine($"Couldn't find file '{file}'"); return; } var directory = Path.IsPathRooted(file) ? Path.GetDirectoryName(file) : Directory.GetCurrentDirectory(); var runtimeContext = ProjectContext.CreateContextForEachTarget(directory).First(); if (debugMode) { Console.WriteLine($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'"); } var projectExporter = runtimeContext.CreateExporter(config); var runtimeDependencies = new HashSet <string>(); var projectDependencies = projectExporter.GetDependencies(); foreach (var projectDependency in projectDependencies) { var runtimeAssemblies = projectDependency.RuntimeAssemblyGroups; foreach (var runtimeAssembly in runtimeAssemblies.GetDefaultAssets()) { var runtimeAssemblyPath = runtimeAssembly.ResolvedPath; if (debugMode) { Console.WriteLine($"Discovered runtime dependency for '{runtimeAssemblyPath}'"); } runtimeDependencies.Add(runtimeAssemblyPath); } } var code = File.ReadAllText(file); var opts = ScriptOptions.Default. AddImports(_namespaces). AddReferences(_assemblies). AddReferences(typeof(ScriptingHost).GetTypeInfo().Assembly). WithSourceResolver(new RemoteFileResolver(directory)); var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier(); var assemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x => x.FullName.ToLowerInvariant().StartsWith("system.") || x.FullName.ToLowerInvariant().StartsWith("mscorlib")); foreach (var assemblyName in assemblyNames) { if (debugMode) { Console.WriteLine("Adding reference to a default dependency => " + assemblyName.FullName); } var assembly = Assembly.Load(assemblyName); opts = opts.AddReferences(assembly); } foreach (var runtimeDep in runtimeDependencies) { if (debugMode) { Console.WriteLine("Adding reference to a runtime dependency => " + runtimeDep); } opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep)); } var script = CSharpScript.Create(code, opts, typeof(ScriptingHost)); var compilation = script.GetCompilation(); var diagnostics = compilation.GetDiagnostics(); if (diagnostics.Any()) { foreach (var diagnostic in diagnostics) { Console.Write("There is an error in the script."); Console.WriteLine(diagnostic.GetMessage()); } } else { var host = new ScriptingHost { CurrentDirectory = directory, CurrentScript = file, ScriptArgs = scriptArgs }; var scriptResult = script.RunAsync(host).Result; if (scriptResult.Exception != null) { Console.Write("Script execution resulted in an exception."); Console.WriteLine(scriptResult.Exception.Message); Console.WriteLine(scriptResult.Exception.StackTrace); } } }
public static void Main(string[] args) { var directory = args.Length == 0 ? Directory.GetCurrentDirectory() : Path.GetFullPath(args[0]); // Pick the corret runtime id (based on something) // Compile time context var compileTimeContext = ProjectContext.CreateContextForEachFramework(directory).First(); Console.WriteLine($"TFM: {compileTimeContext.TargetFramework}"); var workspace = compileTimeContext.CreateWorkspace(); var projects = new Dictionary <string, ProjectId>(); foreach (var project in workspace.CurrentSolution.Projects) { // Projects have the name {name+tfm} projects[project.AssemblyName] = project.Id; } // Runtime context var runtimeContext = ProjectContext.CreateContextForEachTarget(directory).Last(); Console.WriteLine($"TFM + RID: {runtimeContext.TargetFramework} {runtimeContext.RuntimeIdentifier}"); var exporter = runtimeContext.CreateExporter("Debug"); var assemblies = new Dictionary <AssemblyName, string>(AssemblyNameComparer.OrdinalIgnoreCase); var dllImports = new Dictionary <string, string>(); foreach (var export in exporter.GetAllExports()) { if (export.Library is ProjectDescription) { continue; } // TODO: Handle resource assemblies foreach (var asset in export.RuntimeAssemblies) { var assemblyName = new AssemblyName(asset.Name); assemblies[assemblyName] = asset.ResolvedPath; } foreach (var asset in export.NativeLibraries) { dllImports[asset.Name] = asset.ResolvedPath; } } var loadContext = new DynamicLoadContext(workspace, projects, dllImports); // We need to force load all assemblies in the load context since we don't want // things to transitively fall back to the default load context foreach (var asm in assemblies) { try { // Force load the assemblies loadContext.LoadFile(asm.Value); } catch { // It's in the TPA list Console.WriteLine($"Failed to load assembly {asm.Key}. It's in the TPA list"); } } var assembly = loadContext.LoadFromAssemblyName(new AssemblyName(compileTimeContext.ProjectFile.Name)); if (assembly.EntryPoint != null) { assembly.EntryPoint.Invoke(null, new object[] { args.Skip(1).ToArray() }); } }
public void Initalize(IConfiguration configuration) { var scriptHelper = new ScriptHelper(configuration); _logger.LogInformation($"Detecting CSX files in '{_env.TargetDirectory}'."); // Nothing to do if there are no CSX files var allCsxFiles = Directory.GetFiles(_env.TargetDirectory, "*.csx", SearchOption.AllDirectories); if (allCsxFiles.Length == 0) { _logger.LogInformation("Could not find any CSX files"); return; } _logger.LogInformation($"Found {allCsxFiles.Length} CSX files."); // explicitly inherit scripting library references to all global script object (CommandLineScriptGlobals) to be recognized var inheritedCompileLibraries = DependencyContext.Default.CompileLibraries.Where(x => x.Name.ToLowerInvariant().StartsWith("microsoft.codeanalysis")).ToList(); // explicitly include System.ValueTuple inheritedCompileLibraries.AddRange(DependencyContext.Default.CompileLibraries.Where(x => x.Name.ToLowerInvariant().StartsWith("system.valuetuple"))); var runtimeContexts = File.Exists(Path.Combine(_env.TargetDirectory, "project.json")) ? ProjectContext.CreateContextForEachTarget(_env.TargetDirectory) : null; if (!bool.TryParse(configuration["enableScriptNuGetReferences"], out var enableScriptNuGetReferences)) { enableScriptNuGetReferences = false; } if (enableScriptNuGetReferences && (runtimeContexts == null || runtimeContexts.Any() == false)) { runtimeContexts = TryCreateRuntimeContextsFromScriptFiles(); } var runtimeContext = runtimeContexts?.FirstOrDefault(); var commonReferences = new HashSet <MetadataReference>(); // if we have no context, then we also have no dependencies // we will assume desktop framework // and add default CLR references // same applies for having a context that is not a .NET Core app AddDefaultClrMetadataReferences(runtimeContext, commonReferences); if (runtimeContext == null) { _logger.LogInformation("Unable to find project context for CSX files. Will default to non-context usage (Destkop CLR scripts)."); } // otherwise we will grab dependencies for the script from the runtime context else { // assume the first one _logger.LogInformation($"Found script runtime context '{runtimeContext.TargetFramework.Framework}' for '{runtimeContext.ProjectFile.ProjectFilePath}'."); var projectExporter = runtimeContext.CreateExporter("Release"); var projectDependencies = projectExporter.GetDependencies(); // let's inject all compilation assemblies needed var compilationAssemblies = projectDependencies.SelectMany(x => x.CompilationAssemblies); foreach (var compilationAssembly in compilationAssemblies) { _logger.LogDebug("Discovered script compilation assembly reference: " + compilationAssembly.ResolvedPath); AddMetadataReference(commonReferences, compilationAssembly.ResolvedPath); } } // inject all inherited assemblies foreach (var inheritedCompileLib in inheritedCompileLibraries.SelectMany(x => x.ResolveReferencePaths())) { _logger.LogDebug("Adding implicit reference: " + inheritedCompileLib); AddMetadataReference(commonReferences, inheritedCompileLib); } // Each .CSX file becomes an entry point for it's own project // Every #loaded file will be part of the project too foreach (var csxPath in allCsxFiles) { try { var csxFileName = Path.GetFileName(csxPath); var project = scriptHelper.CreateProject(csxFileName, commonReferences); // add CSX project to workspace _workspace.AddProject(project); _workspace.AddDocument(project.Id, csxPath, SourceCodeKind.Script); _projects[csxPath] = project; _logger.LogInformation($"Added CSX project '{csxPath}' to the workspace."); } catch (Exception ex) { _logger.LogError(ex, $"{csxPath} will be ignored due to an following error"); } } }
public ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var runtimeContext = ProjectContext.CreateContextForEachTarget(context.WorkingDirectory).First(); _logger.Verbose($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'"); var projectExporter = runtimeContext.CreateExporter(context.Configuration); var runtimeDependencies = new HashSet <string>(); var projectDependencies = projectExporter.GetDependencies(); foreach (var projectDependency in projectDependencies) { var runtimeAssemblies = projectDependency.RuntimeAssemblyGroups; foreach (var runtimeAssembly in runtimeAssemblies.GetDefaultAssets()) { var runtimeAssemblyPath = runtimeAssembly.ResolvedPath; _logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'"); runtimeDependencies.Add(runtimeAssemblyPath); } } var opts = ScriptOptions.Default. AddImports(DefaultNamespaces). AddReferences(DefaultAssemblies). WithSourceResolver(new RemoteFileResolver(context.WorkingDirectory)); if (!string.IsNullOrWhiteSpace(context.FilePath)) { opts = opts.WithFilePath(context.FilePath); } var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier(); var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x => x.FullName.ToLowerInvariant().StartsWith("system.") || x.FullName.ToLowerInvariant().StartsWith("microsoft.codeanalysis") || x.FullName.ToLowerInvariant().StartsWith("mscorlib")); foreach (var inheritedAssemblyName in inheritedAssemblyNames) { _logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName); var assembly = Assembly.Load(inheritedAssemblyName); opts = opts.AddReferences(assembly); } foreach (var runtimeDep in runtimeDependencies) { _logger.Verbose("Adding reference to a runtime dependency => " + runtimeDep); opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep)); } var loader = new InteractiveAssemblyLoader(); var script = CSharpScript.Create <TReturn>(context.Code.ToString(), opts, typeof(THost), loader); var compilation = script.GetCompilation(); var diagnostics = compilation.GetDiagnostics(); if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)) { foreach (var diagnostic in diagnostics) { _logger.Log(diagnostic.ToString()); } throw new CompilationErrorException("Script compilation failed due to one or more errors.", diagnostics); } return(new ScriptCompilationContext <TReturn>(script, context.Code, loader)); }
public virtual ScriptCompilationContext <TReturn> CreateCompilationContext <TReturn, THost>(ScriptContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var runtimeContext = ProjectContext.CreateContextForEachTarget(context.WorkingDirectory).First(); var runtimeIdentitfer = GetRuntimeIdentitifer(); _logger.Verbose($"Current runtime is '{runtimeIdentitfer}'."); _logger.Verbose($"Found runtime context for '{runtimeContext.ProjectFile.ProjectFilePath}'."); var projectExporter = runtimeContext.CreateExporter(context.Configuration); var runtimeDependencies = new HashSet <string>(); var projectDependencies = projectExporter.GetDependencies(); foreach (var projectDependency in projectDependencies) { var runtimeAssemblyGroups = projectDependency.RuntimeAssemblyGroups; foreach (var libraryAsset in runtimeAssemblyGroups.GetDefaultAssets()) { var runtimeAssemblyPath = libraryAsset.ResolvedPath; _logger.Verbose($"Discovered runtime dependency for '{runtimeAssemblyPath}'"); runtimeDependencies.Add(runtimeAssemblyPath); } foreach (var runtimeAssemblyGroup in runtimeAssemblyGroups) { if (!string.IsNullOrWhiteSpace(runtimeAssemblyGroup.Runtime) && runtimeAssemblyGroup.Runtime == runtimeIdentitfer) { foreach (var runtimeAsset in runtimeAssemblyGroups.GetRuntimeAssets(GetRuntimeIdentitifer())) { var runtimeAssetPath = runtimeAsset.ResolvedPath; _logger.Verbose($"Discovered runtime asset dependency ('{runtimeIdentitfer}') for '{runtimeAssetPath}'"); runtimeDependencies.Add(runtimeAssetPath); } } } } var opts = CreateScriptOptions(context); var runtimeId = RuntimeEnvironment.GetRuntimeIdentifier(); var inheritedAssemblyNames = DependencyContext.Default.GetRuntimeAssemblyNames(runtimeId).Where(x => x.FullName.StartsWith("system.", StringComparison.OrdinalIgnoreCase) || x.FullName.StartsWith("microsoft.codeanalysis", StringComparison.OrdinalIgnoreCase) || x.FullName.StartsWith("mscorlib", StringComparison.OrdinalIgnoreCase)); foreach (var inheritedAssemblyName in inheritedAssemblyNames) { _logger.Verbose("Adding reference to an inherited dependency => " + inheritedAssemblyName.FullName); var assembly = Assembly.Load(inheritedAssemblyName); opts = opts.AddReferences(assembly); } foreach (var runtimeDep in runtimeDependencies) { _logger.Verbose("Adding reference to a runtime dependency => " + runtimeDep); opts = opts.AddReferences(MetadataReference.CreateFromFile(runtimeDep)); } var loader = new InteractiveAssemblyLoader(); var script = CSharpScript.Create <TReturn>(context.Code.ToString(), opts, typeof(THost), loader); var compilation = script.GetCompilation(); var diagnostics = compilation.GetDiagnostics(); var orderedDiagnostics = diagnostics.OrderBy((d1, d2) => { var severityDiff = (int)d2.Severity - (int)d1.Severity; return(severityDiff != 0 ? severityDiff : d1.Location.SourceSpan.Start - d2.Location.SourceSpan.Start); }); if (orderedDiagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)) { foreach (var diagnostic in orderedDiagnostics) { _logger.Log(diagnostic.ToString()); } throw new CompilationErrorException("Script compilation failed due to one or more errors.", orderedDiagnostics.ToImmutableArray()); } return(new ScriptCompilationContext <TReturn>(script, context.Code, loader)); }