async void HandleDocumentChanged(object sender, DocumentChangedEventArgs e) { if (server.ClientsCount == 0) { return; } var classDecl = await DocumentParser.ParseDocument(e.Filename, e.Text, e.SyntaxTree, e.SemanticModel); if (classDecl == null) { return; } EvalRequest request = new EvalRequest { Declarations = classDecl.Code, NeedsRebuild = classDecl.NeedsRebuild, OriginalTypeName = classDecl.FullNamespace, NewTypeName = classDecl.CurrentFullNamespace, Xaml = classDecl.Xaml, XamlResourceName = classDecl.XamlResourceId, StyleSheets = classDecl.StyleSheets }; await server.Send(request); }
async Task <EvalResult> EvalOnMainThread(EvalRequest code, CancellationToken token) { EvalResult evalResult = new EvalResult(); var sw = new System.Diagnostics.Stopwatch(); Log.Debug($"Evaluation request {code}"); sw.Start(); currentEvalRequest = code; await evaluator.EvaluateExpression(code.NewTypeExpression, code.NeedsRebuild?code.Declarations : null, evalResult); if (evalResult.Result != null) { LoadXAML(evalResult.Result, code.Xaml, evalResult); } sw.Stop(); Log.Debug($"Evaluation ended with result {evalResult.Result}"); evalResult.Duration = sw.Elapsed; return(evalResult); }
async Task <EvalResult> EvalOnMainThread(EvalRequest code, CancellationToken token) { object result = null; bool hasResult = false; EvalResult evalResult = new EvalResult(); var sw = new System.Diagnostics.Stopwatch(); Log.Debug($"Evaluation request {code}"); sw.Start(); if (code.Xaml != null) { result = await LoadXAML(code.Xaml, code.XamlType, code.Declarations, evalResult); hasResult = result != null; } else { throw new NotSupportedException(); } sw.Stop(); Log.Debug($"Evaluation ended with result {result}"); evalResult.Duration = sw.Elapsed; evalResult.Result = result; evalResult.HasResult = hasResult; return(evalResult); }
async void HandleDocumentChanged(object sender, DocumentChangedEventArgs e) { if (server.ClientsCount == 0) { return; } var classDecl = await DocumentParser.ParseDocument(e.Filename, e.Text, e.SyntaxTree, e.SemanticModel); if (classDecl == null) { return; } EvalRequest request = new EvalRequest { Declarations = classDecl.Code, NeedsRebuild = classDecl.NeedsRebuild, NewTypeExpression = classDecl.NewInstanceExpression, Xaml = classDecl.Xaml, StyleSheets = classDecl.StyleSheets }; await server.Send(request); }
public EvalResult Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token) { var r = new EvalResult (); Task.Factory.StartNew (() => { r = EvalOnMainThread (code, token); }, token, TaskCreationOptions.None, mainScheduler).Wait (); return r; }
partial void PlatformVisualize(EvalRequest req, EvalResponse resp) { var val = resp.Result; var ty = val != null ? val.GetType () : typeof(object); Log ("{0} value = {1}", ty.FullName, val); ShowViewer (GetViewer (req, resp)); }
public void Write(EvalRequest <T> value, IMsgPackWriter writer) { writer.WriteMapHeader(2); _keyConverter.Write(Key.Expression, writer); _stringConverter.Write(value.Expression, writer); _keyConverter.Write(Key.Tuple, writer); _tupleConverter.Write(value.Tuple, writer); }
public EvalResult Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token) { var r = new EvalResult(); Task.Factory.StartNew(() => { r = EvalOnMainThread(code, token); }, token, TaskCreationOptions.None, mainScheduler).Wait(); return(r); }
public async Task<EvalResponse> VisualizeAsync (string declarations, string valueExpression) { var req = new EvalRequest { Declarations = declarations, ValueExpression = valueExpression }; var reqStr = JsonConvert.SerializeObject (req); var respStr = await client.UploadStringTaskAsync (visualizeUrl, reqStr); return JsonConvert.DeserializeObject<EvalResponse> (respStr); }
public async Task<EvalResponse> VisualizeAsync (string code) { var req = new EvalRequest { Code = code }; var reqStr = JsonConvert.SerializeObject (req); var respStr = await client.UploadStringTaskAsync (visualizeUrl, reqStr); return JsonConvert.DeserializeObject<EvalResponse> (respStr); }
async Task <HttpResponse> HandleNewXaml(HttpRequest request) { JsonHttpResponse response = new JsonHttpResponse(); StreamReader sr = new StreamReader(request.Body, Encoding.UTF8); string json = await sr.ReadToEndAsync(); EvalRequest evalRequest = Serializer.DeserializeJson <EvalRequest>(json); EvalResponse evalResponse = new EvalResponse(); response.Data = evalResponse; EvalResult result = null; try { result = await vm.Eval(evalRequest, mainScheduler, CancellationToken.None); evalResponse.Messages = result.Messages; evalResponse.Duration = result.Duration; Log.Information($"Visualizing result {result.Result}"); if (result.HasResult) { var tcs = new TaskCompletionSource <bool>(); Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { try { await previewer.Preview(result); tcs.SetResult(true); } catch (Exception ex) { await previewer.NotifyError(new ErrorViewModel("Oh no! An exception!", ex)); tcs.SetException(ex); } }); await tcs.Task; } else { Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { await previewer.NotifyError(new ErrorViewModel("Oh no! An evaluation error!", result)); }); } return(response); } catch (Exception ex) { Log.Exception(ex); response.StatusCode = HttpStatusCode.InternalServerError; return(response); } }
public async Task <EvalResponse> VisualizeAsync(string code) { var req = new EvalRequest { Code = code }; var reqStr = JsonConvert.SerializeObject(req); var respStr = await client.UploadStringTaskAsync(visualizeUrl, reqStr); return(JsonConvert.DeserializeObject <EvalResponse> (respStr)); }
public async Task <EvalResponse> VisualizeAsync(string declarations, string valueExpression) { var req = new EvalRequest { Declarations = declarations, ValueExpression = valueExpression }; var reqStr = JsonConvert.SerializeObject(req); var respStr = await client.UploadStringTaskAsync(visualizeUrl, reqStr); return(JsonConvert.DeserializeObject <EvalResponse> (respStr)); }
public EvalResult ResetCS(EvalRequest request) { var response = EvalResult.Empty(request.SessionId); response.StringResult = $"Total Memory: {System.GC.GetTotalMemory(false)} bytes -> "; var engine = ReplFactory.GetCSEngine(request.SessionId, e => { e.Reset(typeof(ReplService).Assembly); }); response.StringResult += $"{System.GC.GetTotalMemory(true)} bytes"; return(response); }
partial void PlatformVisualize (EvalRequest req, EvalResponse resp) { var val = resp.Result; var ty = val != null ? val.GetType () : typeof(object); Log ("{0} value = {1}", ty.FullName, val); ShowViewerAsync (GetViewer (req, resp)).ContinueWith (t => { if (t.IsFaulted) { Log ("ShowViewer ERROR {0}", t.Exception); } }); }
/// <summary> /// Request to preview a xaml document. /// </summary> /// <returns>The evaluation response.</returns> /// <param name="request">The evaluation request.</param> public async Task <EvalResponse> PreviewXaml(EvalRequest request) { var content = new StringContent(Serializer.SerializeJson(request), Encoding.UTF8); var response = await client.PostAsync(baseUri + "/xaml", content); if (response.IsSuccessStatusCode) { return(Serializer.DeserializeJson <EvalResponse>(await response.Content.ReadAsStringAsync())); } else { return(null); } }
public EvalResult Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token) { var t = Task.Factory.StartNew(() => { var r = new EvalResult(); r.HasResult = true; r.Result = new UILabel { BackgroundColor = UIColor.Red, Text = "Hello at " + DateTime.Now, }; return r; }, token, TaskCreationOptions.None, mainScheduler); return t.Result; }
public EvalResult EvalCS(EvalRequest request) { var analyzer = new ReplAnalyzerCS(request.Code); if (!analyzer.IsCompleteSubmission()) { return(EvalResult.Error(request.SessionId, "Submission is not completed!")); } var engine = ReplFactory.GetCSEngine(request.SessionId, e => { e.InitEngineWithAssembly(typeof(ReplService).Assembly); }); return(engine.Eval(request.Code)); }
public EvalResult Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token) { var t = Task.Factory.StartNew(() => { var r = new EvalResult(); r.HasResult = true; r.Result = new UILabel { BackgroundColor = UIColor.Red, Text = "Hello at " + DateTime.Now, }; return(r); }, token, TaskCreationOptions.None, mainScheduler); return(t.Result); }
private List <ulong> Eval(EvalRequest request, IEnumerable <ulong> inputs) { request.arguments = inputs.Select(ui => ui.ToString("X")).ToArray(); var response = webApi.Eval(request); if (!response.status.Equals("ok", StringComparison.OrdinalIgnoreCase)) { throw new ApplicationException(string.Format("Error EvalResponse ({0}): {1}", response.status, response.message)); } var values = response.outputs.Select(str => Convert.ToUInt64(str, 16)).ToList(); return(values); }
EvalResult EvalOnMainThread(EvalRequest code, CancellationToken token) { var sw = new System.Diagnostics.Stopwatch(); object result = null; bool hasResult = false; lock (mutex) { InitIfNeeded(); Log("EVAL ON THREAD {0}", System.Threading.Thread.CurrentThread.ManagedThreadId); printer.Messages.Clear(); sw.Start(); try { if (!string.IsNullOrEmpty(code.Declarations)) { eval.Evaluate(code.Declarations, out result, out hasResult); } if (!string.IsNullOrEmpty(code.ValueExpression)) { eval.Evaluate(code.ValueExpression, out result, out hasResult); } } catch (InternalErrorException) { eval = null; // Force re-init } catch (Exception ex) { // Sometimes Mono.CSharp fails when constructing failure messages if (ex.StackTrace.Contains("Mono.CSharp.InternalErrorException")) { eval = null; // Force re-init } printer.AddError(ex); } sw.Stop(); Log("END EVAL ON THREAD {0}", System.Threading.Thread.CurrentThread.ManagedThreadId); } return(new EvalResult { Messages = printer.Messages.ToArray(), Duration = sw.Elapsed, Result = result, HasResult = hasResult, }); }
/// <summary> /// Count the items matching the query and check for data completeness. /// </summary> /// <param name="query"></param> /// <returns>completeness, items count</returns> public KeyValuePair <bool, int> EvalQuery(OrQuery query) { var request = new EvalRequest(query); var response = Channel.SendRequest(request); if (response is ExceptionResponse exResponse) { throw new CacheException("Error while getting server information", exResponse.Message, exResponse.CallStack); } var concreteResponse = (EvalResponse)response; return(new KeyValuePair <bool, int>(concreteResponse.Complete, concreteResponse.Items)); }
EvalResult EvalOnMainThread(EvalRequest code, CancellationToken token) { var sw = new System.Diagnostics.Stopwatch (); object result = null; bool hasResult = false; lock (mutex) { InitIfNeeded (); Log ("EVAL ON THREAD {0}", System.Threading.Thread.CurrentThread.ManagedThreadId); printer.Messages.Clear (); sw.Start (); try { if (!string.IsNullOrEmpty (code.Declarations)) { eval.Evaluate (code.Declarations, out result, out hasResult); } if (!string.IsNullOrEmpty (code.ValueExpression)) { eval.Evaluate (code.ValueExpression, out result, out hasResult); } } catch (InternalErrorException) { eval = null; // Force re-init } catch (Exception ex) { // Sometimes Mono.CSharp fails when constructing failure messages if (ex.StackTrace.Contains ("Mono.CSharp.InternalErrorException")) { eval = null; // Force re-init } printer.AddError (ex); } sw.Stop (); Log ("END EVAL ON THREAD {0}", System.Threading.Thread.CurrentThread.ManagedThreadId); } return new EvalResult { Messages = printer.Messages.ToArray (), Duration = sw.Elapsed, Result = result, HasResult = hasResult, }; }
public EvalResult ValidateCS(EvalRequest request) { var analyzer = new ReplAnalyzerCS(request.Code); if (!analyzer.IsCompleteSubmission()) { return(EvalResult.Error(request.SessionId, "Submission is not completed!")); } var engine = ReplFactory.GetCSEngine(request.SessionId, e => { e.InitEngineWithAssembly(typeof(ReplService).Assembly); }); var diagnostics = engine.Validate(request.Code, out var script, out var scriptState); var hasErrors = diagnostics.Any(x => x.Severity == DiagnosticSeverity.Error || (x.Severity == DiagnosticSeverity.Warning && x.IsWarningAsError)); var diagResult = diagnostics.Select(x => new DiagnosticsResult(x.ToString(), x.Severity)).ToList(); return(EvalResult.Instance(request.SessionId, string.Empty, diagResult, hasErrors)); }
UIViewController GetViewer (EvalRequest req, EvalResponse resp) { var vc = resp.Result as UIViewController; if (vc != null) return vc; var v = GetSpecialView (resp.Result); if (v != null) { vc = new UIViewController (); vc.View = v; } else { vc = new ObjectInspector (resp.Result); } return vc; }
async Task HandleEvalRequest(EvalRequest request) { EvalResponse evalResponse = new EvalResponse(); EvalResult result; try { result = await vm.Eval(request, mainScheduler, CancellationToken.None); if (result.HasResult) { var tcs = new TaskCompletionSource <bool>(); Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { try { await previewer.Preview(result); tcs.SetResult(true); } catch (Exception ex) { errorViewModel.SetError("Oh no! An exception!", ex); await previewer.NotifyError(errorViewModel); tcs.SetException(ex); } }); await tcs.Task; } else { Xamarin.Forms.Device.BeginInvokeOnMainThread(async() => { errorViewModel.SetError("Oh no! An evaluation error!", result); await previewer.NotifyError(errorViewModel); }); } } catch (Exception ex) { Log.Exception(ex); } }
async void HandleDocumentChanged(object sender, DocumentChangedEventArgs e) { if (clients.Count == 0) { return; } var classDecl = await DocumentParser.ParseDocument(e.Filename, e.Text, e.SyntaxTree, e.SemanticModel); EvalRequest request = new EvalRequest { Declarations = classDecl?.Code, NeedsRebuild = classDecl.NeedsRebuild, NewTypeExpression = classDecl.NewInstanceExpression, Xaml = classDecl.Xaml }; await clients.Values.ToList().ForEachAsync(10, async(client) => { var res = await client.PreviewXaml(request); }); }
public async Task <EvalResponse?> EvalCSharpPrivate(EvalRequest request) { if (HasInitialized.Not()) { await ScriptRunner.RunCode("0"); HasInitialized = true; } if (request.Code == null) { return(null); } String responseBody = await ScriptRunner.RunCode(request.Code); return(new EvalResponse { Result = responseBody, }); }
private IDictionary <UInt64, UInt64> DownloadTrainProblemResult(TrainResponse trainProblem, UInt64[] arguments) { EvalRequest request = new EvalRequest() { program = trainProblem.challenge, arguments = arguments.Select(i => i.ToString("X")).ToArray() }; var response = webApi.Eval(request); Dictionary <UInt64, UInt64> results = new Dictionary <ulong, ulong>(); if (response.outputs.Length != arguments.Length) { return(null); } for (int i = 0; i < response.outputs.Length; ++i) { UInt64 result = Convert.ToUInt64(response.outputs[i], 16); results[arguments[i]] = result; } return(results); }
/// <summary> /// Загружает результаты вычислений для данной НЕТЕСТОВОЙ проблемы /// сохраняет их в Source /// </summary> public IDictionary <UInt64, UInt64> DownloadProblemResult(Problem problem, UInt64[] arguments) { EvalRequest request = new EvalRequest() { id = problem.Id, arguments = arguments.Select(i => i.ToString("X")).ToArray() }; var response = webApi.Eval(request); Dictionary <UInt64, UInt64> results = new Dictionary <ulong, ulong>(); if (response.outputs.Length != arguments.Length) { return(null); } for (int i = 0; i < response.outputs.Length; ++i) { UInt64 result = Convert.ToUInt64(response.outputs[i], 16); results[arguments[i]] = result; } Source.SaveResultsForProblem(problem, results); return(results); }
public Task <EvalResult> Eval(EvalRequest code, TaskScheduler mainScheduler, CancellationToken token) { var tcs = new TaskCompletionSource <EvalResult>(); var r = new EvalResult(); lock (mutex) { Task.Factory.StartNew(async() => { try { r = await EvalOnMainThread(code, token); tcs.SetResult(r); } catch (Exception ex) { tcs.SetException(ex); } }, token, TaskCreationOptions.None, mainScheduler).Wait(); return(tcs.Task); } }
async Task <EvalResult> EvalOnMainThread(EvalRequest code, CancellationToken token) { EvalResult evalResult = new EvalResult(); var sw = new System.Diagnostics.Stopwatch(); Log.Debug($"Evaluating code"); sw.Start(); currentEvalRequest = code; object newType; if (evaluator.IsEvaluationSupported) { if (code.NeedsRebuild) { await evaluator.EvaluateCode(code.Declarations, evalResult); } if (!evalResult.HasErrors) { evalResult.ResultType = GetTypeByName(code.NewTypeName); } } else { evalResult.ResultType = GetTypeByName(code.OriginalTypeName); } sw.Stop(); Log.Debug($"Evaluation ended with result"); evalResult.Duration = sw.Elapsed; return(evalResult); }
object GetViewer(EvalRequest req, EvalResponse resp) { return resp.Result; }
void Visualize (EvalRequest req, EvalResponse resp) { if (!resp.HasResult) { return; } visualizer.Visualize (req, resp); }
partial void PlatformVisualize(EvalRequest req, EvalResponse resp);
public void Visualize(EvalRequest req, EvalResponse resp) { PlatformVisualize (req, resp); }
public EvalRequestBuilder(EvalRequest evalRequest) : base(evalRequest) { _evalRequest = evalRequest; }
/// <summary>Performs an EVAL request.</summary> /// <param name="evalRequest">The call request.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The <see cref="Task" /> with MessagePackObject as result.</returns> public async Task <MessagePackObject> EvalAsync(EvalRequest evalRequest, CancellationToken cancellationToken) { return(await RequestAsync(evalRequest, cancellationToken).ConfigureAwait(false)); }