bernstein 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28bd90208deb3660afce5ecadda52636d9c31e8c
+  data.tar.gz: e84c2e6717ed39563921b813f676e678b91e79f5
+SHA512:
+  metadata.gz: 1c5605a448740f7e0940175e9c72ada85f6f6ea36e6d1c24fb53982cca179e8de9891cea93ed71da27294e12058eb022f3d8fdccc9dc2f66b25ae0c5236d97f9
+  data.tar.gz: 1e52a953484c378fc81638411255d5a6b1a4896995658639af604d9450ea770ee7a104c1581302126befaf76be1676d2c9880cd74e9697a8163f59213bf5a510

data/.gitignore

@@ -0,0 +1,5 @@
+*.*~
+*.swp
+*~
+*.rdb
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+gem 'ruby-osc'
+gem 'eventmachine'
+gem 'redis'
+gem 'redis-namespace'
+gem 'json'
+gem 'daemons'

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Anthony Plekhov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# Bernstein
+
+Bernstein is a simple Ruby message queue for [OSC](http://en.wikipedia.org/wiki/Open_Sound_Control) messages 
+that gives Ruby the ability to asynchronously send messages to OSC-enabled software and hardware.
+It is built on top of the [ruby-osc](https://github.com/maca/ruby-osc) libray and currently uses Redis to 
+queue the messages. Bernstein provides support for float,integer and string datatypes.  In addition, it offers an
+awk-mode that a client can use to be notified that an OSC message was delivered and awknowledged.
+
+## Why is it useful?
+
+While typical OSC communication is 1:1 between a client and an OSC consumer, Bernstein allows for many clients
+to control an OSC device or process.  For example, there could be a web interface adapting requests from
+many users and sending them as OSC messages to a sound generator in an installation or performance. 
+See [here](https://github.com/aplekhov/bernstein-web). 
+Due to the queuing there is an inherent latency, however that might be neglible in certain situations.
+
+
+## Basic Usage
+
+    gem install bernstein
+
+Make sure that Redis is running. Start the background poller daemon:
+    
+    bernstein start -- -c bernstein.yml
+
+```ruby
+require 'bernstein'
+
+# see sample yml file for options
+Bernstein.configure_from_yaml!('bernstein.yml')
+
+# send a message string, all parameters will be converted to floats
+msg_id = Bernstein::Client.send_message_by_string "/synths/4/filter_cutoff 0.5"
+
+# send a message with specific types
+msg_id = Bernstein::Client.send_message '/synth/params', 'sinewave', 440, 556.3, 334.0
+
+# get status ('queued','sending','sent')
+Bernstein::Client.message_status(msg_id)
+```
+
+Stop the background poller like this:
+
+    bernstein stop
+
+## Default Configuration
+See bernstein.sample.yml.
+Note: if no redis options are passed, then the redis connection defaults will be used.
+
+## Awk mode
+By default, bernstein has awk mode enabled which means that it will send an internal message id along with every
+message and expect the OSC receiver to respond back with an OSC 'awk' that contains the same message id.  For many software
+OSC implementations this is pretty easy to setup, however it is not likely to work with hardware.  Make sure to disable it 
+using the `require_awks` config key.
+
+## License
+The MIT License.  Copyright (c) 2014 Anthony Plekhov. See LICENSE.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc 'Generate documentation for plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Timeliness'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Default: run specs.'
+task :default => :spec

data/bernstein.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/bernstein/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Anthony Plekhov"]
+  gem.email         = ["anthony.plekhov@gmail.com"]
+  gem.description   = gem.summary = "Ruby OSC message queue"
+  gem.license       = "MIT"
+  gem.executables   = ['bernstein']
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- spec/*`.split("\n")
+  gem.name          = "bernstein"
+  gem.require_paths = ["lib"]
+  gem.version       = Bernstein::VERSION
+  gem.add_dependency                  'redis', '>= 3.1.0'
+  gem.add_dependency                  'redis-namespace', '>= 1.5.1'
+  gem.add_dependency                  'eventmachine', '>= 1.0.3'
+  gem.add_dependency                  'json', '>= 1.8.1'
+  gem.add_dependency                  'daemons', '>= 1.1.9'
+  gem.add_dependency                  'ruby-osc', '>= 0.31.0'
+  gem.add_development_dependency      'rspec', '>= 3.1.0'
+end

data/bernstein.sample.yml

@@ -0,0 +1,14 @@
+# osc config for where osc messages need to be delivered
+:osc_client:
+  :port: 9090
+  :host: '127.0.0.1'
+# osc config that bernstein listens on for awk OSC messages
+:osc_server:
+  :port: 9000
+  :host: '127.0.0.1'
+  :require_awks: true
+# redis config, accepts all Redis gem options
+:redis_queue:
+  :key_expiry: 300
+  :host: '127.0.0.1'
+  :port: 6379

data/bin/bernstein

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'bernstein'
+require 'daemons'
+
+#options = {
+#  :backtrace  => true,
+#  :ontop      => true,
+#  :log_output => true,
+#}
+
+working_directory = Dir.pwd
+config_opt_index = ARGV.find_index('-c')
+if ARGV[0] == "start" && config_opt_index.nil?
+  puts "Usage: bundle exec bernstein [start|stop|restart] -- -c <bernstein yaml file>"
+  exit
+else
+  init_proc = Proc.new do
+    Bernstein.configure_from_yaml!(File.join( working_directory, ARGV[config_opt_index + 1]))
+  end
+end
+
+Daemons.run_proc('bernstein') do
+  init_proc.call
+  Bernstein::Server.start
+end

data/lib/bernstein/client.rb

@@ -0,0 +1,34 @@
+module Bernstein
+  class Client
+    ##
+    # Example: Bernstein::Client.send_message("/synths/4/filter_cutoff .5")
+    # note: only accepts float arguments
+    #
+    def self.send_message_by_string(message_string)
+      msg = Message.build_from_string(message_string)
+      save_and_return_id(msg)
+    end
+
+    ##
+    # Example: Bernstein::Client.send_message("/synths/frequencies", 440, 556.3 334.0")
+    # note: only accepts float arguments
+    #
+    def self.send_message(address = '/', *args)
+      msg = Message.build(address, *args)
+      save_and_return_id(msg)
+    end
+
+    ##
+    # Example: Bernstein::Client.message_status("34246456458856")
+    #
+    def self.message_status(message_id)
+      Message.get_status(message_id)
+    end
+
+    private
+    def self.save_and_return_id(msg)
+      msg.save!
+      msg.id
+    end
+  end
+end

data/lib/bernstein/message.rb

@@ -0,0 +1,78 @@
+require 'ruby-osc'
+require 'json'
+
+module Bernstein
+  class Message
+    attr_reader :id, :osc_message
+    @@persister = RedisQueue
+    @@osc_connection = OSCConnection
+
+    def initialize(osc_message, id = nil)
+      @osc_message = osc_message
+      @id = id || new_id
+      @is_saved = false
+    end
+
+    def self.build(address = '', *args)
+      Message.new(OSC::Message.new(address, *args))
+    end
+
+    # only supports float arguments
+    def self.build_from_string(message_string)
+      address, args = parse_message_string(message_string)
+      Message.new(OSC::Message.new(address, *args))
+    end
+
+    def self.deserialize(serialized_msg)
+      data = JSON.parse(serialized_msg)
+      Message.new OSC::Message.new(data['address'], *data['args']), data['id']
+    end
+
+    def serialize
+      {'id' => @id, 'address' => @osc_message.address, 'args' => @osc_message.args}.to_json
+    end
+
+    def self.get_status(id)
+      @@persister.status(id)
+    end
+
+    def status
+      @@persister.status(@id)
+    end
+
+    def self.get_queued_messages
+      @@persister.queued_messages
+    end
+
+    def self.set_as_sent!(id)
+      @@persister.mark_as_sent(id)
+    end
+
+    def save!
+      unless @is_saved
+        @@persister.add(self)
+        @is_saved = true
+      end
+    end
+
+    def send!(expect_awk = true)
+      @@osc_connection.send_message self, expect_awk
+      @@persister.dequeue @id, !expect_awk
+    end
+
+    def ==(other)
+      (self.class == other.class) && (self.osc_message == other.osc_message) &&
+        (self.id == other.id)
+    end
+    
+    protected
+    def new_id
+      Time.now.to_f.to_s.delete('.')
+    end
+
+    def self.parse_message_string message_string
+      message_array = message_string.split
+      [message_array.shift, message_array.map{|arg| arg.to_f}]
+    end
+  end
+end

data/lib/bernstein/osc_connection.rb

@@ -0,0 +1,20 @@
+require 'ruby-osc'
+
+module Bernstein
+  class OSCConnection
+    include OSC
+  
+    @options = {port: 8000, host: '127.0.0.1'}
+    
+    def self.configure!(options = {})
+      @options.merge!(options || {})
+      @connection = OSC::Client.new @options[:port], @options[:host]
+    end
+
+    def self.send_message(message, with_message_id = true)
+      osc_message = message.osc_message
+      osc_message = OSC::Bundle.new(nil, osc_message, OSC::Message.new('/message_id', message.id)) if with_message_id
+      @connection.send osc_message
+    end
+  end
+end

data/lib/bernstein/redis_queue.rb

@@ -0,0 +1,86 @@
+require 'redis'
+require 'redis-namespace'
+
+module Bernstein
+  class RedisQueue
+    include States
+
+    QUEUE_SET = "queued_messages"
+    @options = {key_expiry: 300, redis: {}}
+
+    def self.configure!(options = {})
+      @options.merge!(options || {})
+      @redis = Redis::Namespace.new(:bernstein, :redis => Redis.new(@options[:redis]))
+    end
+
+    def self.add(message)
+      @redis.multi do
+        @redis.sadd QUEUE_SET, message.id
+        @redis.setex message.id, @options[:key_expiry], message.serialize
+        @redis.setex status_key(message.id), @options[:key_expiry], STATES[:queued]
+      end
+    end
+
+    def self.status(id)
+      @redis.get(status_key(id)) || STATES[:not_yet_queued]
+    end
+
+    def self.queued_messages
+      queued_message_ids = @redis.smembers QUEUE_SET
+      messages = []
+      unless queued_message_ids.empty?
+        messages = @redis.mget(queued_message_ids).compact
+        unless messages.empty?
+          messages.map!{|m| Message.deserialize(m)} 
+        end
+        if messages.size < queued_message_ids.size
+          clean_up_queue(queued_message_ids - messages.map{|m| m.id})
+        end
+      end
+      messages
+    end
+
+    def self.clear
+      @redis.del QUEUE_SET
+    end
+
+    def self.dequeue(id, mark_as_sent = false)
+      remove_and_change_status(id, (mark_as_sent ? STATES[:sent] : STATES[:sending]))
+    end
+
+    def self.mark_as_sent(id)
+      set_status(id, STATES[:sent])
+    end
+
+    private
+    def self.status_key(id)
+      "#{id}_status"
+    end
+
+    def self.remove_and_change_status(id, status)
+      remove(id){ set_status(id, status) }
+    end
+
+    def self.set_status(id, status)
+      @redis.setex status_key(id), @options[:key_expiry], status
+    end
+
+    def self.remove(id)
+      if block_given?
+        @redis.multi do
+          @redis.srem QUEUE_SET, id
+          yield
+        end
+      else
+        @redis.srem QUEUE_SET, id
+      end
+      @redis.del id
+    end
+
+    def self.clean_up_queue(ids_to_remove)
+      @redis.pipelined do
+        ids_to_remove.each{|id| @redis.srem QUEUE_SET, id}
+      end
+    end
+  end
+end

data/lib/bernstein/server.rb

@@ -0,0 +1,41 @@
+require 'eventmachine'
+require 'ruby-osc'
+
+module Bernstein
+  class Server
+    @options = {port: 9000, host: '127.0.0.1', require_awks: true, poll_interval: 5, awk_address: '/awk_id'}
+    def self.configure!(options = {})
+      @options.merge!(options || {})
+    end
+
+    def self.start
+      OSC.run do
+        @server = OSC::Server.new(@options[:port],@options[:host])
+        if @options[:require_awks] 
+          @server.add_pattern @options[:awk_address] do |*args|
+            handle_awknowledgement(args[1])
+          end
+        end
+
+        @timer = EventMachine::PeriodicTimer.new(@options[:poll_interval]) do 
+          process_queued_messages
+        end
+        yield if block_given?
+      end
+    end
+
+    def self.stop
+      @server.stop unless @server.nil?
+      @timer.cancel unless @timer.nil?
+    end
+
+    private
+      def self.process_queued_messages
+        Message.get_queued_messages.each{|m| m.send!(@options[:require_awks])}
+      end
+
+      def self.handle_awknowledgement(id)
+        Message.set_as_sent!(id)
+      end
+  end
+end

data/lib/bernstein/states.rb

@@ -0,0 +1,5 @@
+module Bernstein
+  module States
+    STATES = {not_yet_queued: 'not_yet_queued', queued: 'queued', sending: 'sending', sent: 'sent'}
+  end
+end

data/lib/bernstein/version.rb

@@ -0,0 +1,3 @@
+module Bernstein
+  VERSION = "0.0.1"
+end

data/lib/bernstein.rb

@@ -0,0 +1,20 @@
+require 'bernstein/states'
+require 'bernstein/redis_queue'
+require 'bernstein/osc_connection'
+require 'bernstein/message'
+require 'bernstein/client'
+require 'bernstein/server'
+require 'bernstein/version'
+require 'yaml'
+
+module Bernstein
+  def self.configure_from_yaml!(file_path)
+    configure!(YAML.load_file(file_path))
+  end
+
+  def self.configure!(options = {})
+    RedisQueue.configure!(options[:redis_queue])
+    OSCConnection.configure!(options[:osc_client])
+    Server.configure!(options[:osc_server])
+  end
+end

data/spec/bernstein/client_spec.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+describe Bernstein::Client do
+  subject { Bernstein::Client }
+
+  describe "sending a message" do
+    it "should build the message object and return its id" do
+      id = subject.send_message_by_string("/synths/4/chord/notes 25 30 10")
+      expect(id).to_not be_nil
+      queued_messages = Bernstein::Message.get_queued_messages
+      message = queued_messages.find{|m| m.id == id}
+      expect(message).to_not be_nil
+      expect(message.osc_message.address).to eq("/synths/4/chord/notes")
+      expect(message.osc_message.args).to eq([25.0, 30.0, 10.0])
+    end
+
+    it "should accept arguments to build the message" do
+      id = subject.send_message("/synths/4/parameters", 20, 34.2, 'squarewave')
+      expect(id).to_not be_nil
+      queued_messages = Bernstein::Message.get_queued_messages
+      message = queued_messages.find{|m| m.id == id}
+      expect(message).to_not be_nil
+      expect(message.osc_message.address).to eq("/synths/4/parameters")
+      expect(message.osc_message.args).to eq([20, 34.2, 'squarewave'])
+    end
+  end
+
+  describe "querying a message's status by id" do
+    it "should return the current status or not yet queued" do
+      id = subject.send_message("/synths/4/chord/notes 25 30 10")
+      expect_state(subject.message_status(id), :queued)
+      expect_state(subject.message_status('123'), :not_yet_queued)
+    end
+  end
+end

data/spec/bernstein/message_spec.rb

@@ -0,0 +1,221 @@
+require 'helper'
+require 'ruby-osc'
+
+class DummyPersister
+  attr_accessor :queue, :sent_messages, :message_states
+  def initialize
+    @queue, @sent_messages, @message_states = [],[], {}
+  end
+
+  def add(message)
+    @queue << message
+    @message_states[message] = :queued
+  end
+
+  def queued_messages
+    @queue
+  end
+
+  def dequeue(id, mark_as_sent = false)
+    message = @queue.find{|m| m.id == id}
+    if !message.nil?
+      @message_states[message] = (mark_as_sent ? :sent : :sending)
+      @sent_messages << message
+      @queue.delete(message)
+    end
+  end
+
+  def mark_as_sent(id)
+    message = @message_states.keys.find{|m| m.id == id}
+    @message_states[message] = :sent unless message.nil?
+  end
+
+  def status(id)
+    message = @message_states.keys.find{|m| m.id == id}
+    Bernstein::States::STATES[@message_states[message]]
+  end
+
+  def clear
+    @queue.clear
+    @sent_messages.clear
+    @message_states.clear
+  end
+end
+
+class DummyOSCConnection
+  attr_accessor :fail_send, :sent_messages, :sent_ids
+  def initialize
+    @fail_send, @sent_messages, @sent_ids = false, [], []
+  end
+
+  def send_message message, with_message_id = true
+    if @fail_send
+      throw "something went wrong"
+    else
+      @sent_messages << message
+      @sent_ids << message.id if with_message_id
+    end
+  end
+end
+
+describe Bernstein::Message do
+  subject { Bernstein::Message }
+
+  before(:all) do
+    @mock_queue = DummyPersister.new
+    @mock_osc_connection = DummyOSCConnection.new
+    @real_persister = Bernstein::Message.class_variable_get('@@persister')
+    @real_osc_connection = Bernstein::Message.class_variable_get('@@osc_connection')
+    Bernstein::Message.class_variable_set('@@persister', @mock_queue)
+    Bernstein::Message.class_variable_set('@@osc_connection', @mock_osc_connection)
+  end
+
+  after(:all) do
+    Bernstein::Message.class_variable_set('@@persister', @real_persister)
+    Bernstein::Message.class_variable_set('@@osc_connection', @real_osc_connection)
+  end
+
+  before(:each) do
+    @mock_queue.clear
+    @message = Bernstein::Message.build_from_string("/test 1 2 3")  
+  end
+
+  describe "building a new message" do
+    it "should be able to be built from a message string and turn all parameters into floats" do
+      address = "/test/this/out"
+      args = ['1', '2', '3.5']
+      message = subject.build_from_string("#{address} #{args.join(' ')}")
+      expect(message.osc_message.address).to eq(address)
+      expect(message.osc_message.args).to eq(args.map{|a| a.to_f})
+    end
+
+    it "should be able to built from address and args, preserving types" do
+      address = "/test/this/out"
+      args = [5, 'pizza', 9.9, 2.0]
+      message = subject.build(address,*args)
+      expect(message.osc_message.address).to eq(address)
+      expect(message.osc_message.args).to eq(args)
+    end
+
+    it "should be able to be built from an already built osc message" do
+      msg = OSC::Message.new('/hi/msg','2',4)
+      message1 = subject.new(msg)
+      expect(message1.osc_message).to eq(msg)
+    end
+
+    it "should return a unique id" do
+      messages = []
+      5.times {|i| messages << subject.build_from_string("/test #{i}")}
+      messages.each do |message| 
+        expect(message.id).to_not be_nil
+        (messages - [message]).each{|other_message| expect(other_message.id).to_not eq(message.id)}
+      end
+    end
+
+    it "should be able to be built with a set id" do
+      address = "/test/this/out"
+      args = ['1', '2', '3']
+      id = "456"
+      osc_msg = OSC::Message.new(address, *args)
+      message = subject.new osc_msg, id
+      expect(message.id).to eq(id)
+      expect(message.osc_message.address).to eq(address)
+      expect(message.osc_message.args).to eq(args)
+    end
+
+    it "should be equal to another message with the same id, args and address" do
+      message1 = subject.build_from_string("/test 1 2 3") 
+      message2 = subject.new(OSC::Message.new("/test", 1,2,3), message1.id)
+      message3 = subject.new(message2.osc_message, '999')
+      expect(message1).to eq(message2)
+      expect(message1).to_not eq(message3)
+    end
+  end
+
+  describe "serialization" do
+    it "should serialize and deserialize the osc message and id" do
+      @message = subject.build_from_string("/test 1 2 3.2345")  
+      serialized_msg = @message.serialize
+      expect(@message).to eq(subject.deserialize(serialized_msg))
+    end
+
+    it "should handle float, integer and string arguments" do
+      @message = subject.build("/test", 3.4567, 10, 'a_string')
+      serialized_msg = @message.serialize
+      expect(@message).to eq(subject.deserialize(serialized_msg))
+    end
+  end
+
+  describe "saving a message" do
+    it "should add message onto the queue upon save" do
+      @message.save!
+      expect(@mock_queue.queue).to include(@message)
+    end
+
+    it "should not be able to add the same message onto the queue again" do
+      @message.save!
+      expect{@message.save!}.to_not change(@mock_queue.queue, :size)
+    end
+  end
+
+  describe "sending a message" do
+    before(:each) do
+      @message.save!
+    end
+
+    after(:each) do
+      @mock_osc_connection.fail_send = false
+    end
+
+    it "should send the message and message id on the OSC connection and remove from queue" do
+      @message.send!
+      expect(@mock_osc_connection.sent_messages).to include(@message)
+      expect(@mock_osc_connection.sent_ids).to include(@message.id)
+      expect(@mock_queue.sent_messages).to include(@message)
+    end
+
+    it "should not mark the message as sent on the queue if there is an error" do
+      @mock_osc_connection.fail_send = true
+      @message.send rescue
+      expect(@mock_queue.sent_messages).to_not include(@message)
+      expect(@mock_osc_connection.sent_messages).to_not include(@message)
+      expect(@mock_osc_connection.sent_ids).to_not include(@message.id)
+    end
+
+    it "should send the message and mark as sent and not ask to send message id along" do
+      @message.send!(false)
+      expect_state(@message.status, :sent)
+      expect(@mock_osc_connection.sent_messages).to include(@message)
+      expect(@mock_osc_connection.sent_ids).to_not include(@message.id)
+    end
+  end
+
+  describe "querying status" do
+    before(:each) do
+      @message.save!
+    end
+
+    it "should return the current status for a message object" do
+      expect_state(@message.status, :queued)
+      @message.send!
+      expect_state(@message.status, :sending)
+      @mock_queue.mark_as_sent(@message.id)
+      expect_state(@message.status, :sent)
+    end
+
+    it "should return the current status by message id" do
+      expect_state(subject.get_status(@message.id), :queued)
+      @message.send!(false)
+      expect_state(subject.get_status(@message.id), :sent)
+    end
+  end
+
+  describe "getting queued messages" do
+    it "should return all queued messages" do
+      @message.save!
+      @message2 = subject.build_from_string("/test/2 4 5 6")
+      @message2.save!
+      expect(subject.get_queued_messages).to eq([@message, @message2])
+    end
+  end
+end

data/spec/bernstein/osc_connection_spec.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+def current_client
+  Bernstein::OSCConnection.instance_variable_get('@connection')
+end
+
+describe Bernstein::OSCConnection do
+  describe "configuring" do
+    it "should instantiate a new osc client based on the port and host that was given" do
+      expect(OSC::Client).to receive(:new).with(9000, '10.10.10.1')
+      Bernstein::OSCConnection.configure!({port: 9000, host: '10.10.10.1'})
+    end
+  end
+  
+  describe "sending a message" do
+    it "should create a new osc message from the passed in message and call send on the client" do
+      Bernstein::OSCConnection.configure!({port: 9000, host: '10.10.10.1'})
+      expect(OSC::Message).to receive(:new).with('/test', 1.0,2.0,3.0).and_return("mock")
+      message1 = Bernstein::Message.build_from_string("/test 1 2 3")
+      expect(current_client).to receive(:send).with("mock")
+      Bernstein::OSCConnection.send_message(message1, false)
+    end
+
+    it "should send a bundle when asked to send message id" do
+      Bernstein::OSCConnection.configure!({port: 9000, host: '10.10.10.1'})
+      message1 = Bernstein::Message.build_from_string("/test 1 2 3")
+      expect(current_client).to receive(:send).with(kind_of(OSC::Bundle))
+      Bernstein::OSCConnection.send_message(message1, true)
+    end
+  end
+end

data/spec/bernstein/redis_queue_spec.rb

@@ -0,0 +1,125 @@
+require 'helper'
+
+def redis_connection
+  Bernstein::RedisQueue.instance_variable_get('@redis')
+end
+
+def redis_queue
+  redis_connection.smembers(Bernstein::RedisQueue::QUEUE_SET)
+end
+
+describe Bernstein::RedisQueue do
+  subject { Bernstein::RedisQueue }
+
+  before(:each) do
+    @message = Bernstein::Message.build_from_string("/test/3 1 2.55 4")
+  end
+
+  describe "initialization and configuration" do
+    after(:all){Bernstein::RedisQueue.configure!({redis:{}})}
+
+    it "should pass redis options to initialize a new redis connection" do
+      redis_opts = {host: "10.0.1.1", port: 6380, db: 15}
+      expect(Redis).to receive(:new).with(redis_opts).and_call_original
+      Bernstein::RedisQueue.configure!({key_expiry: 600, redis: redis_opts})
+    end
+
+    it "should be namespaced" do
+      expect(redis_connection.class).to eq(Redis::Namespace)
+    end
+  end
+
+  describe "adding a new message" do
+    it "should serialize the message and add it to the proper sets" do
+      subject.add(@message)
+      data = redis_connection.get(@message.id)
+      expect(Bernstein::Message.deserialize(data)).to eq(@message)
+      expect(redis_queue).to include(@message.id)
+    end
+  end
+
+  describe "expired messages" do
+    before(:all) do
+      @key_expiry = 1
+      Bernstein::RedisQueue.configure! key_expiry: @key_expiry
+    end
+
+    after(:all) do
+      Bernstein::RedisQueue.configure! key_expiry: 300
+    end
+
+    it "should expire messages based on set expiry times" do
+      subject.add(@message)
+      expect_state(subject.status(@message.id), :queued)
+      expect(redis_connection.get(@message.id)).to_not be_nil
+      sleep @key_expiry + 1
+      expect(redis_connection.get(@message.id)).to be_nil
+      expect_state(subject.status(@message.id), :not_yet_queued)
+    end
+
+    it "should expire messages that have had their status changed" do
+      subject.add(@message)
+      subject.mark_as_sent(@message.id)
+      expect_state(subject.status(@message.id), :sent)
+      sleep @key_expiry + 1
+      expect_state(subject.status(@message.id), :not_yet_queued)
+    end
+
+    it "should clean up request_queue of unhandled expired messages" do
+      subject.add(@message)
+      expect(subject.queued_messages).to include(@message)
+      sleep @key_expiry + 1
+      @another_message = Bernstein::Message.build_from_string("/test/current 5 6 7")
+      subject.add(@another_message)
+      queued_messages = subject.queued_messages
+      queue_set = redis_queue
+      expect(queued_messages).to_not include(@message)
+      expect(queued_messages).to include(@another_message)
+      expect(queue_set).to_not include(@message.id)
+      expect(queue_set).to include(@another_message.id)
+    end
+  end
+
+  describe "marking and requesting status" do
+    it "should return not yet sent queued for unknown messages" do
+      expect_state(subject.status('123456'), :not_yet_queued)
+    end
+
+    it "should set new messages' status to queued" do
+      subject.add(@message)
+      expect_state(subject.status(@message.id), :queued)
+    end
+
+    it "should mark a message as sent" do
+      subject.add(@message)
+      subject.mark_as_sent(@message.id)
+      expect_state(subject.status(@message.id), :sent)
+    end
+
+    it "should dequeue messages and set them to sending state by default" do
+      subject.add(@message)
+      subject.dequeue(@message.id)
+      expect_state(subject.status(@message.id), :sending)
+      expect(redis_queue).to_not include(@message.id)
+    end
+
+    it "should dequeue messages and set their state straight to sent" do
+      subject.add(@message)
+      subject.dequeue(@message.id, true)
+      expect_state(subject.status(@message.id), :sent)
+      expect(redis_queue).to_not include(@message.id)
+    end
+  end
+  
+  describe "getting queued messages" do
+    it "should pull queued messages and deserialize them" do
+      subject.clear
+      message = Bernstein::Message.build_from_string("/test/1 1")
+      message2 = Bernstein::Message.build_from_string("/test/2 1 2")
+      message3 = Bernstein::Message.build_from_string("/test/3 1 2 3")
+      messages = [message, message2, message3]
+      messages.each{|m| subject.add(m)}
+      expect(subject.queued_messages.sort{|a,b| a.id <=> b.id}).to eq(messages.sort{|a,b| a.id <=> b.id})
+    end
+  end
+end

data/spec/bernstein/server_spec.rb

@@ -0,0 +1,91 @@
+require 'helper'
+require 'ruby-osc'
+require 'eventmachine'
+
+describe Bernstein::Server do
+  describe "initialization and configuration" do
+    it "should pass options to initialize a new OSC server" do
+      opts = {port: 9004, host: '127.0.0.1'}
+      expect(OSC::Server).to receive(:new).with(opts[:port], opts[:host]).and_call_original
+      Bernstein::Server.configure!(opts)
+      Bernstein::Server.start do
+        Bernstein::Server.stop
+        EventMachine.stop_event_loop 
+      end
+    end
+  end
+
+  describe "processing queued messages" do
+    before(:each) do
+      connection = Bernstein::Message.class_variable_get('@@osc_connection')
+      allow(connection).to receive(:send_message)
+      Bernstein::RedisQueue.clear
+      @message = Bernstein::Client.send_message_by_string("/test/1 1")
+      @message2 = Bernstein::Client.send_message_by_string("/test/2 1 2")
+      @message3 = Bernstein::Client.send_message_by_string("/test/3 1 2 3")
+      [@message, @message2, @message3].each do |message_id|
+        expect_state(Bernstein::Client.message_status(message_id), :queued)
+      end
+    end
+
+
+    it "should call send on all queued messages" do
+      Bernstein::Server.configure!({poll_interval:1, require_awks:true})
+      Bernstein::Server.start do
+        EventMachine.add_timer 4 do
+          Bernstein::Server.stop
+          EventMachine.stop_event_loop
+        end
+      end
+      [@message, @message2, @message3].each do |message_id|
+        expect_state(Bernstein::Client.message_status(message_id), :sending)
+      end
+    end
+  end
+
+  describe "awks" do
+    before(:each) do
+      connection = Bernstein::Message.class_variable_get('@@osc_connection')
+      allow(connection).to receive(:send_message)
+      Bernstein::RedisQueue.clear
+      @message_id = Bernstein::Client.send_message_by_string("/test/1 1")
+      expect_state(Bernstein::Client.message_status(@message_id), :queued)
+    end
+
+    it "should listen for awks and set messages with corresponding ids to sent if configured" do
+      Bernstein::Server.configure!({port: 9090, host: '127.0.0.1', poll_interval: 1, require_awks: true})
+      Bernstein::Server.start do
+        client = OSC::Client.new 9090
+        EventMachine.add_timer 2 do
+          expect_state(Bernstein::Client.message_status(@message_id), :sending)
+        end
+        EventMachine.add_timer 3 do
+          client.send OSC::Message.new('/awk_id', @message_id)
+        end
+        EventMachine.add_timer 4 do
+          Bernstein::Server.stop
+          EventMachine.stop_event_loop
+        end
+      end
+      expect_state(Bernstein::Client.message_status(@message_id), :sent)
+    end
+
+    it "should not listen for awks and set messages directly to sent if configured" do
+      Bernstein::Server.configure!({port: 9090, host: '127.0.0.1', require_awks: false, poll_interval: 1})
+      Bernstein::Server.start do
+        client = OSC::Client.new 9090
+        EventMachine.add_timer 2 do
+          expect_state(Bernstein::Client.message_status(@message_id), :sent)
+        end
+        EventMachine.add_timer 3 do
+          client.send OSC::Message.new('/awk_id', @message_id)
+        end
+        EventMachine.add_timer 4 do
+          Bernstein::Server.stop
+          EventMachine.stop_event_loop
+        end
+      end
+      expect_state(Bernstein::Client.message_status(@message_id), :sent)
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+$:.unshift( File.join( File.dirname( __FILE__), '..', 'lib' ) )
+require 'bernstein'
+
+RSpec.configure do |c|
+  c.mock_with :rspec
+end
+
+Bernstein.configure!
+
+include Bernstein::States
+
+def expect_state(something, state)
+  expect(something).to eq(STATES[state])
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: bernstein
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anthony Plekhov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.1
+- !ruby/object:Gem::Dependency
+  name: daemons
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+- !ruby/object:Gem::Dependency
+  name: ruby-osc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.31.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: Ruby OSC message queue
+email:
+- anthony.plekhov@gmail.com
+executables:
+- bernstein
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bernstein.gemspec
+- bernstein.sample.yml
+- bin/bernstein
+- lib/bernstein.rb
+- lib/bernstein/client.rb
+- lib/bernstein/message.rb
+- lib/bernstein/osc_connection.rb
+- lib/bernstein/redis_queue.rb
+- lib/bernstein/server.rb
+- lib/bernstein/states.rb
+- lib/bernstein/version.rb
+- spec/bernstein/client_spec.rb
+- spec/bernstein/message_spec.rb
+- spec/bernstein/osc_connection_spec.rb
+- spec/bernstein/redis_queue_spec.rb
+- spec/bernstein/server_spec.rb
+- spec/helper.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Ruby OSC message queue
+test_files:
+- spec/bernstein/client_spec.rb
+- spec/bernstein/message_spec.rb
+- spec/bernstein/osc_connection_spec.rb
+- spec/bernstein/redis_queue_spec.rb
+- spec/bernstein/server_spec.rb
+- spec/helper.rb