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));
}
