ShellExecute.cs

using System.Diagnostics;
using System;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
 
namespace Waher.Script.System.Functions
{
    public class ShellExecute : FunctionMultiVariate
    {
        public ShellExecute(ScriptNode FileName, ScriptNode Arguments, ScriptNode WorkFolder, 
            int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { FileName, Arguments, WorkFolder }, argumentTypes3Scalar, Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(ShellExecute);
 
        public override string[] DefaultArgumentNames => new string[] { "FileName", "Arguments", "WorkFolder" };
 
        public override bool IsAsynchronous => true;
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            return this.EvaluateAsync(Arguments, Variables).Result;
        }
 
        public override Task<IElement> EvaluateAsync(IElement[] Arguments, Variables Variables)
        {
            if (!(Arguments[0].AssociatedObjectValue is string FileName) ||
                !(Arguments[1].AssociatedObjectValue is string Arg) ||
                !(Arguments[2].AssociatedObjectValue is string WorkFolder))
            {
                throw new ScriptRuntimeException("Expected string arguments.", this);
            }
 
            ProcessStartInfo ProcessInformation = new ProcessStartInfo()
            {
                FileName = FileName,
                Arguments = Arg,
                UseShellExecute = false,
                RedirectStandardError = true,
                RedirectStandardOutput = true,
                WorkingDirectory = WorkFolder,
                CreateNoWindow = true,
                WindowStyle = ProcessWindowStyle.Hidden, 
                ErrorDialog = false
            };
 
            Process P = new Process();
            TaskCompletionSource<IElement> ResultSource = new TaskCompletionSource<IElement>();
 
            P.ErrorDataReceived += (Sender, e) =>
            {
                ResultSource.TrySetException(new ScriptRuntimeException(e.Data, this));
            };
 
            P.Exited += async (Sender, e) =>
            {
                try
                {
                    if (P.ExitCode != 0)
                    {
                        string ErrorText = await P.StandardError.ReadToEndAsync();
                        ResultSource.TrySetException(new ScriptRuntimeException(ErrorText, this));
                    }
                    else
                    {
                        string s = await P.StandardOutput.ReadToEndAsync();
                        ResultSource.TrySetResult(new StringValue(s));
                    }
                }
                catch (Exception ex)
                {
                    ResultSource.TrySetException(ex);
                }
            };
 
            Task _ = Task.Delay(1000 * 60 * 5).ContinueWith(Prev => ResultSource.TrySetException(new TimeoutException("Process did not exit within the provided time.")));
 
            P.StartInfo = ProcessInformation;
            P.EnableRaisingEvents = true;
            P.Start();
 
            return ResultSource.Task;
        }
 
    }
}