public override void Execute(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction, ISerializedParameters parameters) { try { if (!parameters.ContainsKey("ActionName")) { throw new Exception("ContextRecordAction requires a parameter for ActionName"); } var contextRecord = transaction.TransactionContext; var dataRecord = transaction.DataRecord; var req = new OrganizationRequest(parameters["ActionName"]); req["Target"] = new EntityReference(contextRecord.RecordType, contextRecord.Id); req["Transaction"] = transaction.ToEntityReference(); req["DataRecord"] = new EntityReference(dataRecord.RecordType, dataRecord.Id); //process any additional parameter data passed in from the configuration. if (parameters.Count > 1) { foreach (var key in parameters.Keys) { if (key != "ActionName" && !string.IsNullOrEmpty(parameters[key])) { req[key] = parameters[key]; } } } executionContext.DataService.ToOrgService().Execute(req); } catch (Exception ex) { throw new Exception(ex.Message, ex); } }
public void Serialize(ExecutionResult result, IFastJsonWriter writer, IWorkSession session) { writer.WriteStartObject(); writer.WritePropertyStartArray("output"); SerializeOutput(result.Output, writer); writer.WriteEndArray(); writer.WritePropertyStartArray("flow"); foreach (var step in result.Flow) { SerializeFlowStep(step, writer); } writer.WriteEndArray(); if (session.GetContainerExperimentException() is {} exception&& !session.WasContainerExperimentExceptionReported()) { writer.WriteProperty("containerExperimentException", exception.ToString()); session.SetContainerExperimentExceptionReported(true); } writer.WriteEndObject(); }
public ImmutableArray <string?> GetCallArgumentIdentifiers(IWorkSession session, int callStartLine, int callStartColumn) { var call = RoslynAdapterHelper.FindSyntaxNodeInSession(session, callStartLine, callStartColumn) as InvocationExpressionSyntax; if (call == null) { return(ImmutableArray <string?> .Empty); } var arguments = call.ArgumentList.Arguments; if (arguments.Count == 0) { return(ImmutableArray <string?> .Empty); } var results = new string?[arguments.Count]; for (var i = 0; i < arguments.Count; i++) { results[i] = (arguments[i].GetExpression() is IdentifierNameSyntax n) ? n.Identifier.ValueText : null; } return(ImmutableArray.Create(results)); }
public void WriteResult(IFastJsonWriter writer, object result, IWorkSession session) { if (result == null) { writer.WriteValue(null); return; } var targetName = session.GetTargetName(); if (session.GetTargetName() == AstTargetName) { var astTarget = _astTargets.GetValueOrDefault(session.LanguageName); astTarget.SerializeAst(result, writer, session); return; } var decompiler = _decompilers[targetName]; using (var stream = (Stream)result) using (var stringWriter = writer.OpenString()) { decompiler.Decompile(stream, stringWriter); } }
protected override ExecutionResultWithException ExecuteWithIsolation(MemoryStream assemblyStream, RuntimeGuardToken guardToken, IWorkSession session) { using (var context = new CustomAssemblyLoadContext(shouldShareAssembly: _ => false)) { var assembly = context.LoadFromStream(assemblyStream); var serverAssembly = context.LoadFromAssemblyPath(Current.AssemblyPath); var coreType = serverAssembly.GetType(typeof(IsolatedExecutorCore).FullName); var execute = coreType.GetMethod(nameof(IsolatedExecutorCore.Execute)); var wrapperInContext = execute.Invoke(null, new object[] { assembly, guardToken.Guid, Current.ProcessId, ProfilerState.Active }); // Since wrapperInContext belongs to a different AssemblyLoadContext, it is not possible to convert // it to same type in the default context without some trick (e.g. serialization). using (var wrapperStream = _memoryStreamManager.GetStream()) { var formatter = new BinaryFormatter(); formatter.Serialize(wrapperStream, wrapperInContext); wrapperStream.Seek(0, SeekOrigin.Begin); return((ExecutionResultWithException)formatter.Deserialize(wrapperStream)); } } }
public abstract bool Rollback(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction, ISerializedParameters parameters);
private async Task <bool> TryCompileFSharpToStreamAsync(MemoryStream assemblyStream, IWorkSession session, IList <Diagnostic> diagnostics, CancellationToken cancellationToken) { var fsharp = session.FSharp(); // GetLastParseResults are guaranteed to be available here as MirrorSharp's SlowUpdate does the parse var parsed = fsharp.GetLastParseResults(); using (var virtualAssemblyFile = FSharpFileSystem.RegisterVirtualFile(assemblyStream)) { var compiled = await FSharpAsync.StartAsTask(fsharp.Checker.Compile( // ReSharper disable once PossibleNullReferenceException FSharpList <Ast.ParsedInput> .Cons(parsed.ParseTree.Value, FSharpList <Ast.ParsedInput> .Empty), "_", virtualAssemblyFile.Name, fsharp.AssemblyReferencePathsAsFSharpList, pdbFile: null, executable: false, noframework: true ), null, cancellationToken).ConfigureAwait(false); foreach (var error in compiled.Item1) { // no reason to add warnings as check would have added them anyways if (error.Severity.Tag == FSharpErrorSeverity.Tags.Error) { diagnostics.Add(fsharp.ConvertToDiagnostic(error)); } } return(virtualAssemblyFile.Stream.Length > 0); } }
public ImmutableArray <int> GetMethodParameterLines(IWorkSession session, int lineInMethod, int columnInMethod) { return(ImmutableArray <int> .Empty); // not supported yet }
private void SerializeAst(RoslynAst ast, IFastJsonWriter writer, IWorkSession session) { writer.WriteStartArray(); SerializeNode(ast.SyntaxRoot, ast.SemanticModel, writer); writer.WriteEndArray(); }
public async Task <(bool assembly, bool symbols)> TryCompileToStreamAsync(MemoryStream assemblyStream, MemoryStream?symbolStream, IWorkSession session, IList <Diagnostic> diagnostics, CancellationToken cancellationToken) { PerformanceLog.Checkpoint("Compiler.TryCompileToStreamAsync.Start"); if (session.IsFSharp()) { var compiled = await TryCompileFSharpToStreamAsync(assemblyStream, session, diagnostics, cancellationToken).ConfigureAwait(false); return(compiled, false); } #warning TODO: Revisit after https://github.com/dotnet/docs/issues/14784 var compilation = (await session.Roslyn.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false)) !; var emitResult = compilation.Emit(assemblyStream, pdbStream: symbolStream, options: RoslynEmitOptions); PerformanceLog.Checkpoint("Compiler.TryCompileToStreamAsync.Emit.End"); if (!emitResult.Success) { foreach (var diagnostic in emitResult.Diagnostics) { diagnostics.Add(diagnostic); } return(false, false); } return(true, true); }
private ExecutionResult ExecuteInAppDomain(MemoryStream assemblyStream, RuntimeGuardToken guardToken, IWorkSession session) { var currentSetup = AppDomain.CurrentDomain.SetupInformation; using (var context = AppDomainContext.Create(new AppDomainSetup { ApplicationBase = currentSetup.ApplicationBase, PrivateBinPath = currentSetup.PrivateBinPath })) { context.LoadAssembly(LoadMethod.LoadFrom, Assembly.GetExecutingAssembly().GetAssemblyFile().FullName); var(result, exception) = RemoteFunc.Invoke(context.Domain, assemblyStream, guardToken, CurrentProcess.Id, Remote.Execute); if (ShouldMonitorException(exception)) { _monitor.Exception(exception, session); } return(result); } }
public static bool HasContainerExperimentFailed(this IWorkSession session) { return(session.GetContainerExperimentException() != null); }
public static void SetContainerExperimentExceptionReported(this IWorkSession session, bool value) { session.ExtensionData["ContainerExperimentExceptionReported"] = true; }
public static bool WasContainerExperimentExceptionReported(this IWorkSession session) { return((bool?)session.ExtensionData.GetValueOrDefault("ContainerExperimentExceptionReported") ?? false); }
public static void SetContainerExperimentException(this IWorkSession session, Exception exception) { session.ExtensionData["ContainerExperimentException"] = exception; }
public void Event(string name, IWorkSession session, IDictionary <string, string> extras = null) { Trace.TraceInformation("[{0}] Event '{0}'.", session?.GetSessionId(), name); }
public void SerializeAst(object ast, IFastJsonWriter writer, IWorkSession session) { SerializeAst((RoslynAst)ast, writer, session); }
public async Task <object?> ProcessAsync(IWorkSession session, IList <Diagnostic> diagnostics, CancellationToken cancellationToken) { PerformanceLog.Checkpoint("SlowUpdate.ProcessAsync.Start"); var targetName = GetAndEnsureTargetName(session); if (targetName == TargetNames.Ast || targetName == TargetNames.Explain) { var astTarget = _astTargets[session.LanguageName]; var ast = await astTarget.GetAstAsync(session, cancellationToken).ConfigureAwait(false); if (targetName == TargetNames.Explain) { return(await _explainer.ExplainAsync(ast, session, cancellationToken).ConfigureAwait(false)); } return(ast); } if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error)) { return(null); } if (targetName == LanguageNames.VisualBasic) { return(VisualBasicNotAvailable); } if (targetName != TargetNames.Run && targetName != TargetNames.Verify && !_decompilers.ContainsKey(targetName)) { throw new NotSupportedException($"Target '{targetName}' is not (yet?) supported by this branch."); } MemoryStream?assemblyStream = null; MemoryStream?symbolStream = null; try { assemblyStream = _memoryStreamManager.GetStream(); if (targetName == TargetNames.Run || targetName == TargetNames.IL) { symbolStream = _memoryStreamManager.GetStream(); } var compiled = await _compiler.TryCompileToStreamAsync(assemblyStream, symbolStream, session, diagnostics, cancellationToken).ConfigureAwait(false); if (!compiled.assembly) { assemblyStream.Dispose(); symbolStream?.Dispose(); return(null); } if (targetName == TargetNames.Verify) { assemblyStream.Dispose(); symbolStream?.Dispose(); return("✔️ Compilation completed."); } assemblyStream.Seek(0, SeekOrigin.Begin); symbolStream?.Seek(0, SeekOrigin.Begin); var streams = new CompilationStreamPair(assemblyStream, compiled.symbols ? symbolStream : null); if (targetName == TargetNames.Run) { return(_executor.Execute(streams, session)); } // it's fine not to Dispose() here -- MirrorSharp will dispose it after calling WriteResult() return(streams); } catch { assemblyStream?.Dispose(); symbolStream?.Dispose(); throw; } }
public void SetOptionsForTarget([NotNull] IWorkSession session, [NotNull] string target) { // I don't use `exe` for Run, see FSharpEntryPointRewriter }
public async Task <object> GetAstAsync(IWorkSession session, CancellationToken cancellationToken) { var document = session.Roslyn.Project.Documents.Single(); return(await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false)); }
/// <summary>Specifies whether the <see cref="IWorkSession" /> is using F#.</summary> /// <param name="session">The session</param> /// <returns><c>true</c> if the session is using F#; otherwise, <c>false</c></returns> public static bool IsFSharp(this IWorkSession session) { Argument.NotNull(nameof(session), session); return(((WorkSession)session).LanguageSession is IFSharpSession); }
public void SerializeAst(object ast, IFastJsonWriter writer, IWorkSession session) { writer.WriteStartArray(); SerializeNode((SyntaxNode)ast, writer); writer.WriteEndArray(); }
public async Task <bool> TryCompileToStreamAsync(MemoryStream assemblyStream, IWorkSession session, IList <Diagnostic> diagnostics, CancellationToken cancellationToken) { if (session.IsFSharp()) { return(await TryCompileFSharpToStreamAsync(assemblyStream, session, diagnostics, cancellationToken)); } var compilation = await session.Roslyn.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); var emitResult = compilation.Emit(assemblyStream); if (!emitResult.Success) { foreach (var diagnostic in emitResult.Diagnostics) { diagnostics.Add(diagnostic); } return(false); } return(true); }
private void TryInsertReportMethodArguments(ILProcessor il, Instruction instruction, SequencePoint sequencePoint, MethodDefinition method, ReportMethods flow, IWorkSession session, ref int index) { if (!method.HasParameters) { return; } var parameterLines = _languages[session.LanguageName] .GetMethodParameterLines(session, sequencePoint.StartLine, sequencePoint.StartColumn); if (parameterLines.Length == 0) { return; } // Note: method parameter lines are unreliable and can potentially return // wrong lines if nested method syntax is unrecognized and code matches it // to the containing method. That is acceptable, as long as parameter count // mismatch does not crash things -> so check length here. if (parameterLines.Length != method.Parameters.Count) { return; } foreach (var parameter in method.Parameters) { if (parameter.IsOut) { continue; } InsertReportValue( il, instruction, il.CreateLdargBest(parameter), parameter.ParameterType, parameter.Name, parameterLines[parameter.Index], flow, ref index ); } }
public abstract void Execute(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction, ISerializedParameters parameters);
private (string name, TypeReference type)? GetValueToReport(Instruction instruction, ILProcessor il, IWorkSession session) { var localIndex = GetIndexIfStloc(instruction); if (localIndex != null) { var variable = il.Body.Variables[localIndex.Value]; var symbols = il.Body.Method.DebugInformation; if (symbols == null || !symbols.TryGetName(variable, out var variableName)) { return(null); } return(variableName, variable.VariableType); } if (instruction.OpCode.Code == Code.Ret) { if (instruction.Previous?.Previous?.OpCode.Code == Code.Tail) { return(null); } var returnType = il.Body.Method.ReturnType; if (returnType.IsVoid()) { return(null); } return("return", returnType); } return(null); }
public bool TryGetById(string id, out IWorkSession item) { item = _Repo.FirstOrDefault(i => i.Id == id); return(item != null); }
public IStepExecutionResult Execute(IProcessExecutionContext executionContext, IWorkSession session, ITransaction transaction, IRequirementEvaluator requirementEvaluator) { try { bool blockProgress = false; bool isValid = true; Type.ValidateStepParameters(executionContext, Parameters); //complete any specific implementation for the step type Type.Execute(executionContext, session, transaction, Parameters); if (ValidationRequirements.Count > 0) { var requirementPointers = ValidationRequirements.Select(r => r.RequirementId).ToList(); var deficiencies = requirementEvaluator.Evaluate(executionContext, transaction, requirementPointers); if (deficiencies.Count > 0) { isValid = false; //if any validation requirement is configured to block progress and there is a deficiency for that requirement //then the step is blocked. foreach (var r in ValidationRequirements) { if (r.BlockProcessProgress && deficiencies.Where(d => d.Requirement.Id == r.RequirementId.Id).FirstOrDefault() != null) { blockProgress = true; } } } } var nextStep = getNextStep(executionContext, transaction); return(new StepExecutionResult { StepIsBlocked = blockProgress, StepIsValid = isValid, NextStep = nextStep }); } catch (Exception ex) { throw new Exception(ex.Message, ex); } }
protected override ExecutionResultWithException ExecuteWithIsolation(MemoryStream assemblyStream, RuntimeGuardToken guardToken, IWorkSession session) { var currentSetup = AppDomain.CurrentDomain.SetupInformation; using (var context = AppDomainContext.Create(new AppDomainSetup { ApplicationBase = currentSetup.ApplicationBase, PrivateBinPath = currentSetup.PrivateBinPath })) { context.LoadAssembly(LoadMethod.LoadFrom, Assembly.GetExecutingAssembly().GetAssemblyFile().FullName); return(RemoteFunc.Invoke(context.Domain, assemblyStream.ToArray(), guardToken, Current.ProcessId, ProfilerState.Active, Remote.Execute)); } }
public void Exception(Exception exception, IWorkSession session, IDictionary <string, string> extras = null) { Trace.TraceError("[{0}] Exception: {0}.", session?.GetSessionId(), exception); }