public async Task <IActionResult> BuildJar([FromBody] CompileRequest request) { try { var bytes = await _service.BuildJarFromGit(request.GitPath); bytes = await _obfuscation.Obfuscate(new ObfuscateRequest { Bytes = bytes, Config = request.ObfuscateConfig }); return(File(bytes, "application/java-archive", "result.jar")); } catch (Exception e) { Console.WriteLine(e); var split = e.Message.Split("@@"); return(BadRequest(JsonConvert.SerializeObject(new { Logs = split[0], Errors = split.Length > 1 ? split[1] : string.Empty }))); } }
public async Task <CompiledScript> Handle(CompileScriptCommand request, CancellationToken cancellationToken) { var config = await _mediator.Send(new GetFileQuery { Name = "script-obfuscate-config.xml" }, cancellationToken); var compileRequest = new CompileRequest { GitPath = request.GitlabUrl, ObfuscateConfig = Encoding.Default.GetString(config), Game = request.Game }; var res = await _client.PostAsync("/api/git/buildJar", new StringContent( JsonSerializer.Serialize(compileRequest), Encoding.Default, "application/json"), cancellationToken); if (res.StatusCode != HttpStatusCode.OK) { var error = await res.Content.ReadAsStringAsync(); var result = JsonSerializer.Deserialize <CompileResult>(error); throw new CompileException(result); } var bytes = await res.Content.ReadAsByteArrayAsync(); if (bytes.Length == 0) { throw new Exception("Failed to compile script by url: " + request.GitlabUrl); } return(new CompiledScript { Content = bytes }); }
/// <summary> /// Compiles the given TypeScript source into pure JavaScript. /// </summary> /// <param name="source">The typescript source code to be compiled.</param> /// <param name="fileName">The filename that represents this source code.</param> /// <param name="options">The options to use when compiling.</param> /// <returns>The results of the compilation.</returns> public virtual CompiledModule Compile(string source, string fileName, CompileOptions options) { // // Generate the compilation request. // var request = new CompileRequest { SourceCode = source, FileName = fileName, Options = options }; // // Make sure the queue is running and submit the new request to the queue. // EnsureWorkerThreadRunning(); _sharedQueue.Enqueue(request); _sharedQueueEvent.Set(); // // Wait for up to 30 seconds for the compilation to complete. // if (!request.WaitHandle.WaitOne(30000)) { return(new CompiledModule { FileName = fileName, Success = false, Messages = new[] { "Timeout waiting for compilation to complete." } }); } return(request.CompiledModule); }
public IHttpActionResult PostCompile(CompileRequest request) { var source = new Source(request.Code, request.Dependencies); var compilationResult = _compilationService.Compile(source); // Return an error response if compile was unsuccessful, otherwise the response was successful. return(Content(compilationResult.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError, compilationResult)); }
/// <summary> /// Compiles the specified code and returns errors. /// </summary> /// <param name="req">The request</param> public IEnumerable<FSharpErrorInfo> Post(CompileRequest req) { // short circuit bad requests if (string.IsNullOrEmpty(req.Source)) { return new List<FSharpErrorInfo>(); } var c = WebApiApplication.Compiler.TypeCheck(req.Source, "/home/test.fsx"); return c.Check.Errors; }
public CompileResponse CompileCode(CompileRequest request) { try { return(CompileResponse.ForSuccess(Executor.ExecuteSnippet(request.Snippet))); } catch (DynamicCompilationException e) { return(CompileResponse.ForError(e)); } }
public async Task <CompileResult> Compile(CompileRequest request) { const string uri = "/compile"; var response = await _http.PostAsJsonAsync(uri, request); if (response.IsSuccessStatusCode == false) { throw new BadRequestException(uri, response.StatusCode, await response.Content.ReadAsStringAsync()); } var result = await response.Content.ReadFromJsonAsync <CompileResult>(); return(result !); }
private static Request Map(CompileRequest code) { if (SupportedLanguages.TryGetValue(code.Language, out var language)) { return(new Request { LanguageChoice = language, Input = code.Input, CompilerArgs = code.CompilerArgs, Program = code.Code }); } throw new NotSupportedException($"{code.Language} is not supported by {ApiUrl}"); }
public CompileResponse Compile(CompileRequest request) { var configuration = request.ModuleCompileTimeServices.Configuration; var container = request.ModuleCompileTimeServices.Container; var compiler = container .RoslynCompiler() .WithCodeLogging(configuration.Compiler.Logging.IsEnableCode) .WithCodeAuditDirectory(configuration.Compiler.Logging.AuditDirectory) .WithSources( request.Classes .Select(_ => new RoslynCompiler.SourceBasic(_.ClassName, _.Code)) .ToList<RoslynCompiler.Source>()); return new CompileResponse( request, compiler.Compile()); }
public async Task <CompileResult> RunCode(CompileRequest code) { var request = new HttpRequestMessage(HttpMethod.Post, ApiUrl) { Content = Serialize(Map(code)) }; using var response = await HttpClient.SendAsync(request); if (!response.IsSuccessStatusCode) { throw new Exception($"RepDesk API throw exception with code {response.StatusCode}: {response.ReasonPhrase}"); } //to avoid too many requests await Task.Delay(1000); var deserializedResponse = await DeserializeAsync <Response>(response.Content); return(Map(deserializedResponse)); }
public Task <CompileResult> RunCode(CompileRequest code) { // define source code, then parse it (to the type used for compilation) SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(@" using System; namespace RoslynCompileSample { public class Writer { public void Write(string message) { Console.WriteLine(message); } } }"); // define other necessary objects for compilation string assemblyName = Path.GetRandomFileName(); MetadataReference[] references = new MetadataReference[] { MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location) }; // analyse and generate IL code from syntax tree CSharpCompilation compilation = CSharpCompilation.Create( assemblyName, syntaxTrees: new[] { syntaxTree }, references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)); using (var ms = new MemoryStream()) { // write IL code into memory EmitResult result = compilation.Emit(ms); if (!result.Success) { // handle exceptions IEnumerable <Diagnostic> failures = result.Diagnostics.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error); foreach (Diagnostic diagnostic in failures) { Console.Error.WriteLine("{0}: {1}", diagnostic.Id, diagnostic.GetMessage()); } } else { // load this 'virtual' DLL so that we can use ms.Seek(0, SeekOrigin.Begin); Assembly assembly = Assembly.Load(ms.ToArray()); // create instance of the desired class and call the desired function Type type = assembly.GetType("RoslynCompileSample.Writer"); object obj = Activator.CreateInstance(type); type.InvokeMember("Write", BindingFlags.Default | BindingFlags.InvokeMethod, null, obj, new object[] { "Hello World" }); } } return(Task.FromResult(new CompileResult())); }