qcmd 0.1.7 → 0.1.8

data/sample/dnssd.rb

@@ -9,7 +9,7 @@ def row label, record
   puts "%-12s%s" % [label, record.send(label)]
 end
 
-browser = DNSSD.browse '_qlab._udp' do |b|
+def do_browse_on_service(b)
   DNSSD.resolve b.name, b.type, b.domain do |r|
     puts '*' * 40
     puts "FOUND QLAB:"
@@ -30,7 +30,24 @@ browser = DNSSD.browse '_qlab._udp' do |b|
   end
 end
 
-trap 'INT' do browser.stop; exit end
-trap 'TERM' do browser.stop; exit end
+browsers = []
+
+#browsers.push(DNSSD.browse('_qlab._udp.') do |b|
+#  do_browse_on_service(b)
+#end)
+
+browsers.push(DNSSD.browse('_qlab._tcp.') do |b|
+  do_browse_on_service(b)
+end)
+
+trap 'INT' do
+  browsers.map(&:stop);
+  exit
+end
+
+trap 'TERM' do
+  browsers.map(&:stop);
+  exit
+end
 
 sleep

data/sample/simple_console.rb

@@ -6,14 +6,12 @@ require 'readline'
 require 'rubygems'
 
 # use Qcmd's parser for type conversions and double quote recognizing
-require 'qcmd/parser'
+require 'qcmd'
 
 # other gems
 require 'osc-ruby'
 require 'json'
-
-# handle Ctrl-C quitting
-trap("INT") { exit }
+require 'trollop'
 
 # if there are args, there must be two:
 #
@@ -23,11 +21,27 @@ trap("INT") { exit }
 #
 #   receive_port
 
-# default qlab send port 53000
+VERSION_STRING =  "qcmd simple console #{ Qcmd::VERSION } (c) 2012 Figure 53, Baltimore, MD."
+
+opts = Trollop::options do
+  version VERSION_STRING
+  opt :debug, "Show full debug output", :default => false
+end
+
+if opts[:debug]
+  Qcmd.log_level = :debug
+  Qcmd.debug_mode = true
+end
+
+Qcmd.print VERSION_STRING
+Qcmd.print
+
+# default qlab send to localhost:53000
 send_address = 'localhost'
-send_port    = 53000
+send_port = 53000
 
-# default qlab receive port 53001
+# default qlab receive port 53001. This is how QLab will send response
+# messages.
 receive_port = 53001
 
 if ARGV.size > 0
@@ -39,38 +53,122 @@ if ARGV.size > 0
   elsif recv_matcher =~ ARGV[0]
     receive_port = $1
   else
-    puts 'send address must be an address in the form SERVER_ADDRESS:PORT'
+    Qcmd.print 'Send address must be an address in the form SERVER_ADDRESS:PORT'
+    Qcmd.print
   end
 
   if ARGV[1]
     if recv_matcher =~ ARGV[1]
       receive_port = $1
     else
-      puts 'send address must be a port number'
+      Qcmd.print 'Send address must be a port number'
     end
   end
 end
 
-puts %[connecting to server #{send_address}:#{send_port} with receiver at port #{receive_port}]
+Qcmd.print %[connecting to server #{send_address}:#{send_port} with receiver at port #{receive_port}]
 
 # how long to wait for responses from QLab. If you notice responses coming in
 # out of order, you may need to increase this value.
 REPLY_TIMEOUT = 1
 
-# open IO pipes to communicate between client / server process
-response_receiver, writer = IO.pipe
+# IO pipes to communicate between client / server process. In this case,
+# the process talking to QLab is the client, which receives QLab's responses
+# via the response_receiver.
+response_receiver, response_writer = IO.pipe
+
+class ClientReceiver
+  attr_accessor :state, :channel
+
+  def initialize channel, state
+    @channel = channel
+    @state   = state
+  end
+
+  def wait
+    # wait for response until TIMEOUT seconds
+    select = IO.select([channel], [], [], REPLY_TIMEOUT)
+    if !select.nil?
+      rs = select[0]
+
+      # get readable channel
+      if in_channel = rs[0]
+        data = []
+
+        # read everything until end of stream
+        while line = in_channel.gets
+          if line.strip != '<<EOS>>'
+            data << line
+          else
+            break
+          end
+        end
+
+        new_state = data.join
+        Qcmd.debug "[response_receiver] new_state #{ new_state.inspect }"
+
+        new_state_obj = Marshal::load(new_state)
+        Qcmd.debug "[response_receiver] got state: #{ new_state_obj.inspect }"
+
+        if new_state_obj[:state]
+          self.state.merge! new_state_obj[:state]
+        end
+
+        if new_state_obj[:message]
+          Qcmd.print new_state_obj[:message]
+        end
+      end
+    else
+      Qcmd.debug '[response_receiver] timed out'
+
+      # select timed out, probably not going to get a response,
+      # go back to command line mode
+    end
+  end
+end
 
 # fork readline process to allow server to communicate because if we use
 # Thread.new, readline locks the WHOLE Ruby VM and the server can't start
 pid = fork do
+  # handle Ctrl-C quitting
+  trap("INT") { exit }
+
   # close the IO channel that server process will be using
-  writer.close
+  response_writer.close
 
   # native OSC connection, outbound
   client = OSC::Client.new 'localhost', send_port
 
+  command_state = {}
+  receiver = ClientReceiver.new response_receiver, command_state
+
+  # load list of workspaces
+  client.send OSC::Message.new('/workspaces')
+  receiver.wait
+
+  # connect to frontmost workspace
+  client.send OSC::Message.new('/connect')
+  receiver.wait
+
   loop do
-    command_string = Readline.readline('> ', true)
+    # command prompt
+    pre_prompt = nil
+    prompt = "> "
+    if command_state[:workspace_id]
+      if command_state[:workspaces]
+        name = command_state[:workspaces].fetch(command_state[:workspace_id], {}).fetch('displayName', nil)
+      else
+        name = command_state[:workspace_id]
+      end
+
+      if !name.nil?
+        pre_prompt = "[#{ name }]"
+      end
+    end
+
+    Qcmd.print(pre_prompt) if !pre_prompt.nil?
+    command_string = Readline.readline(prompt, true)
+
     next if command_string.nil? || command_string.strip.size == 0
 
     # break command string up and properly typecast all given values
@@ -78,10 +176,16 @@ pid = fork do
     address = args.shift
 
     # quit, q, and exit all quit
-    exit if /^(q(uit)?|exit)/i =~ address
+    exit if /^(q(uit)?|exit) ?$/i =~ address
+
+    case address
+    when 'state'
+      Qcmd.print JSON.pretty_generate(command_state)
+      next
+    end
 
     # "sanitize" the given address
-    if %r[^/] != address
+    if %r[^/] !~ address
       if address == '>'
         # pasted previous command line entry
         address = args.shift
@@ -93,31 +197,12 @@ pid = fork do
 
     message = OSC::Message.new(address, *args)
     client.send message
+    receiver.wait
 
-    # wait for response until TIMEOUT seconds
-    select = IO.select([response_receiver], [], [], REPLY_TIMEOUT)
-    if !select.nil?
-      rs = select[0]
-
-      # get readable channel
-      if in_channel = rs[0]
-        # read everything until end of stream
-        while line = in_channel.gets
-          if line.strip != '<<EOS>>'
-            puts line
-          else
-            break
-          end
-        end
-      end
-    else
-      # select timed out, probably not going to get a response,
-      # go back to command line mode
-    end
   end
 end
 
-puts "launched console with process id #{ pid }, use Ctrl-c or 'exit' to quit"
+Qcmd.print "launched console with process id #{ pid }, use Ctrl-c or 'exit' to quit"
 
 # close unused pipe
 response_receiver.close
@@ -125,18 +210,71 @@ response_receiver.close
 # native OSC connection, inbound
 server = OSC::Server.new receive_port
 
-# server listens and forwards responses to the forked process
+response_handlers = [
+  [
+    %r{^/workspaces$},
+    Proc.new { |data, message, response|
+      workspaces = {}
+
+      data.each {|ws|
+        workspaces[ws['uniqueID']] = ws
+      }
+
+      data_out = Marshal::dump({
+        :message => "#{workspaces.size} workspaces available: #{workspaces.values.map {|ws| ws['displayName']}.join(', ')}",
+        :state => {:workspaces => workspaces}
+      })
+
+      Qcmd.debug "[/connect responder] sending marshalled object: #{ data_out.inspect }"
+
+      response.puts data_out
+    }
+  ],
+  [
+    %r{^/workspace/.+/connect$},
+    Proc.new { |data, message, response|
+      if data == 'ok'
+        data = Marshal::dump({:message => 'ok', :state => {:workspace_id => message['workspace_id']}})
+      else
+        data = Marshal::dump({:message => 'connection failed', :state => {:workspace_id => nil}})
+      end
+
+      Qcmd.debug "[/connect responder] sending marshalled object: #{ data.inspect }"
+      response.puts data
+    }
+  ]
+]
+
+# server listens and forwards responses to the console process
 server.add_method %r[/reply] do |osc_message|
-  data = JSON.parse(osc_message.to_a.first)['data']
+  response = JSON.parse(osc_message.to_a.first)
+  address  = response['address']
+  data     = response['data']
+
+  responded = false
+  response_handlers.each do |(match, action)|
+    if match =~ address
+      action.call data, response, response_writer
+      responded = true
+    end
+  end
 
   begin
-    writer.puts JSON.pretty_generate(data)
+    if !responded
+      data = Marshal::dump({:message => JSON.pretty_generate(data)})
+    end
   rescue JSON::GeneratorError
-    writer.puts data.to_s
+    data = Marshal::dump({:message => data.to_s})
+  end
+
+  if !responded
+    Qcmd.debug  "[server] sending marshalled object: #{ data.inspect }"
+    response_writer.puts data
   end
 
   # end of signal
-  writer.puts '<<EOS>>'
+  Qcmd.debug "[server] sending <<EOS>>"
+  response_writer.puts '<<EOS>>'
 end
 
 # start blocking server
@@ -145,4 +283,9 @@ Thread.new do
 end
 
 # chill until the command line process quits
-Process.wait pid
+begin
+  Process.wait pid
+rescue Interrupt
+  # ignore
+  exit
+end

data/sample/tcp_qlab_connection.rb

@@ -0,0 +1,67 @@
+require 'qcmd'
+
+require 'rubygems'
+require 'json'
+
+# try it out
+
+qlab = OSC::TCPClient.new 'localhost', 53000
+
+def receive(rcv)
+  if rcv
+    rcv.each do |osc_message|
+      begin
+        response = JSON.parse(osc_message.to_a.first)
+
+        address  = response['address']
+        data     = response['data']
+        status   = response['status']
+
+        puts address
+
+        if status
+          puts "status -> #{ status }"
+        end
+
+        if data
+          puts JSON.pretty_generate(data)
+        end
+      rescue => ex
+        puts "parsing response failed: #{ ex.message }"
+      end
+    end
+  else
+    puts 'no response...'
+  end
+end
+
+msg  = OSC::Message.new '/workspaces'
+qlab.send(msg) do |response|
+  receive(response)
+end
+
+# don't always expect a reply
+msg = OSC::Message.new '/alwaysReply', 0
+qlab.send(msg) do |response|
+  receive(response)
+end
+
+# non-responsive command
+msg  = OSC::Message.new '/workspace/65E9D86D-87DD-4CB1-A659-6584BAE57AB2/go'
+qlab.send(msg) do |response|
+  receive(response)
+end
+
+# always expect a reply
+msg = OSC::Message.new '/alwaysReply', 1
+qlab.send(msg) do |response|
+  receive(response)
+end
+
+# non-responsive command is now a responsive command
+msg  = OSC::Message.new '/workspace/65E9D86D-87DD-4CB1-A659-6584BAE57AB2/go'
+qlab.send(msg) do |response|
+  receive(response)
+end
+
+

data/spec/unit/action_spec.rb

@@ -0,0 +1,84 @@
+require 'qcmd'
+
+def test_log msg=''
+  puts msg
+end
+
+class DeadHandler
+  def self.handle response
+    # do nothing :P
+  end
+end
+
+describe Qcmd::Action do
+  before do
+    Qcmd.context = Qcmd::Context.new
+    Qcmd.context.machine = Qcmd::Machine.new('test machine', 'localhost', 53000)
+    Qcmd.context.connect_to_qlab DeadHandler
+
+    # always reply ON
+    Qcmd.context.qlab.send(OSC::Message.new('/alwaysReply', 1))
+  end
+
+  it "should call `parse` when initialized" do
+    Qcmd::Action.any_instance.stub(:parse) { true }
+    Qcmd::Action.any_instance.should_receive(:parse)
+    Qcmd::Action.new [:cue, 10, :name]
+  end
+
+  it 'should send a command when evaluated' do
+    action = Qcmd::Action.new 'workspaces'
+
+    action.stub(:send_message) { true }
+    action.should_receive :send_message
+
+    action.evaluate
+  end
+
+  it 'should return the data resulting from an OSC message' do
+    action = Qcmd::Action.new 'cueLists'
+
+    result = nil
+
+    expect {
+      result = action.evaluate
+    }.to_not raise_error
+
+    result.should_not be_nil
+    result.should be_an_instance_of(Array)
+  end
+
+  describe 'workspace specific action' do
+    before do
+      osc_message = OSC::Message.new '/workspaces'
+      Qcmd.context.qlab.send(osc_message) do |response|
+        reply = Qcmd::QLab::Reply.new(response)
+        Qcmd.context.machine.workspaces = reply.data.map {|ws| Qcmd::QLab::Workspace.new(ws)}
+      end
+    end
+
+    it 'should be able to connect' do
+      workspace = Qcmd.context.machine.workspaces.first
+
+      ws_action_string = "workspace/#{workspace.id}/connect"
+
+      reply = Qcmd::Action.evaluate(ws_action_string)
+
+      reply.should eql('ok')
+    end
+  end
+
+  describe 'cue specific action' do
+    it 'should send a cue OSC message' do
+      action = Qcmd::CueAction.new 'cue 1 isRunning'
+      action.send(:osc_address).should eql('/cue/1/isRunning')
+      action.send(:osc_arguments).should eql([])
+    end
+
+    it 'should nest actions' do
+      action = Qcmd::CueAction.new 'cue 1 name (cue 2 name)'
+      action.code[3].should be_an_instance_of(Qcmd::CueAction)
+    end
+  end
+
+end