ActionResult ExecuteUrl( string url, string verb, Dictionary <string, string> arguments) { // Sanity checking URL if (!Utilities.IsLegalHttpName(url)) { throw new ApplicationException("Illeal URL"); } var path = RootResolver.Root + url + $".{verb}.hl"; if (!File.Exists(path)) { return(new NotFoundResult()); } using (var stream = File.OpenRead(path)) { var lambda = new Parser(stream).Lambda(); /* * Checking file [.arguments], and if given, removing them to make sure invocation of file * only has a single [.arguments] node. * Notice, future improvements implies validating arguments. */ var fileArgs = lambda.Children.Where((x) => x.Name == ".arguments").ToList(); if (fileArgs.Any()) { if (fileArgs.Count() > 1) { throw new ApplicationException($"URL '{url}' has an invalid [.arguments] declaration. Multiple [.arguments] nodes found in endpoint's file"); } fileArgs.First().UnTie(); } // Adding arguments from invocation to evaluated lambda node. if (arguments.Count > 0) { var argsNode = new Node(".arguments"); argsNode.AddRange(arguments.Select((x) => ConvertArgument(x.Key, x.Value, fileArgs.First().Children.FirstOrDefault(x2 => x2.Name == x.Key)))); lambda.Insert(0, argsNode); } _signaler.Signal("eval", lambda); var result = GetReturnValue(lambda); if (result != null) { return(new OkObjectResult(result)); } return(new OkResult()); } }
void UnrollSignal(Node input) { var inner = input.Get <hl.Signal>().Content; _signaler.Signal(inner.Name, inner); input.Value = inner.Value; input.AddRange(inner.Children.ToList()); }
/* * Executes [.finally] if it exists. */ void ExecuteFinally(ISignaler signaler, Node input) { if (input.Next?.Name == ".finally") { signaler.Signal("eval", input.Next); } else if (input.Next?.Next?.Name == ".finally") { signaler.Signal("eval", input.Next.Next); } }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { // Evaluating condition. signaler.Signal("eval", input); // Checking if condition evaluated to true. if (input.Children.First().GetEx <bool>()) { // Retrieving and evaluating lambda node. signaler.Signal("eval", GetLambdaNode(input)); } }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { SanityCheck(input); // Storing termination node, to check if we should terminate early for some reasons. var terminate = signaler.Peek <Node>("slots.result"); // Making sure we don't enter an infinite loop. int iterations = 0; // Evaluating lambda while condition is true. while (true) { // Checking if we've passed our maximum number of iterations. iterations = SanityCheckIterations(iterations); // Making sure we can reset back to original nodes after every single iteration. var old = input.Children.Select(x => x.Clone()).ToList(); // This will evaluate the condition. signaler.Signal("eval", input); // Verifying we're supposed to proceed into body of [while]. if (!input.Children.First().GetEx <bool>()) { break; } // Retrieving [.lambda] node and doing basic sanity check. var lambda = input.Children.Skip(1).First(); if (lambda.Name != ".lambda") { throw new ArgumentException("Keyword [while] requires its second child to be [.lambda]"); } // Evaluating "body" lambda of [while]. signaler.Signal("eval", lambda); // Resetting back to original nodes. input.Clear(); // Notice, cloning in case we've got another iteration, to avoid changing original nodes' values. input.AddRange(old.Select(x => x.Clone())); // Checking if execution for some reasons was terminated. if (terminate != null && (terminate.Value != null || terminate.Children.Any())) { return; } } }
private static void ExecuteFile(ISignaler signaler, string filename) { Console.WriteLine(); Console.WriteLine("*****************************************************"); Console.WriteLine($"*** Executing file '{filename}'"); Console.WriteLine("*****************************************************"); using (var file = File.OpenText(filename)) { var hl = file.ReadToEnd(); var node = new Node("", hl); signaler.Signal("lambda", node); signaler.Signal("eval", node); } }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { // Checking to see if we should evaluate at all. if (ShouldEvaluate(input, out Node lambda)) { // Evaluating condition. signaler.Signal("eval", input); // Checking if evaluation of condition evaluated to true. if (input.Children.First().GetEx <bool>()) { signaler.Signal("eval", lambda); } } }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { // Sanity checking invocation. SanityCheckInvocation(input); signaler.Signal("eval", input); MoveImplementation(input); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { if (ShouldEvaluate(input)) { signaler.Signal("eval", input); } }
/* * Creates ContentObject from filename. */ static void CreateContentObjectFromFilename( ISignaler signaler, Node contentNode, MimePart part) { var filename = contentNode.GetEx <string>() ?? throw new ArgumentException("No [filename] value provided"); // Checking if explicit encoding was supplied. ContentEncoding encoding = ContentEncoding.Default; var encodingNode = contentNode.Children.FirstOrDefault(x => x.Name == "Content-Encoding"); if (encodingNode != null) { encoding = (ContentEncoding)Enum.Parse(typeof(ContentEncoding), encodingNode.GetEx <string>()); } // Checking if explicit disposition was specified. if (part.ContentDisposition == null) { // Defaulting Content-Disposition to; "attachment; filename=whatever.xyz" part.ContentDisposition = new ContentDisposition("attachment") { FileName = Path.GetFileName(filename) }; } var rootPath = new Node(); signaler.Signal(".io.folder.root", rootPath); part.Content = new MimeContent( File.OpenRead( rootPath.GetEx <string>() + filename.TrimStart('/')), encoding); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { // Making sure we can reset back to original nodes after every single iteration. var old = input.Children.Select(x => x.Clone()).ToList(); // Storing termination node, to check if we should terminate early for some reasons. var terminate = signaler.Peek <Node>("slots.result"); foreach (var idx in input.Evaluate().ToList()) { // Inserting "data pointer". input.Insert(0, new Node(".dp", idx)); // Evaluating "body" lambda of [for-each] signaler.Signal("eval", input); // Resetting back to original nodes. input.Clear(); // Notice, cloning in case we've got another iteration, to avoid changing original nodes' values. input.AddRange(old.Select(x => x.Clone())); // Checking if execution for some reasons was terminated. if (terminate != null && (terminate.Value != null || terminate.Children.Any())) { return; } } }
public void Signal(Node input) { var connectionString = input.GetEx <string>(_signaler); // Checking if this is a "generic connection string". if (connectionString.StartsWith("[", StringComparison.InvariantCulture) && connectionString.EndsWith("]", StringComparison.InvariantCulture)) { var generic = _configuration["databases:mssql:generic"]; connectionString = generic.Replace("{database}", connectionString.Substring(1, connectionString.Length - 2)); } else if (!connectionString.Contains(";")) { var generic = _configuration["databases:mssql:generic"]; connectionString = generic.Replace("{database}", connectionString); } using (var connection = new SqlConnection(connectionString)) { connection.Open(); _connections.Push(connection); try { _signaler.Signal("eval", input); } finally { _connections.Pop(); } input.Value = null; } }
/* * Responsible for rendering custom exception handler's result to HTTP response, * and decorating HTTP response according to exception handler's return value(s). */ static async Task RenderCustomExceptionResponse( HttpContext context, ISignaler signaler, Node nodeResult) { // Decorating status code for HTTP response and removing [status] from payload response. var status = nodeResult.Children.FirstOrDefault(x => x.Name == "status"); context.Response.StatusCode = status?.Get <int>() ?? 500; status?.UnTie(); /* * Returning response according to result of above invocation, * making sure we return default message if no message was returned from * Hyperlambda file. */ signaler.Signal(".lambda2json-raw", nodeResult); var response = nodeResult.Get <JObject>(); if (response["message"] == null) { response["message"] = DEFAULT_ERROR_MESSAGE; } /* * Notice, we have no way to determine the frontend used unless we find an explicit configuration part. * Hence, we've got no other options than to simply turn on everything if no frontends are declared * in configuration. */ context.Response.Headers.Add("Access-Control-Allow-Origin", "*"); //NOSONAR // Writing exception to response and returning success. await context.Response.WriteAsync(response.ToString(Newtonsoft.Json.Formatting.Indented)); }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { // Making sure we're able to handle returned values and nodes from slot implementation. var result = new Node(); signaler.Scope("slots.result", result, () => { // Loading file and converting its content to lambda. var filename = input.GetEx <string>(); var hyperlambda = _service .Load( PathResolver.CombinePaths( _rootResolver.RootFolder, filename)); // Creating and parametrising our lambda object from argument + file's Hyperlambda content. var lambda = GetLambda(input, hyperlambda, filename); // Evaluating lambda of slot. signaler.Signal("eval", lambda); // Applying result. ApplyResult(input, result); }); }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { // Making sure we evaluate any children, to make sure any signals wanting to retrieve our source is evaluated. signaler.Signal("eval", input); // Saving file. if (input.Name == "io.file.save") { // Text content. _service.Save( PathResolver.CombinePaths( _rootResolver.RootFolder, input.GetEx <string>()), input.Children.First().GetEx <string>()); } else { // Binary content. _service.Save( PathResolver.CombinePaths( _rootResolver.RootFolder, input.GetEx <string>()), input.Children.First().GetEx <byte[]>()); } }
public void Signal(Node input) { var previous = input.Previous; if (previous == null || (previous.Name != "if" && previous.Name != "else-if")) { throw new ApplicationException("[else] must have an [if] or [else-if] before it"); } var evaluate = true; while (previous != null && (previous.Name == "if" || previous.Name == "else-if")) { if (previous.Children.First().GetEx <bool>(_signaler)) { evaluate = false; break; } previous = previous.Previous; } if (evaluate) { _signaler.Signal("eval", input); } }
/// <summary> /// Handles the signal for the class. /// </summary> /// <param name="signaler">Signaler used to signal the slot.</param> /// <param name="input">Root node for invocation.</param> public void Signal(ISignaler signaler, Node input) { signaler.Scope( "mssql.transaction", new Transaction(signaler, signaler.Peek <SqlConnectionWrapper>("mssql.connect").Connection), () => signaler.Signal("eval", input)); }
/* * Helper method to handle one single message, by parsing it (unless raw is true), and invoking [.lambda] * callback to notify client of message retrieved. */ void HandleMessage( MimeMessage message, ISignaler signaler, Node lambda, bool raw) { var messageNode = new Node(".message"); lambda.Insert(0, messageNode); if (raw) { messageNode.Value = message.ToString(); } else { messageNode.Add(new Node("subject", message.Subject)); AddRecipient(message.From.Select(x => x as MailboxAddress), messageNode, "from"); AddRecipient(message.To.Select(x => x as MailboxAddress), messageNode, "to"); AddRecipient(message.Cc.Select(x => x as MailboxAddress), messageNode, "cc"); AddRecipient(message.Bcc.Select(x => x as MailboxAddress), messageNode, "bcc"); var parseNode = new Node("", message.Body); signaler.Signal(".mime.parse", parseNode); messageNode.AddRange(parseNode.Children); } }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler that raised the signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { var settings = new Pop3Settings(input, _configuration); _client.Connect(settings.Connection.Server, settings.Connection.Port, settings.Connection.Secure); try { if (settings.Connection.HasCredentials) { _client.Authenticate(settings.Connection.Username, settings.Connection.Password); } var count = _client.GetMessageCount(); for (var idx = 0; Done(idx, count, settings.Max); idx++) { var lambda = settings.Lambda.Clone(); var message = _client.GetMessage(idx); HandleMessage(message, signaler, lambda, settings.Raw); signaler.Signal("eval", lambda); } } finally { _client.Disconnect(true); } }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { SanityCheck(input); signaler.Signal("eval", input); input.Value = string.Join("", input.Children.Select(x => x.GetEx <string>())); }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { SanityCheck(input); signaler.Signal("eval", input); input.Value = input.GetEx <string>() .EndsWith(input.Children.First().GetEx <string>(), StringComparison.InvariantCulture); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { SanityCheck(input); signaler.Signal("eval", input); input.Value = Compare( input.Children.First().GetEx <object>(), input.Children.Skip(1).First().GetEx <object>()); }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { SanityCheck(input); signaler.Signal("eval", input); input.Value = string.Join( input.Children.First(x => x.Name != "").GetEx <string>(), input.Evaluate().Select(x => x.GetEx <string>()).ToArray()); }
public void Apply(SwaggerDocument swaggerDoc, DocumentFilterContext context) { foreach (var idx in _signaler.Slots.Where((ix) => ix.StartsWith(".swagger-dox."))) { var node = new Node("", swaggerDoc); _signaler.Signal(idx, node); } }
/// <summary> /// Implementation of your slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to your slot.</param> public void Signal(ISignaler signaler, Node input) { var databaseType = input.Children.FirstOrDefault(x => x.Name == "database-type")?.GetEx <string>() ?? _configuration["magic:databases:default"]; input.Children.FirstOrDefault(x => x.Name == "database-type")?.UnTie(); signaler.Signal($"{databaseType}.connect", input); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { var executionNode = GetExecutionNode(input); if (executionNode != null) { signaler.Signal(executionNode.Name, executionNode); } }
public static object GetEx(this Node node, ISignaler signaler, bool evaluate = true) { if (node.Value is Signal signal) { signaler.Signal(signal.Content.Name, signal.Content); return(signal.Content.Value); } return(node.Get(evaluate)); }
/// <summary> /// Implementation of signal /// </summary> /// <param name="signaler">Signaler used to signal</param> /// <param name="input">Parameters passed from signaler</param> public void Signal(ISignaler signaler, Node input) { var arguments = GetArguments(input); signaler.Scope(arguments.Name, arguments.Value, () => { signaler.Signal("eval", arguments.Lambda); }); }
public void Signal(Node input) { if (input.Parent?.Name != "switch") { throw new ApplicationException("[case] must be a child of [switch]"); } _signaler.Signal("eval", input); }
/// <summary> /// Implementation of slot. /// </summary> /// <param name="signaler">Signaler used to raise the signal.</param> /// <param name="input">Arguments to slot.</param> public void Signal(ISignaler signaler, Node input) { SanityCheckArguments(input); signaler.Signal("eval", input); var paths = GetPaths(input); _service.Copy( paths.SourcePath, paths.DestinationPath); }