RapidSequencer.cs

using RSI.RapidSequencer;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace RSI.RapidSequencer
{
 
  public struct EngineStatus
  {
    public bool Running;
    public SequencerType SequencerType;
    public ulong TaskCount;
  }
 
  public struct TaskStatus
  {
    public TaskState State;
    public ulong LineNumber;
    public ulong Counter;
  }
 
  public struct SequencerGlobal
  {
    public enum DataType
    {
      Bool,
      Char,
      Int16,
      UInt16,
      Int32,
      UInt32,
      Int64,
      UInt64,
      Double,
    }
 
    public string Name;
    public ulong HostAddress;
    public uint FirmwareAddress;
    public uint Index;
    public ulong Size;
    public DataType Type;
    public dynamic Value;
  }
 
  public class RapidSequencer
  {
    public const uint CONNECT_TIMEOUT_MS = 1000;
 
    public const uint CONNECT_ATTEMPTS = 3;
 
    public const string DEFAULT_ENTRY_POINT = "main";
 
    private Grpc.Core.Channel channel;
    private RapidSequencerService.RapidSequencerServiceClient client;
    private string _grpcAddr;
    private int _grpcPort;
    private CompileSuccess lastCompileSuccess = null;
    private string warnings = "";
 
    public RapidSequencer(string grpcAddr, int grpcPort, uint connectTimeoutMs = CONNECT_TIMEOUT_MS, uint connectAttempts = CONNECT_ATTEMPTS)
    {
      _grpcAddr = grpcAddr;
      _grpcPort = grpcPort;
      channel = new Grpc.Core.Channel(_grpcAddr, _grpcPort, Grpc.Core.ChannelCredentials.Insecure);
 
      channel.ConnectAsync(DateTime.Now);
      System.Threading.Thread.Sleep(1);
 
      int attempts = 0;
      while (attempts < connectAttempts && channel.State != Grpc.Core.ChannelState.Ready)
      {
        channel.TryWaitForStateChangedAsync(channel.State, DateTime.UtcNow.AddMilliseconds(connectTimeoutMs)).Wait();
        attempts++;
        if (attempts >= connectAttempts)
        {
          throw new Exception("RapidSequencer failed to transition to ready state");
        }
      }
 
      client = new RapidSequencerService.RapidSequencerServiceClient(channel);
    }
 
    public int PortGet()
    {
      return _grpcPort;
    }
 
    public string IpGet()
    {
      return _grpcAddr;
    }
 
    public static string ParseRepeatedString(Google.Protobuf.Collections.RepeatedField<string> result)
    {
      string output = "";
      foreach (var str in result)
      {
        output += str + "\n";
      }
      return output;
    }
 
    public string CommandLineRun(string command)
    {
      var request = new CommandLineRequest { Command = command };
      var reply = client.CommandLine(request);
      return ParseRepeatedString(reply.Result);
    }
 
    public CompileSuccess Compile(string path, string entryPoint = DEFAULT_ENTRY_POINT, string exceptionHandler = "")
    {
      var request = new CompileRequest { Path = path, EntryPoint = entryPoint, ExceptionHandler = exceptionHandler };
      var reply = client.Compile(request, null, DateTime.UtcNow.AddSeconds(10));
      string errorMessage = "Unknown compilation error!";
      warnings = "";
      foreach (var str in reply.Warnings)
      {
        warnings += str + "\n";
      }
 
      switch (reply.ResultCase)
      {
        case CompileResponse.ResultOneofCase.CompileSuccess:
          lastCompileSuccess = reply.CompileSuccess;
          break;
        case CompileResponse.ResultOneofCase.CompileFailure:
          var failInfo = reply.CompileFailure;
          errorMessage =
            "Compilation Failure: " + failInfo.CompilerText +
            "\n  Message: " + failInfo.CompilerMessage +
            "\n  Line: " + failInfo.CompilerLine + ", character: " + failInfo.CompilerStart;
          throw new Exception(errorMessage);
        case CompileResponse.ResultOneofCase.GeneralFailure:
          errorMessage = "Compilation General Failure: " + reply.GeneralFailure;
          throw new Exception(errorMessage);
        default:
          throw new Exception(errorMessage);
      }
 
      return reply.CompileSuccess;
    }
 
    public string WarningsGet()
    {
      return warnings;
    }
 
    private string RunCore(CompileSuccess compileSuccess, ulong[] breakpoints, bool block)
    {
      if (compileSuccess == null)
      {
        throw new Exception("No previously successful compilation found!");
      }
      var request = new RunRequest { Block = block, Compiled = compileSuccess, };
      if (breakpoints != null)
      {
        foreach (var breakpoint in breakpoints)
        {
          request.Breakpoints.Add(breakpoint);
        }
      }
      var reply = client.Run(request);
      return reply.Task.Id;
    }
 
    public string Run(ulong[] breakpoints = null)
    {
      return RunCore(lastCompileSuccess, breakpoints, true);
    }
 
    public string Run(CompileSuccess compileSuccess, ulong[] breakpoints = null)
    {
      return RunCore(compileSuccess, breakpoints, true);
    }
 
    public string RunAsync(ulong[] breakpoints = null)
    {
      return RunCore(lastCompileSuccess, breakpoints, false);
    }
 
    public string RunAsync(CompileSuccess compileSuccess, ulong[] breakpoints = null)
    {
      return RunCore(compileSuccess, breakpoints, false);
    }
 
    public void Shutdown()
    {
      var serverControlClient = new RapidServer.ServerControlService.ServerControlServiceClient(channel);
      serverControlClient.Shutdown(new RapidServer.ServerShutdownRequest());
    }
 
    public void EngineStart(string rmpNode = "NodeA", string rmpPath = "")
    {
      client.EngineStart(new EngineStartRequest { RmpNode = rmpNode, RmpPath = rmpPath });
    }
 
    public void EngineStop()
    {
      client.EngineStop(new EngineStopRequest());
    }
 
    public EngineStatus EngineStatusGet()
    {
      var reply = client.EngineStatusGet(new EngineStatusRequest());
      return new EngineStatus { Running = reply.Running, SequencerType = reply.Type, TaskCount = reply.TaskCount, };
    }
 
    public static TaskID TaskIDFromString(string taskId)
    {
      return new TaskID { Id = taskId };
    }
 
    public void TaskStop(string taskId)
    {
      client.TaskStop(TaskIDFromString(taskId));
    }
 
    public void TaskPause(string taskId)
    {
      client.TaskPause(TaskIDFromString(taskId));
    }
 
    public void TaskResume(string taskId)
    {
      client.TaskResume(TaskIDFromString(taskId));
    }
 
    public void TaskRemove(string taskId)
    {
      var reply = client.TaskRemove(TaskIDFromString(taskId));
      if (!reply.Result)
      {
        throw new Exception($"Failed to remove task: {taskId}. Ensure that task is stopped before removing.");
      }
    }
 
    public TaskStatus TaskStatusGet(string taskId)
    {
      var reply = client.TaskStatusGet(TaskIDFromString(taskId));
      return new TaskStatus { State = reply.State, LineNumber = reply.LineNumber, Counter = reply.Counter, };
    }
 
    public string TaskOutputGet(string taskId)
    {
      var reply = client.TaskOutputGet(TaskIDFromString(taskId));
      return ParseRepeatedString(reply.Result);
    }
 
    public void DebugResume(string taskId)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.ResumeUnspecified });
    }
 
    public void DebugPause(string taskId)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.Pause });
    }
 
    public void DebugStep(string taskId)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.Step });
    }
 
    public void DebugStepIn(string taskId)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.StepIn });
    }
 
    public void DebugStepOut(string taskId)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.StepOut });
    }
 
 
    public void DebugBreakpointSet(string taskId, ulong lineNumber)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.BreakpointSet, LineNumber = (int)lineNumber });
    }
 
    public void DebugBreakpointRemove(string taskId, ulong lineNumber)
    {
      client.DebugCommand(new DebugRequest { Task = TaskIDFromString(taskId), Action = DebugAction.BreakpointUnset, LineNumber = (int)lineNumber });
    }
 
    private SequencerGlobal ParseGlobalVariableGetResponse(GlobalVariableGetResponse reply)
    {
      var globalVar = new SequencerGlobal
      {
        HostAddress = reply.HostAddress,
        FirmwareAddress = reply.FirmwareAddress,
        Index = reply.Index
      };
 
      switch (reply.ValueCase)
      {
        case GlobalVariableGetResponse.ValueOneofCase.Bool:
          globalVar.Type = SequencerGlobal.DataType.Bool;
          globalVar.Value = reply.Bool;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Char:
          globalVar.Type = SequencerGlobal.DataType.Char;
          globalVar.Value = reply.Char;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Int16:
          globalVar.Type = SequencerGlobal.DataType.Int16;
          globalVar.Value = reply.Int16;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Uint16:
          globalVar.Type = SequencerGlobal.DataType.UInt16;
          globalVar.Value = reply.Uint16;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Int32:
          globalVar.Type = SequencerGlobal.DataType.Int32;
          globalVar.Value = reply.Int32;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Uint32:
          globalVar.Type = SequencerGlobal.DataType.UInt32;
          globalVar.Value = reply.Uint32;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Int64:
          globalVar.Type = SequencerGlobal.DataType.Int64;
          globalVar.Value = reply.Int64;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Uint64:
          globalVar.Type = SequencerGlobal.DataType.UInt64;
          globalVar.Value = reply.Uint64;
          break;
        case GlobalVariableGetResponse.ValueOneofCase.Double:
          globalVar.Type = SequencerGlobal.DataType.Double;
          globalVar.Value = reply.Double;
          break;
        default:
          throw new Exception("Unknown data type in GlobalVariableGetResponse.");
      }
      return globalVar;
    }
 
    public SequencerGlobal GlobalVariableGet(string name)
    {
      var request = new GlobalVariableGetRequest { Name = name };
      var reply = client.GlobalVariableGet(request);
      var global = ParseGlobalVariableGetResponse(reply);
      global.Name = name;
      return global;
    }
 
    private SequencerGlobal ParseGlobalVariableData(GlobalVariableData data)
    {
      var globalVar = new SequencerGlobal
      {
        Name = data.Name,
        HostAddress = data.HostAddress,
        FirmwareAddress = data.FirmwareAddress,
        Index = data.Index,
        Size = data.Size
      };
 
      switch (data.ValueCase)
      {
        case GlobalVariableData.ValueOneofCase.Bool:
          globalVar.Type = SequencerGlobal.DataType.Bool;
          globalVar.Value = data.Bool;
          break;
        case GlobalVariableData.ValueOneofCase.Char:
          globalVar.Type = SequencerGlobal.DataType.Char;
          globalVar.Value = data.Char;
          break;
        case GlobalVariableData.ValueOneofCase.Int16:
          globalVar.Type = SequencerGlobal.DataType.Int16;
          globalVar.Value = data.Int16;
          break;
        case GlobalVariableData.ValueOneofCase.Uint16:
          globalVar.Type = SequencerGlobal.DataType.UInt16;
          globalVar.Value = data.Uint16;
          break;
        case GlobalVariableData.ValueOneofCase.Int32:
          globalVar.Type = SequencerGlobal.DataType.Int32;
          globalVar.Value = data.Int32;
          break;
        case GlobalVariableData.ValueOneofCase.Uint32:
          globalVar.Type = SequencerGlobal.DataType.UInt32;
          globalVar.Value = data.Uint32;
          break;
        case GlobalVariableData.ValueOneofCase.Int64:
          globalVar.Type = SequencerGlobal.DataType.Int64;
          globalVar.Value = data.Int64;
          break;
        case GlobalVariableData.ValueOneofCase.Uint64:
          globalVar.Type = SequencerGlobal.DataType.UInt64;
          globalVar.Value = data.Uint64;
          break;
        case GlobalVariableData.ValueOneofCase.Double:
          globalVar.Type = SequencerGlobal.DataType.Double;
          globalVar.Value = data.Double;
          break;
        default:
          throw new Exception("Unkown data type in GlobalVariableData.");
      }
      return globalVar;
    }
 
    public SequencerGlobal[] GlobalVariableListGet(bool skipValues = false)
    {
      var request = new GlobalVariableListGetRequest { SkipValues = skipValues };
      var reply = client.GlobalVariableListGet(request);
      List<SequencerGlobal> globals = new List<SequencerGlobal>();
      foreach (var globalData in reply.Data)
      {
        globals.Add(ParseGlobalVariableData(globalData));
      }
      return globals.ToArray();
    }
 
    public void GlobalVariableSet(string name, SequencerGlobal.DataType type, dynamic value)
    {
      var request = new GlobalVariableSetRequest { Name = name };
      switch (type)
      {
        case SequencerGlobal.DataType.Bool:
          request.Bool = Convert.ToBoolean(value);
          break;
        case SequencerGlobal.DataType.Char:
          request.Char = Convert.ToChar(value);
          break;
        case SequencerGlobal.DataType.Int16:
          request.Int16 = Convert.ToInt16(value);
          break;
        case SequencerGlobal.DataType.UInt16:
          request.Uint16 = Convert.ToUInt16(value);
          break;
        case SequencerGlobal.DataType.Int32:
          request.Int32 = Convert.ToInt32(value);
          break;
        case SequencerGlobal.DataType.UInt32:
          request.Uint32 = Convert.ToUInt32(value);
          break;
        case SequencerGlobal.DataType.Int64:
          request.Int64 = Convert.ToInt64(value);
          break;
        case SequencerGlobal.DataType.UInt64:
          request.Uint64 = Convert.ToUInt64(value);
          break;
        case SequencerGlobal.DataType.Double:
          request.Double = Convert.ToDouble(value);
          break;
        default:
          throw new Exception("Unkown data type given in GlobalVariableSet().");
      }
      client.GlobalVariableSet(request);
    }
  }
 
  public class RapidSequencerFactory
  {
    public const string DEFAULT_SEQUENCER_NODE_NAME = "NodeB";
    public const string DEFAULT_RMP_NODE_NAME = "NodeA";
    public const string DEFAULT_IP = "localhost";
    public const string DEFAULT_MCAST_GROUP = "224.0.0.0";
    public const int DEFAULT_GRPC_PORT = 50051;
    public const ulong DEFAULT_TIMEOUT_MS = 1000;
    public const int DEFAULT_DISCOVER_PORT = 60061;
 
    public static RapidSequencer[] Discover(DiscoveryType discoveryType, ushort numExpectedSequencers = 0, string sequencerNodeName = DEFAULT_SEQUENCER_NODE_NAME, ulong timeoutMs = DEFAULT_TIMEOUT_MS, int discoveryPort = DEFAULT_DISCOVER_PORT)
    {
      ServerInfoCollection result;
      if (discoveryType == DiscoveryType.All)
      {
        result = API.DiscoverBroadcast(discoveryType, numExpectedSequencers, sequencerNodeName, timeoutMs, discoveryPort);
      }
      else if (discoveryType == DiscoveryType.Local_Intime)
      {
        result = API.DiscoverLocalINtime(sequencerNodeName);
      }
      else if (discoveryType == DiscoveryType.Local_Windows)
      {
        result = API.DiscoverLocalWindows();
      }
      else
      {
        result = API.DiscoverLocal(sequencerNodeName);
      }
 
 
      var foundSequencers = new List<RapidSequencer>();
      for (uint index = 0; index < result.ServerCount(); index++)
      {
        try
        {
          //foundSequencers.Add(new RapidSequencer(addresses[index], ports[index]));
 
          var sequencerInfo = result.ServerInfoGet(index);
          foundSequencers.Add(new RapidSequencer(sequencerInfo.AddressGet(), sequencerInfo.PortGet()));
        }
        catch
        {
          // something happened to the seqeuncer or the grpc channel failed for some reason? Just don't add it to the list?
          // For now, I will just not add a sequencer to the list if the Constructor throws an exception due to the grpc channels not being set up properly
        }
      }
 
      return foundSequencers.ToArray();
    }
 
    public static RapidSequencer Create(Platform platform, string sequencerNodeName, string rmpNodeName, string executablePath,
      int grpcPort = DEFAULT_GRPC_PORT, string friendlyName = "RapidServer", ulong timeoutMs = DEFAULT_TIMEOUT_MS, int discoveryPort = DEFAULT_DISCOVER_PORT)
    {
      //int sequencerCount = 10;
      //int addressSize = 46;
      //string[] addresses = new string[sequencerCount];
      //int[] ports = new int[sequencerCount];
      //int usedElements;
      //int foundIndex;
 
      //var result = RSI.RapidSequencer.API.CreateStart(platform, sequencerNodeName, rmpNodeName, executablePath, ref addresses, sequencerCount, addressSize,
      //  ports, sequencerCount, out usedElements, out foundIndex, timeoutMs, (int)grpcPort, friendlyName, mcastGroup, (int)mcastPort);
 
      //if (result == CreateDiscoverResult.OK && usedElements > 0 && foundIndex > -1)
      //{
      //  var sequencer = new RapidSequencer(addresses[foundIndex], ports[foundIndex]);
      //  sequencer.EngineStart();
      //  return sequencer;
      //}
      //else
      //{
      //  string errorMessage = $"Failed to create a new sequencer at port: {grpcPort}. ";
      //  switch (result)
      //  {
      //    case CreateDiscoverResult.DiscoveryTimeout:
      //      errorMessage += "Discovery timed out.";
      //      break;
      //    case CreateDiscoverResult.ExecutableDNE:
      //      errorMessage += "Executable could not be found.";
      //      break;
      //    case CreateDiscoverResult.ExecutableFailure:
      //      errorMessage += "Executable failure.";
      //      break;
      //    case CreateDiscoverResult.UnknownINtimeNode:
      //      errorMessage += "Unknown INtime node.";
      //      break;
      //    case CreateDiscoverResult.UnknownPlatform:
      //      errorMessage += "Unknown platform.";
      //      break;
      //  }
      //  throw new Exception(errorMessage);
      //}
 
      var result = RSI.RapidSequencer.API.Start(platform, sequencerNodeName, rmpNodeName, executablePath, grpcPort, friendlyName, timeoutMs, discoveryPort);
      return new RapidSequencer(result.AddressGet(), result.PortGet());
    }
 
    public static RapidSequencer CreateWindows(string sequencerNodeName, string rmpNodeName, string executablePath, int grpcPort = DEFAULT_GRPC_PORT,
      string friendlyName = "RapidServer", ulong timeoutMs = DEFAULT_TIMEOUT_MS, int discoveryPort = DEFAULT_DISCOVER_PORT)
    {
      return Create(Platform.Windows, sequencerNodeName, rmpNodeName, executablePath, grpcPort, friendlyName, timeoutMs, discoveryPort);
    }
 
    public static RapidSequencer CreateRT(string sequencerNodeName, string rmpNodeName, string executablePath, int grpcPort = DEFAULT_GRPC_PORT,
      string friendlyName = "RapidServer", ulong timeoutMs = DEFAULT_TIMEOUT_MS, int discoveryPort = DEFAULT_DISCOVER_PORT)
    {
      return Create(Platform.INtime, sequencerNodeName, rmpNodeName, executablePath, grpcPort, friendlyName, timeoutMs, discoveryPort);
    }
  }
 
}