Boot - create comms between Daemon and Tau

This enables Tauto send the system pid of the erlang beam process over a TCP connection to Daemon now that the Elixir release scripts boots things indirectly.

The comms channel consists of a single TCP connection which expects OSC in a similar manner to SuperCollider - 32 bit unsigned big endian data size followed by that many bytes of OSC message.

This new TCP socket now also acts as the mechanism for the Daemon to determine whether or not Tau is still alive.

Author: samaaron

app/server/erlang/tau/boot-lin.sh

@@ -6,4 +6,4 @@ cd ${SCRIPT_DIR}
 
 echo "Booting Sonic Pi on Linux..."
 
-TAU_ENABLED=$1 TAU_INTERNAL=$2 TAU_MIDI_ENABLED=$3 TAU_LINK_ENABLED=$4 TAU_IN_PORT=$5 TAU_API_PORT=$6 TAU_SPIDER_PORT=$7 exec _build/"${MIX_ENV:-dev}"/rel/tau/bin/tau start
+TAU_ENABLED=$1 TAU_INTERNAL=$2 TAU_MIDI_ENABLED=$3 TAU_LINK_ENABLED=$4 TAU_IN_PORT=$5 TAU_API_PORT=$6 TAU_SPIDER_PORT=$7 TAU_DAEMON_PORT=$8 _build/"${MIX_ENV:-dev}"/rel/tau/bin/tau start

app/server/erlang/tau/boot-mac.sh

@@ -6,4 +6,4 @@ cd ${SCRIPT_DIR}
 
 echo "Booting Sonic Pi on macOS..."
 
-TAU_ENABLED=$1 TAU_INTERNAL=$2 TAU_MIDI_ENABLED=$3 TAU_LINK_ENABLED=$4 TAU_IN_PORT=$5 TAU_API_PORT=$6 TAU_SPIDER_PORT=$7 exec _build/"${MIX_ENV:-dev}"/rel/tau/bin/tau start
+TAU_ENABLED=$1 TAU_INTERNAL=$2 TAU_MIDI_ENABLED=$3 TAU_LINK_ENABLED=$4 TAU_IN_PORT=$5 TAU_API_PORT=$6 TAU_SPIDER_PORT=$7 TAU_DAEMON_PORT=$8 _build/"${MIX_ENV:-dev}"/rel/tau/bin/tau start

app/server/erlang/tau/boot-win.bat

@@ -12,6 +12,7 @@ set TAU_LINK_ENABLED=%4%
 set TAU_IN_PORT=%5%
 set TAU_API_PORT=%6%
 set TAU_SPIDER_PORT=%7%
+set TAU_DAEMON_PORT=%8%
 
 IF NOT DEFINED MIX_ENV SET "MIX_ENV=dev"
 

app/server/erlang/tau/lib/tau.ex

@@ -4,49 +4,45 @@ use Application
   @impl true
   def start(_type, _args) do
     IO.puts "All systems booting.,.."
-
-    enabled = extract_env("TAU_ENABLED", :bool)
-    internal = extract_env("TAU_INTERNAL", :bool)
-    midi_enabled = extract_env("TAU_MIDI_ENABLED", :bool)
-    link_enabled = extract_env("TAU_LINK_ENABLED", :bool)
-    in_port = extract_env("TAU_IN_PORT", :int)
-    api_port = extract_env("TAU_API_PORT", :int)
-    spider_port = extract_env("TAU_SPIDER_PORT", :int)
-
-    Application.put_env(:tau, :enabled, enabled)
-    Application.put_env(:tau, :internal, internal)
-    Application.put_env(:tau, :midi_enabled, midi_enabled)
-    Application.put_env(:tau, :link_enabled, link_enabled)
-    Application.put_env(:tau, :in_port, in_port)
-    Application.put_env(:tau, :api_port, api_port)
-    Application.put_env(:tau, :spider_port, spider_port)
+    IO.puts "Pid: #{System.pid()}"
+    enabled      = extract_env("TAU_ENABLED",      :bool, true)
+    internal     = extract_env("TAU_INTERNAL",     :bool, true)
+    midi_enabled = extract_env("TAU_MIDI_ENABLED", :bool, true)
+    link_enabled = extract_env("TAU_LINK_ENABLED", :bool, true)
+    in_port      = extract_env("TAU_IN_PORT",      :int,  5000)
+    api_port     = extract_env("TAU_API_PORT",     :int,  5001)
+    spider_port  = extract_env("TAU_SPIDER_PORT",  :int,  5002)
+    daemon_port  = extract_env("TAU_DAEMON_PORT",  :int,  -1)
 
     :tau_server_sup.set_application_env(enabled,
       internal,
       midi_enabled,
       link_enabled,
       in_port,
       api_port,
-      spider_port)
+      spider_port,
+      daemon_port
+    )
 
     # Although we don't use the supervisor name below directly,
     # it can be useful when debugging or introspecting the system.
     :tau_server_sup.start_link()
   end
 
-  def extract_env(name, kind) do
+  def extract_env(name, kind, default) do
     env_val = System.get_env(name)
-    if !env_val do
-      raise "Error, missing ENV Variable #{name}"
+    res = if !env_val do
+      IO.puts "No env variable supplied for #{name} using default: #{default}"
+      default
+    else
+      extracted = case kind do
+                    :bool -> extract_env_bool(env_val)
+                    :int -> extract_env_int(env_val)
+                    :string -> env_val
+                  end
+      IO.puts "extracting env #{name} #{kind} #{extracted}"
+      extracted
     end
-    res = case kind do
-            :bool -> extract_env_bool(env_val)
-            :int -> extract_env_int(env_val)
-            :string -> env_val
-
-          end
-
-    IO.puts "extracting env #{name} #{kind} #{res}"
     res
   end
 

app/server/erlang/tau/src/tau_server/tau_server_api.erl

@@ -78,6 +78,8 @@ start_link(CueServer, MIDIServer, LinkServer) ->
 init(Parent, CueServer, MIDIServer, LinkServer) ->
     register(?SERVER, self()),
     APIPort = application:get_env(?APPLICATION, api_port, undefined),
+    DaemonPort = application:get_env(?APPLICATION, daemon_port, undefined),
+
     io:format("~n"
               "+--------------------------------------+~n"
               "    This is the Sonic Pi API Server     ~n"
@@ -88,10 +90,24 @@ init(Parent, CueServer, MIDIServer, LinkServer) ->
               [erlang:system_info(otp_release), APIPort]),
 
     {ok, APISocket} = gen_udp:open(APIPort, [binary, {ip, loopback}]),
-
+    io:format("connecting to Daemon via TCP...~n", []),
+    {ok, DaemonSocket} = gen_tcp:connect({127,0,0,1}, DaemonPort, [
+                                                                   binary,
+                                                                   {active, true},
+                                                                   {packet, 4},
+                                                                   {keepalive, true}
+                                                                  ]),
+
+    PidMsg = osc:encode(["/tau_pid", os:getpid()]),
+    io:format("Sending Pid to Daemon...~n", []),
+
+    gen_tcp:send(DaemonSocket, PidMsg),
     %% tell parent we have allocated resources and are up and running
     proc_lib:init_ack(Parent, {ok, self()}),
 
+
+
+
     debug(2, "listening for API commands on socket: ~p~n",
           [try erlang:port_info(APISocket) catch _:_ -> undefined end]),
     State = #{parent => Parent,
@@ -106,6 +122,10 @@ init(Parent, CueServer, MIDIServer, LinkServer) ->
 
 loop(State) ->
     receive
+        {tcp, Socket, Data} ->
+            debug(3, "api server got TCP on ~p:~p~n", [Socket, Data]),
+            ?MODULE:loop(State);
+
         {timeout, Timer, {call, Server, Msg, Tracker}} ->
             Server ! Msg,
             tau_server_tracker:forget(Timer, Tracker),

app/server/erlang/tau/src/tau_server/tau_server_sup.erl

@@ -9,8 +9,7 @@
 
 %% Supervisor callbacks
 -export([init/1]).
--export([set_application_env/7]).
-
+-export([set_application_env/8]).
 
 -define(APPLICATION, tau).
 
@@ -39,15 +38,17 @@ set_application_env(Enabled,
                     LinkEnabled,
                     InPort,
                     ApiPort,
-                    SpiderPort) ->
+                    SpiderPort,
+                    DaemonPort) ->
 
     application:set_env(?APPLICATION, enabled, Enabled),
     application:set_env(?APPLICATION, internal, Internal),
     application:set_env(?APPLICATION, midi_enabled, MidiEnabled),
     application:set_env(?APPLICATION, link_enabled, LinkEnabled),
     application:set_env(?APPLICATION, in_port, InPort),
     application:set_env(?APPLICATION, api_port, ApiPort),
-    application:set_env(?APPLICATION, spider_port, SpiderPort).
+    application:set_env(?APPLICATION, spider_port, SpiderPort),
+    application:set_env(?APPLICATION, daemon_port, DaemonPort).
 
 init(_Args) ->
     CueServer = tau_server_cue:server_name(),

app/server/ruby/bin/daemon.rb

@@ -18,6 +18,9 @@
 require 'fileutils'
 require 'time'
 
+require_relative "../lib/sonicpi/osc/osc"
+require_relative "../lib/sonicpi/promise"
+
 # Make sure vendored tomlrb lib is on the Ruby path so it can be required
 Dir["#{File.expand_path("../../vendor", __FILE__)}/*/lib/"].each do |vendor_lib|
   $:.unshift vendor_lib
@@ -148,7 +151,15 @@ def initialize
         @scsynth_booter = ScsynthBooter.new(ports)
 
         Util.log "Booting Tau"
-        @tau_booter     = TauBooter.new(ports)
+        begin
+          @tau_booter = TauBooter.new(ports)
+        rescue StandardError => e
+          Util.log "Oh no, something went wrong booting Tau"
+          Util.log "Error Class: #{e.class}"
+          Util.log "Error Message: #{e.message}"
+          Util.log "Error Backtrace: #{e.backtrace.inspect}"
+        end
+
 
         Util.log "Booting Spider Server"
         @spider_booter  = SpiderBooter.new(ports)
@@ -193,7 +204,7 @@ def spawn_zombie_kill_switch(port_num, &blk)
             Util.log "Waiting for GUI on port #{port_num}...."
 
             unless IO.select([keep_alive_server], nil, nil, connect_timeout)
-              Util.log "Error. Unable to connect to GUI process on TCP port #{port_num}"
+              Util.log "Critical Error. Unable to connect to GUI process on TCP port #{port_num}"
               @safe_exit.exit
             end
 
@@ -215,9 +226,10 @@ def spawn_zombie_kill_switch(port_num, &blk)
             Util.log "Error Backtrace: #{e.backtrace.inspect}"
           end
 
-          Util.log "Shutting down..."
+          Util.log "Critical Error. Lost comms with GUI."
           client.close if client
           keep_alive_server.close if keep_alive_server
+
           @safe_exit.exit
         end
       end
@@ -371,16 +383,23 @@ def idempotent_exit_cleanup
       end
     end
 
-
-
     class ProcessBooter
       attr_reader :pid, :args, :cmd
       def initialize(cmd, args, log_path)
+        @pid = nil
         @args = args.map {|el| el.to_s}
         @cmd = cmd
         @log_file = File.open(log_path, 'a')
         raise "Unable to create log file at path: #{log_path}" unless @log_file
-        boot
+        begin
+          boot
+        rescue StandardError => e
+          Util.log "Error: something went wrong booting process: #{cmd}, #{args}, #{log_path}"
+          Util.log "Error Class: #{e.class}"
+          Util.log "Error Message: #{e.message}"
+          Util.log "Error Backtrace: #{e.backtrace.inspect}"
+          @log_file.close if @log_file
+        end
       end
 
       def inspect
@@ -499,21 +518,72 @@ def initialize(ports)
 
     class TauBooter < ProcessBooter
       def initialize(ports)
+        @tau_pid = Promise.new
         enabled      = true
         internal     = false
         midi_enabled = true
         link_enabled = true
         in_port      = ports["osc-cues"]
         api_port     = ports["tau"]
         spider_port  = ports["listen-to-tau"]
+        daemon_port  = ports["daemon-listen-to-tau"]
+
+        tau_comms    = TCPServer.new "127.0.0.1", daemon_port
+        osc_decoder  = SonicPi::OSC::OscDecode.new
+
+        Thread.new do
+          client = nil
+
+          @tau_comms_thread = Thread.new do
+            Util.log "----->   Accepting incoming connection from Tau"
+            client = tau_comms.accept    # Wait for a client to connect
+            Util.log "----->   Connection accepted"
+
+            recv_osc = lambda do
+              size_str = client.recvfrom(4, Socket::MSG_WAITALL)[0].chomp
+              size = size_str.unpack('N')[0]
+              raise "Critical Error: Bad TCP OSC size received from Tau #{size_str}" unless size
+              data_raw = client.recvfrom(size, Socket::MSG_WAITALL)[0].chomp
+              osc_decoder.decode_single_message(data_raw)
+            end
+
+
+            begin
+              data = recv_osc.call
+              tau_pid = Integer(data[1][0])
+              @tau_pid.deliver!(tau_pid)
+              Util.log "----->   Tau Pid: #{tau_pid}"
+
+              loop do
+                data = recv_osc.call
+                Util.log "Received OSC from Tau: #{data}"
+                # In the future this is where we can handle any callbacks from Tau
+              end
+            rescue Errno::ECONNRESET
+              Util.log  "Tau closed TCP connection"
+            rescue StandardError => e
+              Util.log "Critical Error, whilst communicating with Tau:"
+              Util.log "Error Class: #{e.class}"
+              Util.log "Error Message: #{e.message}"
+              Util.log "Error Backtrace: #{e.backtrace.inspect}"
+            end
+          end
+
+          @tau_comms_thread.join
+          client.close if client
+          tau_comms.close if tau_comms
+        end
 
-        args = [enabled,
+        args = [
+          enabled,
           internal,
           midi_enabled,
           link_enabled,
           in_port,
           api_port,
-          spider_port]
+          spider_port,
+          daemon_port
+        ]
 
         if Util.os == :windows
           cmd = Paths.mix_release_boot_path
@@ -524,6 +594,20 @@ def initialize(ports)
 
         super(cmd, args, Paths.tau_log_path)
       end
+
+      def process_running?
+        @tau_comms_thread.alive?
+      end
+
+      def kill
+        @tau_comms_thread.kill
+        @pid = @tau_pid.get
+        super
+      end
+
+      def wait
+        @tau_comms_thread.join
+      end
     end
 
 
@@ -749,6 +833,8 @@ class PortDiscovery
         # Port which the Ruby server listens to messages back from the Tau server
         "listen-to-tau" => :dynamic,
 
+        "daemon-listen-to-tau" => :dynamic,
+
         # Port which the server uses to communicate via websockets
         # (This is currently unused.)
         "websocket" => :dynamic
@@ -777,6 +863,7 @@ def initialize(safe_exit)
           "osc-cues",
           "tau",
           "listen-to-tau",
+          "daemon-listen-to-tau",
           "websocket"].inject({}) do |res, port_name|
 
           default = nil
@@ -788,15 +875,19 @@ def initialize(safe_exit)
             elsif default == :paired
               port = res[port_name[1]]
             else
-              port = default
+              if check_port(default)
+                port = default
+              else
+                port = find_free_port
+              end
             end
             res[port_name[0]] = port.to_i
           else
             default = PORT_CONFIG[port_name]
             if default == :dynamic
               port = find_free_port
             elsif default == :paired
-              raise "Invalid port default for port: #{port_name}. This port can not be paired."
+              Util.log "Critical error: Invalid port default for port: #{port_name}. This port can not be paired."
               @safe_exit.exit
             else
               port = default
@@ -816,6 +907,7 @@ def check_port(port)
         begin
           socket = UDPSocket.new
           socket.bind('127.0.0.1', port)
+          Util.log "checked port #{port}, #{socket}"
           socket.close
           available = true
         rescue StandardError
@@ -827,6 +919,7 @@ def check_port(port)
       def find_free_port
         while !check_port(@last_free_port += 1)
           if @last_free_port > 65535
+            Util.log "Critical error: Unable to find a free port."
             @safe_exit.exit
           end
         end