qcmd 0.1.7 → 0.1.8

data/lib/qcmd/context.rb

@@ -1,13 +1,15 @@
 module Qcmd
   class Context
-    attr_accessor :machine, :workspace, :workspace_connected
+    attr_accessor :machine, :workspace, :workspace_connected, :cue, :cue_connected, :qlab
 
     def reset
       disconnect_machine
       disconnect_workspace
+      disconnect_cue
     end
 
     def disconnect_machine
+      self.qlab.close unless self.qlab.nil?
       self.machine = nil
     end
 
@@ -16,6 +18,11 @@ module Qcmd
       self.workspace_connected = false
     end
 
+    def disconnect_cue
+      self.cue = nil
+      self.cue_connected = false
+    end
+
     def machine_connected?
       !machine.nil?
     end
@@ -24,27 +31,26 @@ module Qcmd
       !!workspace_connected
     end
 
+    def cue_connected?
+      !!cue_connected
+    end
+
     def connection_state
       if !machine_connected?
         :none
       elsif !workspace_connected?
         :machine
-      else
+      elsif !cue_connected?
         :workspace
+      else
+        :cue
       end
     end
 
-    def print_workspace_list
-      Qcmd.print Qcmd.centered_text(" Workspaces ", '-')
-      Qcmd.print
-
-      machine.workspaces.each_with_index do |ws, n|
-        Qcmd.print "#{ n + 1 }. #{ ws.name }#{ ws.passcode? ? ' [PROTECTED]' : ''}"
-      end
-
-      Qcmd.print
-      Qcmd.print_wrapped('Type `use "WORKSPACE_NAME" PASSCODE` to load a workspace. Passcode is optional.')
-      Qcmd.print
+    def connect_to_qlab handler=nil
+      # get an open connection with the default handler
+      handler ||= Qcmd::Handler
+      self.qlab = OSC::TCPClient.new(machine.address, machine.port, handler)
     end
   end
 end

data/lib/qcmd/core_ext/osc/tcp_client.rb

@@ -0,0 +1,155 @@
+# An OSC TCP client sends and receives on the same socket using the SLIP
+# protocol.
+#
+# http://www.ietf.org/rfc/rfc1055.txt
+
+module OSC
+  class TCPClient
+
+    CHAR_END     = 0300 # indicates end of packet
+    CHAR_ESC     = 0333 # indicates byte stuffing
+    CHAR_ESC_END = 0334 # ESC ESC_END means END data byte
+    CHAR_ESC_ESC = 0335 # ESC ESC_ESC means ESC data byte
+
+    CHAR_END_ENC     = [0300].pack('C') # indicates end of packet
+    CHAR_ESC_ENC     = [0333].pack('C') # indicates byte stuffing
+    CHAR_ESC_END_ENC = [0334].pack('C') # ESC ESC_END means END data byte
+    CHAR_ESC_ESC_ENC = [0335].pack('C') # ESC ESC_ESC means ESC data byte
+
+    def initialize host, port, handler=nil
+      @host = host
+      @port = port
+      @handler = handler
+      @so   = TCPSocket.new host, port
+    end
+
+    def close
+      @so.close unless closed?
+    end
+
+    def closed?
+      @so.closed?
+    end
+
+    # send an OSC::Message
+    def send msg
+      enc_msg = msg.encode
+
+      send_char CHAR_END
+
+      enc_msg.bytes.each do |b|
+        case b
+        when CHAR_END
+          send_char CHAR_ESC
+          send_char CHAR_ESC_END
+        when CHAR_ESC
+          send_char CHAR_ESC
+          send_char CHAR_ESC_ESC
+        else
+          send_char b
+        end
+      end
+
+      send_char CHAR_END
+
+      if block_given? || @handler
+        messages = response
+        if !messages.nil?
+          messages.each do |message|
+            if block_given?
+              yield message
+            else
+              @handler.handle message
+            end
+          end
+        end
+      end
+    end
+
+    def response
+      if received_messages = receive_raw
+        received_messages.map do |message|
+          OSCPacket.messages_from_network(message)
+        end.flatten
+      else
+        nil
+      end
+    end
+
+    def to_s
+      "#<OSC::TCPClient:#{ object_id } @host:#{ @host.inspect }, @port:#{ @port.inspect }, @handler:#{ @handler.to_s }>"
+    end
+
+    private
+
+    def send_char c
+      @so.send [c].pack('C'), 0
+    end
+
+    def receive_raw
+      received = 0
+      messages = []
+      buffer   = []
+      failed   = false
+      received_any = false
+
+      loop do
+        begin
+          # get a character from the socket, fail if nothing is available
+          c = @so.recv_nonblock(1)
+
+          received_any = true
+
+          case c
+          when CHAR_END_ENC
+            if received > 0
+              # add SLIP encoded message to list
+              messages << buffer.join
+
+              # reset state and keep reading from the port until there's
+              # nothing left
+              buffer.clear
+              received = 0
+              failed = false
+            end
+          when CHAR_ESC_ENC
+            # get next character, blocking is okay
+            c = @so.recv(1)
+            case c
+            when CHAR_ESC_END_ENC
+              c = CHAR_END_ENC
+            when CHAR_ESC_ESC_ENC
+              c = CHAR_ESC_ENC
+            else
+              received += 1
+              buffer << c
+            end
+          else
+            received += 1
+            buffer << c
+          end
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          # If any messages have been received, assume sender is done sending.
+          if failed || received_any
+            break
+          end
+
+          # wait one second to see if the socket might become readable (and a
+          # response forthcoming). normal usage is send + wait for response,
+          # we have to give QLab a reasonable amount of time in which to respond.
+
+          IO.select([@so], [], [], 1)
+          failed = true
+          retry
+        end
+      end
+
+      if messages.size > 0
+        messages
+      else
+        nil
+      end
+    end
+  end
+end
+

data/lib/qcmd/handler.rb

@@ -1,86 +1,68 @@
 module Qcmd
   class Handler
-    include Qcmd::Plaintext
+    class << self
+      include Qcmd::Plaintext
 
-    def handle reply
-      Qcmd.debug "(handling #{ reply })"
+      # Handle OSC response message from QLab
+      def handle message
+        Qcmd.debug "[Handler handle] converting OSC::Message to QLab::Reply"
+        reply = QLab::Reply.new(message)
 
-      case reply.address
-      when %r[/workspaces]
-        Qcmd.context.machine.workspaces = reply.data.map {|ws| Qcmd::QLab::Workspace.new(ws)}
+        Qcmd.debug "[Handler handle] handling #{ reply.to_s }"
 
-        unless Qcmd.quiet?
-          Qcmd.context.print_workspace_list
-        end
-
-      when %r[/workspace/[^/]+/connect]
-        # connecting to a workspace
-        if reply.data == 'badpass'
-          print 'failed to connect to workspace, bad passcode or no passcode given'
-          Qcmd.context.disconnect_workspace
-        elsif reply.data == 'ok'
-          print 'connected to workspace'
-          Qcmd.context.workspace_connected = true
-        end
-
-      when %r[/cueLists]
-        Qcmd.debug "(received cueLists)"
+        case reply.address
+        when %r[/(selectedCues|runningCues|runningOrPausedCues)]
+          Qcmd.debug "[Handler handle] received cue list from #{reply.address}"
 
-        # load global cue list
-        Qcmd.context.workspace.cues = cues = reply.data.map {|cue_list|
-          cue_list['cues'].map {|cue| Qcmd::QLab::Cue.new(cue)}
-        }.compact.flatten
+          if reply.has_data?
+            cues = reply.data.map {|cue| Qcmd::QLab::Cue.new(cue)}
 
-      when %r[/(selectedCues|runningCues|runningOrPausedCues)]
-        cues = reply.data.map {|cue|
-          cues = [Qcmd::QLab::Cue.new(cue)]
+            if cues.size > 0
+              title = case reply.address
+                      when /selectedCues/;        "Selected Cues"
+                      when /runningCues/;         "Running Cues"
+                      when /runningOrPausedCues/; "Running or Paused Cues"
+                      end
 
-          if cue['cues']
-            cues << cue['cues'].map {|cue| Qcmd::QLab::Cue.new(cue)}
+              print
+              print centered_text(" #{title} ", '-')
+              table(['Number', 'Id', 'Name', 'Type'], cues.map {|cue|
+                [cue.number, cue.id, cue.name, cue.type]
+              })
+              print
+            else
+              print "no cues found"
+            end
           end
 
-          cues
-        }.compact.flatten
-
-        title = case reply.address
-                when /selectedCues/;        "Selected Cues"
-                when /runningCues/;         "Running Cues"
-                when /runningOrPausedCues/; "Running or Paused Cues"
-                end
-
-        print
-        print centered_text(" #{title} ", '-')
-        table(['Number', 'Id', 'Name', 'Type'], cues.map {|cue|
-          [cue.number, cue.id, cue.name, cue.type]
-        })
-        print
+        when %r[/thump]
+          print reply.data
 
-      when %r[/(cue|cue_id)/[^/]+/[a-zA-Z]+]
-        # properties, just print reply data
-        result = reply.data
-        if result.is_a?(String) || result.is_a?(Numeric)
-          print result
         else
-          case reply.address
-          when %r[/basics]
-            keys = result.keys.sort
-            table(['Field Name', 'Value'], keys.map {|key|
-              [key, result[key]]
-            })
-          else
-            begin
-              print JSON.pretty_generate(result)
-            rescue JSON::GeneratorError
-              print result.to_s
-            end
+          Qcmd.debug "[Handler handle] unrecognized message from QLab, cannot handle #{ reply.address }"
+
+          if !reply.status.nil? && reply.status != 'ok'
+            print reply.status
           end
         end
+      end
 
-      when %r[/thump]
-        print reply.data
+      def print_workspace_list
+        if Qcmd.context.machine.workspaces.nil? || Qcmd.context.machine.workspaces.empty?
+          Qcmd.print "there are no workspaces! you're gonna have a bad time :("
+          return
+        end
+
+        Qcmd.print Qcmd.centered_text(" Workspaces ", '-')
+        Qcmd.print
+
+        Qcmd.context.machine.workspaces.each_with_index do |ws, n|
+          Qcmd.print "#{ n + 1 }. #{ ws.name }#{ ws.passcode? ? ' [PROTECTED]' : ''}"
+        end
 
-      else
-        Qcmd.debug "(unrecognized message from QLab, cannot handle #{ reply.address })"
+        Qcmd.print
+        Qcmd.print_wrapped('Type `use "WORKSPACE_NAME" PASSCODE` to load a workspace. Passcode is required if workspace is [PROTECTED].')
+        Qcmd.print
       end
     end
   end

data/lib/qcmd/history.rb

@@ -0,0 +1,26 @@
+module Qcmd
+  class History
+    class << self
+      attr_accessor :commands
+
+      def load
+        if File.exists?(Qcmd::Configuration.history_file)
+          lines = File.new(Qcmd::Configuration.history_file, 'r').readlines
+        else
+          lines = []
+        end
+
+        if lines
+          lines.reverse[0..100].reverse.each {|hist|
+            Readline::HISTORY.push(hist)
+          }
+        end
+      end
+
+
+      def push command
+        Qcmd::Configuration.history.puts command
+      end
+    end
+  end
+end

data/lib/qcmd/input_completer.rb

@@ -7,9 +7,18 @@ module Qcmd
       connect exit quit workspace workspaces disconnect help
     ]
 
-    ReservedWorkspaceWords = Qcmd::Commands::ALL_WORKSPACE_COMMANDS
+    ReservedWorkspaceWords = Qcmd::Commands::WORKSPACE
 
-    ReservedCueWords = Qcmd::Commands::ALL_CUE_COMMANDS
+    ReservedCueWords = Qcmd::Commands::ALL_CUES
+
+    def self.add_commands commands
+      ReservedWords.push(*commands)
+      ReservedWords.uniq!
+    end
+
+    def self.add_command command
+      add_commands([command])
+    end
 
     CompletionProc = Proc.new {|input|
       # puts "input: #{ input }"
@@ -40,6 +49,7 @@ module Qcmd
         quoted_names = machine_names.map {|mn| %["#{mn}"]}
         names = (quoted_names + machine_names).grep(matcher)
         names = quote_if_necessary(names)
+
         # unquote
         commands = commands + names
       end

data/lib/qcmd/network.rb

@@ -1,6 +1,7 @@
 require 'dnssd'
 
 module Qcmd
+  # Browse the LAN and find open and running QLab instances.
   class Network
     BROWSE_TIMEOUT = 2
 
@@ -10,8 +11,9 @@ module Qcmd
       # browse can be used alone to populate the machines list
       def browse
         self.machines = []
+
         self.browse_thread = Thread.start do
-          DNSSD.browse! '_qlab._udp' do |b|
+          DNSSD.browse! '_qlab._tcp.' do |b|
             DNSSD.resolve b.name, b.type, b.domain do |r|
               self.machines << Qcmd::Machine.new(b.name, r.target, r.port)
             end
@@ -39,7 +41,7 @@ module Qcmd
         end
 
         Qcmd.print
-        Qcmd.print 'type `connect MACHINE` to connect to a machine'
+        Qcmd.print 'Type `connect MACHINE` to connect to a machine'
         Qcmd.print
       end
 
@@ -51,7 +53,11 @@ module Qcmd
       end
 
       def find machine_name
-        machines.find {|m| m.name == machine_name}
+        machines.find {|m| m.name.to_s == machine_name.to_s}
+      end
+
+      def find_by_index idx
+        machines[idx] if idx < machines.size
       end
 
       def names