public RuntimeDependencyResolver(ScriptProjectProvider scriptProjectProvider, LogFactory logFactory, ScriptEnvironment scriptEnvironment, bool useRestoreCache)
{
_scriptProjectProvider = scriptProjectProvider;
_scriptEnvironment = scriptEnvironment;
_dependencyContextReader = new ScriptDependencyContextReader(logFactory);
_restorer = CreateRestorer(logFactory, useRestoreCache);
}
public CompilationDependencyResolver(ScriptProjectProvider scriptProjectProvider, ScriptDependencyContextReader scriptDependencyContextReader, ICompilationReferenceReader compilationReferenceReader, LogFactory logFactory)
{
_scriptProjectProvider = scriptProjectProvider;
this._scriptDependencyContextReader = scriptDependencyContextReader;
_compilationReferenceReader = compilationReferenceReader;
_restorer = CreateRestorer(logFactory);
}
public bool TryCreateHash(ExecuteScriptCommandOptions options, out string hash)
{
if (options.NoCache)
{
_logger.Debug($"The script {options.File.Path} was executed with the '--no-cache' flag. Skipping cache.");
hash = null;
return(false);
}
var scriptFilesProvider = new ScriptFilesResolver();
var allScriptFiles = scriptFilesProvider.GetScriptFiles(options.File.Path);
var projectFile = new ScriptProjectProvider(_logFactory).CreateProjectFileFromScriptFiles(ScriptEnvironment.Default.TargetFramework, allScriptFiles.ToArray());
if (!projectFile.IsCacheable)
{
_logger.Warning($"The script {options.File.Path} is not cacheable. For caching and optimal performance, ensure that the script only contains NuGet references with pinned/exact versions.");
hash = null;
return(false);
}
IncrementalHash incrementalHash = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
foreach (var scriptFile in allScriptFiles)
{
incrementalHash.AppendData(File.ReadAllBytes(scriptFile));
}
var configuration = options.OptimizationLevel.ToString();
incrementalHash.AppendData(Encoding.UTF8.GetBytes(configuration));
hash = Convert.ToBase64String(incrementalHash.GetHashAndReset());
return(true);
}
public void CreateExecutable <TReturn, THost>(ScriptContext context, LogFactory logFactory, string runtimeIdentifier)
{
if (runtimeIdentifier == null)
{
throw new ArgumentNullException(nameof(runtimeIdentifier));
}
const string AssemblyName = "scriptAssembly";
var tempProjectPath = ScriptProjectProvider.GetPathToProjectFile(Path.GetDirectoryName(context.FilePath));
var tempProjectDirectory = Path.GetDirectoryName(tempProjectPath);
var scriptAssemblyPath = CreateScriptAssembly <TReturn, THost>(context, tempProjectDirectory, AssemblyName);
var projectFile = new ProjectFile(File.ReadAllText(tempProjectPath));
projectFile.PackageReferences.Add(new PackageReference("Microsoft.CodeAnalysis.Scripting", ScriptingVersion));
projectFile.AssemblyReferences.Add(new AssemblyReference(scriptAssemblyPath));
projectFile.Save(tempProjectPath);
CopyProgramTemplate(tempProjectDirectory);
var commandRunner = new CommandRunner(logFactory);
// todo: may want to add ability to return dotnet.exe errors
var exitcode = commandRunner.Execute("dotnet", $"publish \"{tempProjectPath}\" -c Release -r {runtimeIdentifier} -o {context.WorkingDirectory}");
if (exitcode != 0)
{
throw new Exception($"dotnet publish failed with result '{exitcode}'");
}
_scriptConsole.WriteSuccess($"Published {context.FilePath} (executable) to {context.WorkingDirectory}");
}
public ScriptPublisher(ScriptProjectProvider scriptProjectProvider, ScriptEmitter scriptEmitter, ScriptConsole scriptConsole)
{
_scriptProjectProvider = scriptProjectProvider ?? throw new ArgumentNullException(nameof(scriptProjectProvider));
_scriptEmitter = scriptEmitter ?? throw new ArgumentNullException(nameof(scriptEmitter));
_scriptConsole = scriptConsole ?? throw new ArgumentNullException(nameof(scriptConsole));
_scriptEnvironment = ScriptEnvironment.Default;
}
public void CreateAssembly <TReturn, THost>(ScriptContext context, LogFactory logFactory, string assemblyFileName = null)
{
Directory.CreateDirectory(context.WorkingDirectory);
Directory.CreateDirectory(Path.Combine(context.WorkingDirectory, "obj"));
assemblyFileName = assemblyFileName ?? Path.GetFileNameWithoutExtension(context.FilePath);
var scriptAssemblyPath = CreateScriptAssembly <TReturn, THost>(context, context.WorkingDirectory, assemblyFileName);
var tempProjectPath = ScriptProjectProvider.GetPathToProjectFile(Path.GetDirectoryName(context.FilePath), ScriptEnvironment.Default.TargetFramework);
var tempProjectDirecory = Path.GetDirectoryName(tempProjectPath);
var sourceProjectAssetsPath = Path.Combine(tempProjectDirecory, "obj", "project.assets.json");
var destinationProjectAssetsPath = Path.Combine(context.WorkingDirectory, "obj", "project.assets.json");
File.Copy(sourceProjectAssetsPath, destinationProjectAssetsPath, overwrite: true);
var sourceNugetPropsPath = Path.Combine(tempProjectDirecory, "obj", "script.csproj.nuget.g.props");
var destinationNugetPropsPath = Path.Combine(context.WorkingDirectory, "obj", "script.csproj.nuget.g.props");
File.Copy(sourceNugetPropsPath, destinationNugetPropsPath, overwrite: true);
// only display published if we aren't auto publishing to temp folder
if (!scriptAssemblyPath.StartsWith(FileUtils.GetTempPath()))
{
_scriptConsole.WriteSuccess($"Published {context.FilePath} to { scriptAssemblyPath}");
}
}
private CompilationDependencyResolver(ScriptProjectProvider scriptProjectProvider, ScriptDependencyInfoProvider scriptDependencyInfoProvider, ScriptFilesDependencyResolver scriptFilesDependencyResolver, LogFactory logFactory)
{
_scriptProjectProvider = scriptProjectProvider;
_scriptDependencyInfoProvider = scriptDependencyInfoProvider;
_scriptFilesDependencyResolver = scriptFilesDependencyResolver;
_logger = logFactory.CreateLogger <CompilationDependencyResolver>();
}
public void CreateExecutable <TReturn, THost>(ScriptContext context, LogFactory logFactory, string runtimeIdentifier, string executableFileName = null)
{
if (runtimeIdentifier == null)
{
throw new ArgumentNullException(nameof(runtimeIdentifier));
}
executableFileName = executableFileName ?? Path.GetFileNameWithoutExtension(context.FilePath);
const string AssemblyName = "scriptAssembly";
var tempProjectPath = ScriptProjectProvider.GetPathToProjectFile(Path.GetDirectoryName(context.FilePath), ScriptEnvironment.Default.TargetFramework);
var renamedProjectPath = ScriptProjectProvider.GetPathToProjectFile(Path.GetDirectoryName(context.FilePath), ScriptEnvironment.Default.TargetFramework, executableFileName);
var tempProjectDirectory = Path.GetDirectoryName(tempProjectPath);
var scriptAssemblyPath = CreateScriptAssembly <TReturn, THost>(context, tempProjectDirectory, AssemblyName);
var projectFile = new ProjectFile(File.ReadAllText(tempProjectPath));
projectFile.PackageReferences.Add(new PackageReference("Microsoft.CodeAnalysis.Scripting", ScriptingVersion));
projectFile.AssemblyReferences.Add(new AssemblyReference(scriptAssemblyPath));
projectFile.Save(renamedProjectPath);
CopyProgramTemplate(tempProjectDirectory);
var commandRunner = new CommandRunner(logFactory);
// todo: may want to add ability to return dotnet.exe errors
var exitcode = commandRunner.Execute("dotnet", $"publish \"{renamedProjectPath}\" -c Release -r {runtimeIdentifier} -o \"{context.WorkingDirectory}\" {(ScriptEnvironment.Default.TargetFramework == "netcoreapp3.0" ? "/p:PublishSingleFile=true" : "")} /p:DebugType=Embedded");
if (exitcode != 0)
{
throw new Exception($"dotnet publish failed with result '{exitcode}'");
}
_scriptConsole.WriteSuccess($"Published {context.FilePath} (executable) to {context.WorkingDirectory}");
}
public void DefaultLanguageVersionShouldBeLatest()
{
var scriptProjectProvider = new ScriptProjectProvider(new ScriptOptions(), new OmniSharpEnvironment(), new LoggerFactory(), true, false);
var scriptProjectInfo = scriptProjectProvider.CreateProject("test.csx", Enumerable.Empty <MetadataReference>(), Path.GetTempPath(), typeof(CommandLineScriptGlobals));
Assert.Equal(LanguageVersion.Latest, ((CSharpParseOptions)scriptProjectInfo.ParseOptions).SpecifiedLanguageVersion);
Assert.Equal(LanguageVersion.CSharp9, ((CSharpParseOptions)scriptProjectInfo.ParseOptions).LanguageVersion);
}
private RuntimeDependencyResolver(ScriptProjectProvider scriptProjectProvider, ScriptDependencyInfoProvider scriptDependencyInfoProvider, ScriptFilesDependencyResolver scriptFilesDependencyResolver, LogFactory logFactory, ScriptEnvironment scriptEnvironment)
{
_scriptProjectProvider = scriptProjectProvider;
_scriptDependencyInfoProvider = scriptDependencyInfoProvider;
_scriptFilesDependencyResolver = scriptFilesDependencyResolver;
_logger = logFactory.CreateLogger <RuntimeDependencyResolver>();
_scriptEnvironment = scriptEnvironment;
_runtimeMatcher = new Regex($"{_scriptEnvironment.PlatformIdentifier}.*-{_scriptEnvironment.ProccessorArchitecture}");
}
private ScriptProjectProvider CreateProvider()
{
ScriptProjectProvider provider = new ScriptProjectProvider(type => ((level, message) =>
{
_testOutputHelper.WriteLine($"{level}:{message ?? ""}");
}));
return(provider);
}
public void ShouldLogProjectFileContent()
{
StringBuilder log = new StringBuilder();
var provider = new ScriptProjectProvider(type => ((level, message) => log.AppendLine(message)));
provider.CreateProject(TestPathUtils.GetFullPathToTestFixture("HelloWorld"), RuntimeHelper.TargetFramework, true);
var output = log.ToString();
Assert.Contains("<Project Sdk=\"Microsoft.NET.Sdk\">", output);
}
public void ShouldCreateNet46Project()
{
ScriptProjectProvider p = ScriptProjectProvider.Create(CreateLoggerFactory());
var pathToScript = Path.Combine(Path.GetDirectoryName(new Uri(typeof(ScriptParserTests).GetTypeInfo().Assembly.CodeBase)
.LocalPath), "sample");
var result = p.CreateProject(pathToScript);
var json = File.ReadAllText(result.PathToProjectJson);
json.ShouldContain("net46");
}
public ScriptCompiler(ScriptLogger logger, ScriptProjectProvider scriptProjectProvider)
{
_logger = logger;
_scriptProjectProvider = scriptProjectProvider;
// reset default scripting mode to latest language version to enable C# 7.1 features
// this is not needed once https://github.com/dotnet/roslyn/pull/21331 ships
var csharpScriptCompilerType = typeof(CSharpScript).GetTypeInfo().Assembly.GetType("Microsoft.CodeAnalysis.CSharp.Scripting.CSharpScriptCompiler");
var parseOptionsField = csharpScriptCompilerType?.GetField("s_defaultOptions", BindingFlags.Static | BindingFlags.NonPublic);
parseOptionsField?.SetValue(null, new CSharpParseOptions(LanguageVersion.Latest, kind: SourceCodeKind.Script));
}
public static void AddCsxProjectToWorkspace(OmniSharpWorkspace workspace, TestFile testFile)
{
var references = GetReferences();
var scriptHelper = new ScriptProjectProvider(new ScriptOptions(), new OmniSharpEnvironment(), new LoggerFactory(), true);
var project = scriptHelper.CreateProject(testFile.FileName, references.Union(new[] { MetadataReference.CreateFromFile(typeof(CommandLineScriptGlobals).GetTypeInfo().Assembly.Location) }), testFile.FileName, typeof(CommandLineScriptGlobals), Enumerable.Empty <string>());
workspace.AddProject(project);
var documentInfo = DocumentInfo.Create(
id: DocumentId.CreateNewId(project.Id),
name: testFile.FileName,
sourceCodeKind: SourceCodeKind.Script,
loader: TextLoader.From(TextAndVersion.Create(testFile.Content.Text, VersionStamp.Create())),
filePath: testFile.FileName);
workspace.AddDocument(documentInfo);
}
public void CreateAssembly <TReturn, THost>(ScriptContext context, LogFactory logFactory, string assemblyFileName = null)
{
Directory.CreateDirectory(context.WorkingDirectory);
Directory.CreateDirectory(Path.Combine(context.WorkingDirectory, "obj"));
assemblyFileName = assemblyFileName ?? Path.GetFileNameWithoutExtension(context.FilePath);
CreateScriptAssembly <TReturn, THost>(context, context.WorkingDirectory, assemblyFileName);
var tempProjectPath = ScriptProjectProvider.GetPathToProjectFile(Path.GetDirectoryName(context.FilePath));
var tempProjectDirecory = Path.GetDirectoryName(tempProjectPath);
var sourceProjectAssetsPath = Path.Combine(tempProjectDirecory, "obj", "project.assets.json");
var destinationProjectAssetsPath = Path.Combine(context.WorkingDirectory, "obj", "project.assets.json");
File.Copy(sourceProjectAssetsPath, destinationProjectAssetsPath, overwrite: true);
var sourceNugetPropsPath = Path.Combine(tempProjectDirecory, "obj", "script.csproj.nuget.g.props");
var destinationNugetPropsPath = Path.Combine(context.WorkingDirectory, "obj", "script.csproj.nuget.g.props");
File.Copy(sourceNugetPropsPath, destinationNugetPropsPath, overwrite: true);
}
private ScriptProjectProvider CreateProvider()
{
ScriptProjectProvider provider = new ScriptProjectProvider(TestOutputHelper.CreateTestLogFactory());
return(provider);
}
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 RuntimeDependencyResolver(ScriptProjectProvider scriptProjectProvider, ScriptDependencyInfoProvider scriptDependencyInfoProvider, LogFactory logFactory)
{
_scriptProjectProvider = scriptProjectProvider;
_scriptDependencyInfoProvider = scriptDependencyInfoProvider;
_logger = logFactory.CreateLogger <RuntimeDependencyResolver>();
}
