qcmd 0.1.7 → 0.1.8

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

@@ -1,84 +0,0 @@
-module OSC
-  class StoppingServer < Server
-    def initialize *args
-      @state = :initialized
-      @port  = args.first
-      super(*args)
-    end
-
-    def run
-      @state = :starting
-      super
-    end
-
-    def stop
-      @state = :stopping
-      stop_detector
-      stop_dispatcher
-    end
-
-    def state
-      @state
-    end
-
-  private
-
-    def stop_detector
-      # send listening port a "CLOSE" signal on the open UDP port
-      _closer = UDPSocket.new
-      _closer.connect('', @port)
-      _closer.puts "CLOSE-#{@port}"
-      _closer.close unless _closer.closed? || !_closer.respond_to?(:close)
-    end
-
-    def stop_dispatcher
-      @queue << :stop
-    end
-
-    def dispatcher
-      loop do
-        mesg = @queue.pop
-        dispatch_message( mesg )
-      end
-    rescue StopException
-      @state = :stopped
-    end
-
-    def dispatch_message message
-      if message.is_a?(Symbol) && message.to_s == 'stop'
-        raise StopException.new
-      end
-
-      super(message)
-    end
-
-    def detector
-      @state = :listening
-
-      loop do
-        osc_data, network = @socket.recvfrom( 16384 )
-
-        # quit if socket receives the close signal
-        if osc_data == "CLOSE-#{@port}"
-          @socket.close if !@socket.closed? && @socket.respond_to?(:close)
-          break
-        end
-
-        unpack_socket_receipt osc_data, network
-      end
-    end
-
-    def unpack_socket_receipt osc_data, network
-      ip_info = Array.new
-      ip_info << network[1]
-      ip_info.concat(network[2].split('.'))
-      OSC::OSCPacket.messages_from_network( osc_data, ip_info ).each do |message|
-        @queue.push(message)
-      end
-    rescue EOFError
-      # pass
-    end
-  end
-
-  class StopException < Exception; end
-end

data/lib/qcmd/server.rb

@@ -1,175 +0,0 @@
-require 'osc-ruby'
-
-require 'json'
-
-module Qcmd
-  class TimeoutError < Exception; end
-
-  class Server
-    attr_accessor :receive_channel, :receive_thread, :receive_port, :send_channel, :machine
-
-    def initialize *args
-      options = args.extract_options!
-
-      self.receive_port = options[:receive]
-      connect_to_client
-
-      @handler = Qcmd::Handler.new
-      @sent_messages = []
-      @sent_messages_expecting_reply = []
-      @received_messages = []
-    end
-
-    def connect_to_client
-      self.machine = Qcmd.context.machine
-      self.send_channel = OSC::Client.new machine.address, machine.port
-
-      Qcmd.debug '(setting up listening connection)'
-      listen
-    end
-
-    def generic_responding_proc
-      proc do |osc_message|
-        @received_messages << osc_message
-
-        begin
-          Qcmd.debug "(received message: #{ osc_message.address })"
-          reply_received QLab::Reply.new(osc_message)
-        rescue => ex
-          Qcmd.debug "(ERROR #{ ex.message })"
-        end
-      end
-    end
-
-    # initialize
-    def listen
-      if receive_channel
-        stop
-      end
-
-      self.receive_channel = OSC::StoppingServer.new(self.receive_port)
-
-      Qcmd.debug "(opening receiving channel: #{ self.receive_channel.inspect })"
-
-      receive_channel.add_method %r{/reply/?(.*)}, &generic_responding_proc
-    end
-
-    def replies_expected?
-      @sent_messages_expecting_reply.size > 0
-    end
-
-    def reply_received reply
-      Qcmd.debug "(receiving #{ reply })"
-
-      # update world state
-      begin
-        @handler.handle reply
-      rescue => ex
-        print "(ERROR: #{ ex.message })"
-      end
-
-      # FIFO
-      @sent_messages_expecting_reply.shift
-
-      Qcmd.debug "(#{ @sent_messages_expecting_reply.size } messages awaiting reply)"
-    end
-
-    def wait_for_replies
-      begin
-        yield
-
-        naps = 0
-        while replies_expected? do
-          if naps > 20
-            # FAILED TO GET RESPONSE
-            raise TimeoutError.new
-          end
-
-          naps += 1
-          sleep 0.1
-        end
-      rescue TimeoutError => ex
-        Qcmd.log "[error: reply timeout]"
-        # clear expecting reply item, assume it will never arrive
-        @sent_messages_expecting_reply.shift
-      end
-    end
-
-    def send_command command, *args
-      options = args.extract_options!
-
-      Qcmd.debug "(building command from command, args, options: #{ command.inspect }, #{ args.inspect }, #{ options.inspect })"
-
-      # make sure command is valid OSC Address
-      if %r[^/] =~ command
-        address = command
-      else
-        address = "/#{ command }"
-      end
-
-      osc_message = OSC::Message.new address, *args
-
-      send_message osc_message
-    end
-
-    def send_message osc_message
-      Qcmd.debug "(sending osc message #{ osc_message.address } #{osc_message.has_arguments? ? 'with' : 'without'} args)"
-
-      @sent_messages << osc_message
-      if Qcmd::Commands.expects_reply?(osc_message)
-        Qcmd.debug "(this command expects a reply)"
-        @sent_messages_expecting_reply << osc_message
-      end
-
-      wait_for_replies do
-        send_channel.send osc_message
-      end
-    end
-
-    def stop
-      receive_channel.stop if receive_channel && receive_channel.state == :listening
-    end
-
-    def run
-      Qcmd.debug '(starting server)'
-      self.receive_thread = Thread.new do
-        Qcmd.debug '(server is up)'
-        receive_channel.run
-      end
-    end
-    alias :start :run
-
-    def send_workspace_command _command, *args
-      command = "workspace/#{ Qcmd.context.workspace.id }/#{ _command }"
-      send_command(command, *args)
-    end
-
-    def send_cue_command number, action, *args
-      command = "cue/#{ number }/#{ action }"
-      send_workspace_command(command, *args)
-    end
-
-    ## QLab commands
-
-    def load_workspaces
-      send_command 'workspaces'
-    end
-
-    def load_cues
-      send_workspace_command 'cueLists'
-    end
-
-    def connect_to_workspace workspace
-      if workspace.passcode?
-        send_command "workspace/#{workspace.id}/connect", "%04i" % workspace.passcode
-      else
-        send_command "workspace/#{workspace.id}/connect"
-      end
-
-      # if it worked, load cues automatically
-      if Qcmd.context.workspace
-        load_cues
-      end
-    end
-  end
-end

data/spec/unit/osc_server_spec.rb

@@ -1,78 +0,0 @@
-require File.join( File.dirname(__FILE__) , '..', 'spec_helper' )
-require 'qcmd'
-require 'socket'
-
-class PortFactory
-  @@counter = 12345
-
-  def self.new_port
-    @@counter += 1
-    @@counter
-  end
-end
-
-describe OSC::StoppingServer do
-  before :each do
-    @port = PortFactory.new_port
-  end
-
-  it "should bind to a socket when initialized" do
-    UDPSocket.any_instance.should_receive(:bind).with('', @port)
-    server = OSC::StoppingServer.new @port
-  end
-
-  it 'should start a listening thread when started' do
-    server = OSC::StoppingServer.new @port
-
-    test_thread = Thread.new do
-      Thread.should_receive :fork
-      server.run
-    end
-
-    server.stop
-  end
-
-  it 'should kill the listening thread and close socket when stopped' do
-    server = OSC::StoppingServer.new @port
-
-    test_thread = Thread.new do
-      server.run
-    end
-
-    sleep 0.1
-    server.stop
-    sleep 0.1
-
-    # server has stopped blocking
-    test_thread.alive?.should == false
-
-    # server claims it is closed
-    server.state.should == :stopped
-  end
-
-  it 'should create messages for legitimate OSC commands' do
-    server = OSC::StoppingServer.new @port
-
-    received = nil
-
-    server.add_method '/test' do |message|
-      received = message
-    end
-
-    test_thread = Thread.new do
-      server.run
-    end
-
-    received.should == nil
-
-    client = OSC::Client.new 'localhost', @port
-    client.send OSC::Message.new('/test', 'ansible')
-
-    sleep 0.1
-    server.stop
-
-    received.is_a?(OSC::Message).should == true
-    received.to_a.first.should == 'ansible'
-  end
-end
-