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