UCRM_stage/RSTP_DSLink/RSTP_DSLink/RSTP_DSLink.cs

using DSLink;
using DSLink.Nodes;
using DSLink.Nodes.Actions;
using DSLink.Request;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Net.NetworkInformation;
using System.Net;
using System.Text.RegularExpressions;
using System.Diagnostics;
using Iot.Device.Pigpio;
using Serilog;
using CommandLine;
using System.IO;
using RTSP_DSLink;
using System.Device.Gpio;

namespace RTSP_DSLink
{
    public class RSTP_DSLink : DSLinkContainer
    {
        private readonly Dictionary<string, System.Diagnostics.Process> _processes; 
        private readonly Dictionary<string, CancellationTokenSource> _alarmCTs; 
        public static bool PortInUse(int port)
        {
            bool inUse = false;

            IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();
            IPEndPoint[] ipEndPoints = ipProperties.GetActiveTcpListeners();
            foreach (IPEndPoint endPoint in ipEndPoints)
            {
                if (endPoint.Port == port)
                {
                    inUse = true;
                    break;
                }
            }
            return inUse;
        }
        private static void Main(string[] args)
        {
            Parser.Default.ParseArguments<CommandLineArguments>(args)
                .WithParsed(cmdLineOptions =>
                 {
                    cmdLineOptions = ProcessDSLinkJson(cmdLineOptions);

                    //Init the logging engine
                    InitializeLogging(cmdLineOptions);

                    //Construct a link Configuration
                    var config = new Configuration(cmdLineOptions.LinkName, true, true);

                    //Construct our custom link
                    var dslink = new RSTP_DSLink(config, cmdLineOptions);

                    InitializeLink(dslink).Wait();
                })
                .WithNotParsed(errors => { Environment.Exit(-1); });

            while (true)
            {
                Thread.Sleep(1000);
            }
        }

        public static async Task InitializeLink(RSTP_DSLink dsLink)
        {
            await dsLink.Connect();
            //dsLink.ClearNodes();
        }

        public RSTP_DSLink(Configuration config, CommandLineArguments cmdLineOptions) : base(config)
        {
            _processes = new Dictionary<string, Process>();
            _alarmCTs = new Dictionary<string, CancellationTokenSource>();
            //Perform any configuration overrides from command line options
            if (cmdLineOptions.BrokerUrl != null)
            {
                config.BrokerUrl = cmdLineOptions.BrokerUrl;
            }

            if (cmdLineOptions.Token != null)
            {
                config.Token = cmdLineOptions.Token;
            }

            if (cmdLineOptions.NodesFileName != null)
            {
                config.NodesFilename = cmdLineOptions.NodesFileName;
            }

            if (cmdLineOptions.KeysFolder != null)
            {
                config.KeysFolder = cmdLineOptions.KeysFolder;
            }

            Responder.AddNodeClass("streamAdd", delegate(Node node)
            {
                node.Configs.Set(ConfigType.DisplayName, new Value("Add Stream"));
                node.AddParameter(new Parameter
                {
                    Name = "RSTP URL",
                    ValueType = DSLink.Nodes.ValueType.String
                }
                );
                node.AddParameter(new Parameter
                {
                    Name = "Stream name",
                    ValueType = DSLink.Nodes.ValueType.String
                }
                );
                node.SetAction(new ActionHandler(Permission.Config, _createStreamAction));
            });

            Responder.AddNodeClass("alarmAdd", delegate (Node node)
            {
                node.Configs.Set(ConfigType.DisplayName, new Value("Add Alarm"));
                node.AddParameter(new Parameter
                {
                    Name = "Alarm name",
                    ValueType = DSLink.Nodes.ValueType.String
                }
                );
                /*node.AddParameter(new Parameter
                {
                    Name = "Camera name",
                    ValueType = DSLink.Nodes.ValueType.String
                }
                ); */
                node.AddParameter(new Parameter
                {
                    Name = "Raspberry Pi IP Address",
                    ValueType = DSLink.Nodes.ValueType.String
                }
                );
                node.AddParameter(new Parameter
                {
                    Name = "Port Number",
                    ValueType = DSLink.Nodes.ValueType.Number
                }
                );
                node.AddParameter(new Parameter
                {
                    Name = "GPIO Pin",
                    ValueType = DSLink.Nodes.ValueType.Number
                }
                );
                
                node.SetAction(new ActionHandler(Permission.Config, _createAlarmAction));
            });

            Responder.AddNodeClass("removeNode", delegate (Node node)
            {
                node.Configs.Set(ConfigType.DisplayName, new Value("Remove"));
                node.SetAction(new ActionHandler(Permission.Config, removeNodeAction));
            });

            Responder.AddNodeClass("stream", delegate (Node node)
            {
                node.Configs.Set(ConfigType.Writable, new Value(Permission.Read.Permit));
                node.Configs.Set(ConfigType.ValueType, DSLink.Nodes.ValueType.Number.TypeValue);
                
                node.Value.Set(-1);
            });

            Responder.AddNodeClass("alarm", delegate (Node node)
            {
                node.Configs.Set(ConfigType.Writable, new Value(Permission.Read.Permit));
                node.Configs.Set(ConfigType.ValueType, DSLink.Nodes.ValueType.Boolean.TypeValue);
                node.Value.Set(false);
            });

            /*Responder.AddNodeClass("rng", delegate(Node node)
            {
                node.Configs.Set(ConfigType.Writable, new Value(Permission.Read.Permit));
                node.Configs.Set(ConfigType.ValueType, DSLink.Nodes.ValueType.Number.TypeValue);
                node.Value.Set(0);

            });*/
        }
        public void ClearNodes()
        {
            foreach (var key in Responder.SuperRoot.Children.Keys)
            {
                Responder.SuperRoot.Children.TryGetValue(key, out Node oldStream);
                if (oldStream.ClassName == "stream")
                {
                    //Console.WriteLine(key);
                    Responder.SuperRoot.RemoveChild(key);
                }
            }
        }

        public override void InitializeDefaultNodes()
        {
            Responder.SuperRoot.CreateChild("createStream", "streamAdd").BuildNode();
            Responder.SuperRoot.CreateChild("createAlarm", "alarmAdd").BuildNode();
            SaveNodes();
            //Responder.SuperRoot.CreateChild("removeStream", "remove").BuildNode();
        }

        private async void _createStreamAction(InvokeRequest request)
        {
            try
            {
                var address = request.Parameters["RSTP URL"].Value<string>();
                var streamName = request.Parameters["Stream name"].Value<string>();
                int port = 8081;

                if (string.IsNullOrEmpty(address)) return;

                while (PortInUse(port))
                    port++;

               /*foreach (var oldStreamName in Responder.SuperRoot.Children.Keys)
                {

                    Responder.SuperRoot.Children.TryGetValue(oldStreamName, out Node oldStream);
                    if (oldStream.ClassName == "stream")
                    {
                        //Console.WriteLine(oldStreamName);
                        if (oldStream.Value.Int == port)
                        {
                            Responder.SuperRoot.RemoveChild(oldStreamName);
                        }
                    }
                }*/

                if (string.IsNullOrEmpty(streamName)) return;
                if (Responder.SuperRoot.Children.ContainsKey(streamName)) return;

                var stream = Responder.SuperRoot.CreateChild(streamName, "stream").BuildNode();

                stream.Value.Set(port);
                stream.CreateChild("remove", "removeNode").BuildNode();

                /*System.Diagnostics.Process.Start("CMD.exe", "/C \"C:\\Program Files\\VideoLAN\\VLC\\VLC.exe\"" +
                    " -vvv -Idummy " + address + " --sout #transcode{vcodec=MJPG,venc=ffmpeg{strict=1}}" +
                    ":standard{access=http{mime=multipart/x-mixed-replace;boundary=--7b3cc56e5f51db803f790dad720ed50a}," +
                    "mux=mpjpeg,dst=:" + port + "/} vlc://quit;");*/
                var proc = new Process {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "C:\\Program Files\\VideoLAN\\VLC\\VLC.exe",
                        Arguments = " -vvv -Idummy " + address + " --sout #transcode{vcodec=MJPG,venc=ffmpeg{strict=1}}" +
                        ":standard{access=http{mime=multipart/x-mixed-replace;boundary=--7b3cc56e5f51db803f790dad720ed50a}," +
                        "mux=mpjpeg,dst=:" + port + "/} vlc://quit;",
                        UseShellExecute = false,
                        RedirectStandardOutput = false,
                        CreateNoWindow = true
                    }};
                proc.Start();
                _processes.Add(streamName, proc);

                await request.Close();
                await SaveNodes();
            }
            catch(Exception e)
            {
                Console.WriteLine(e.GetType() + ":" + e.Message);
            }
        }

        private async void _createAlarmAction(InvokeRequest request)
        {
            try
            {
                var alarmName = request.Parameters["Alarm name"].Value<string>();
                //var cameraName = request.Parameters["Camera name"].Value<string>();
                var address = request.Parameters["Raspberry Pi IP Address"].Value<string>();
                var port = request.Parameters["Port Number"].Value<int>();
                var pin = request.Parameters["GPIO Pin"].Value<int>();

                if (string.IsNullOrEmpty(alarmName)) return;
                //if (string.IsNullOrEmpty(cameraName)) return;
                if (Responder.SuperRoot.Children.ContainsKey(alarmName)) return;
                //if (!Responder.SuperRoot.Children.ContainsKey(cameraName)) return;

                var alarm = Responder.SuperRoot.CreateChild(alarmName, "alarm").BuildNode();

                alarm.CreateChild("remove", "removeNode").BuildNode();
                var ts = new CancellationTokenSource();
                CancellationToken ct = ts.Token;
                Task.Run(() => _updateAlarm(alarm, address, port, pin, ct));
                _alarmCTs.Add(alarmName, ts);

                

                await request.Close();
                await SaveNodes();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.GetType() + ":" + e.Message);
            }
        }
        private async void removeNodeAction(InvokeRequest request)
        {
            try
            {
                //Console.WriteLine(request.Path);

                //on récupère le nom du noeud ayant envoyé la requête
                //dans le chemin de la requête en utilisant une regex (le chemin se terminant par /noeud/remove)
                var nodeName = Regex.Replace(request.Path, "^.*\\/([^\\/]*)\\/remove$", "$1");
                //Console.WriteLine(streamName);
                
                
                Responder.SuperRoot.Children.TryGetValue(nodeName, out Node node);
                if (node != null)
                {
                    if (node.ClassName == "stream")
                    {
                        var port = node.Value.Int;
                        _processes.TryGetValue(nodeName, out Process proc);
                        if (proc != null)
                            proc.Kill();
                        _processes.Remove(nodeName);

                        /*System.Diagnostics.Process.Start("CMD.exe", "/C FOR /F \"tokens=5 delims= \" %P IN ('netstat -a -n -o ^|" +
                            "findstr :" + stream.Value.Int + "') DO @ECHO taskkill /F /PID %P");*/

                        //FOR /F "tokens=5 delims= " %P IN('netstat -a -n -o | findstr :8081') DO @ECHO TaskKill.exe /PID %P
                    }
                    else if (node.ClassName == "alarm")
                    {
                        _alarmCTs.TryGetValue(nodeName, out CancellationTokenSource ts);
                        if(ts != null)
                            ts.Cancel();
                    }
                    Responder.SuperRoot.RemoveChild(nodeName);
                }

                await request.Close();
                await SaveNodes();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.GetType() + ":" + e.Message);
            }
        }

        private async void _updateAlarm(Node alarm, string addr, int port, int pin, CancellationToken ct)
        {
            using (var driver = new Driver(new IPEndPoint(IPAddress.Parse(addr), port)))
            {
                await driver.ConnectAsync();
                await Task.Delay(TimeSpan.FromSeconds(1)); //Give the socket time to get connected

                Console.WriteLine("Connected");

                using (var controller = new GpioController(PinNumberingScheme.Logical, driver))
                {
                    controller.OpenPin(pin);
                    controller.SetPinMode(pin, PinMode.InputPullUp);

                    while (!ct.IsCancellationRequested)
                    {
                        controller.WaitForEvent(pin, PinEventTypes.Falling, ct);
                        if(!ct.IsCancellationRequested)
                        {
                            Console.WriteLine("Beep boop");
                            alarm.Value.Set(true);
                        }
                    }
                    Console.WriteLine("Task cancelled");
                    controller.ClosePin(pin);
                }
            }
        }

        #region Initialize Logging

        /// <summary>
        /// This method initializes the logging engine.  In this case Serilog is used, but you
        /// may use a variety of logging engines so long as they are compatible with
        /// Liblog (the interface used by the DSLink SDK)
        /// </summary>
        /// <param name="cmdLineOptions"></param>
        private static void InitializeLogging(CommandLineArguments cmdLineOptions)
        {
            if (cmdLineOptions.LogFileFolder != null &&
                !cmdLineOptions.LogFileFolder.EndsWith(Path.DirectorySeparatorChar))
            {
                throw new ArgumentException($"Specified LogFileFolder must end with '{Path.DirectorySeparatorChar}'");
            }

            var logConfig = new LoggerConfiguration();
            switch (cmdLineOptions.LogLevel)
            {
                case LogLevel.Debug:
                    logConfig.MinimumLevel.Debug();
                    break;

                case LogLevel.Unspecified:
                case LogLevel.Info:
                    logConfig.MinimumLevel.Information();
                    break;

                case LogLevel.Warning:
                    logConfig.MinimumLevel.Warning();
                    break;

                case LogLevel.Error:
                    logConfig.MinimumLevel.Error();
                    break;
            }

            logConfig.WriteTo.Console(
                outputTemplate:
                "{Timestamp:MM/dd/yyyy HH:mm:ss} {SourceContext} [{Level}] {Message}{NewLine}{Exception}");
            logConfig.WriteTo.Logger(lc =>
            {
                lc.WriteTo.RollingFile(cmdLineOptions.LogFileFolder + "log-{Date}.txt", retainedFileCountLimit: 3);
            });
            Log.Logger = logConfig.CreateLogger();
        }

        #endregion

        #region dslink-json file processing

        /// <summary>
        /// This method will return an instance of CommandLineArguments build with the following logic rules.
        /// The file dslink.json can be utilized to specifiy command line arguments.  These live within the config block
        /// of the file.  Here is an example:
        ///         ...
        ///         "configs" : {
        ///                 "broker" : {
        ///                     "type": "url",
        ///                     "value":  "mybroker",
        ///                     "default": "http:localhost:8080\conn"
        ///                 },
        ///              }
        /// 
        /// The code in this method considers only the attribute's name ("broker") and value ("mybroker") in this example).
        /// "type" and "default" are not used.
        /// 
        /// The receives an instance of CommandLineArguments previously built from the parser.  If the dslink-json paramater
        /// is not null the code will use the value specified rather than the default value of "dslink.json" for the file
        /// to read containing the information.
        /// 
        /// Options specified on the command line wins out over those specified in the file.
        /// 
        /// </summary>
        /// <param name="cmdLineOptions"></param>
        /// <returns></returns>
        private static CommandLineArguments ProcessDSLinkJson(CommandLineArguments cmdLineOptions)
        {
            bool errorIfNotFound = false;
            string fileName = "dslink.json";

            //If filename is specified then error if it is not found
            if (!String.IsNullOrEmpty(cmdLineOptions.DSLinkJsonFilename))
            {
                errorIfNotFound = true;
                fileName = cmdLineOptions.DSLinkJsonFilename;
            }

            string fileData = "";
            if (File.Exists(fileName))
            {
                fileData = File.ReadAllText(fileName);
                Console.WriteLine(
                    $"Will use a combination of options specified from the command line and those specified in {fileName}");
            }
            else
            {
                if (errorIfNotFound == true)
                {
                    throw new ArgumentException($"Specified dslink-json file <{fileName}> was not found");
                }
                else
                {
                    return cmdLineOptions;
                }
            }

            JObject dslinkJson = JObject.Parse(fileData);
            var dsLinkJsonConfig = dslinkJson["configs"];

            var cmdLineOptionsDslinkJson = new CommandLineArguments();

            cmdLineOptionsDslinkJson.BrokerUrl =
                GetDsLinkStringValueForAttributeName(dsLinkJsonConfig, "broker", cmdLineOptions.BrokerUrl);
            cmdLineOptionsDslinkJson.LinkName =
                GetDsLinkStringValueForAttributeName(dsLinkJsonConfig, "name", cmdLineOptions.LinkName);
            cmdLineOptionsDslinkJson.LogFileFolder =
                GetDsLinkStringValueForAttributeName(dsLinkJsonConfig, "log-file", cmdLineOptions.LogFileFolder);
            cmdLineOptionsDslinkJson.KeysFolder =
                GetDsLinkStringValueForAttributeName(dsLinkJsonConfig, "key", cmdLineOptions.KeysFolder);
            cmdLineOptionsDslinkJson.NodesFileName =
                GetDsLinkStringValueForAttributeName(dsLinkJsonConfig, "nodes", cmdLineOptions.NodesFileName);
            cmdLineOptionsDslinkJson.Token =
                GetDsLinkStringValueForAttributeName(dsLinkJsonConfig, "token", cmdLineOptions.Token);
            cmdLineOptionsDslinkJson.LogLevel = GetDsLinkLogLevel(dsLinkJsonConfig, cmdLineOptions.LogLevel);

            return cmdLineOptionsDslinkJson;
        }

        private static LogLevel GetDsLinkLogLevel(JToken configObj, LogLevel logLevel)
        {
            if (logLevel != LogLevel.Unspecified)
            {
                return logLevel;
            }

            string testString = "";
            try
            {
                testString = configObj["log"]["value"].ToString();
            }
            catch
            {
            }

            ;

            LogLevel useLogLevel = LogLevel.Info;
            if (!Enum.TryParse(testString, out useLogLevel))
            {
                throw new ArgumentException("Invalid 'value' specified for 'log' value in dslink-json file");
            }

            return useLogLevel;
        }

        private static string GetDsLinkStringValueForAttributeName(JToken configObj, string attributeName,
            string cmdLineValue)
        {
            //use cmdLineValue if specified else attempt to use the one from the dslink-json
            if (cmdLineValue != null)
            {
                return cmdLineValue;
            }

            try
            {
                return configObj[attributeName]["value"].ToString();
            }
            catch
            {
                return null;
            }
        }

        #endregion processingq
    }
}