flotype-bridge 0.1.0.beta.2

data/lib/bb/conn.rb

@@ -0,0 +1,31 @@
+module Bridge
+  module Conn
+    def self.send arg
+      Util::log 'sending: ' + arg
+      @@conn.send_data arg
+    end
+
+    # Methods expected by EventMachine.
+    def initialize
+      Util::log 'Connection initialized.'
+      @@conn = self
+    end
+
+    def post_init
+      Util::log 'Starting handshake.'
+      Core::command(:CONNECT,
+                    { :session => Core::session,
+                      :api_key => Bridge::options['api_key'] })
+    end
+
+    def receive_data data
+      Util::log 'Got data.'
+      Core::process(data)
+    end
+
+    def unbind
+      Util::log 'Disconnected.'
+      Core::disconnect
+    end
+  end
+end

data/lib/bb/core.rb

@@ -0,0 +1,109 @@
+module Bridge
+  # The internals of the Bridge client. Use of this module is strongly
+  # unadvised, as the internal structure may vary greatly from that of
+  # other language implementations.
+  module Core
+    @@services, @@queue, @@sess = {'["system"]' => Bridge::Sys}, [], [nil, nil]
+    @@connected, @@len, @@buffer = false, 0, ''
+
+    def self.session
+      @@sess
+    end
+
+    def self.client_id
+      @@sess[0]
+    end
+
+    def self.connected
+      @@connected
+    end
+
+    # The queue is used primarily for Bridge::ready() callbacks.
+    def self.enqueue fun
+      if @@connected
+        fun.call
+      else
+        @@queue = @@queue + [fun]
+      end
+    end
+
+    def self.store svc, obj = nil, named = true
+      @@services[[named ? svc : "channel:#{svc}"].to_json] = obj
+    end
+
+    def self.lookup ref
+      Util::log 'Looking up ref ' + ref.to_json
+      ref = JSON::parse ref.to_json
+      svc = @@services[ref[2 .. -1].to_json] || @@services[[ref[2]].to_json]
+      if svc != nil
+        if ref[3] != nil
+          svc.method(ref[3])
+        else
+          svc
+        end
+      else
+        Ref.lookup ref
+      end
+    end
+
+    def self.process data
+      if @@len == 0
+        @@len = data.unpack('N')[0]
+        return process data[4 .. -1]
+      end
+      Util::log ':::: ' + data
+      (@@buffer << data)
+      if @@buffer.length < @@len
+        return
+      end
+      data = @@buffer
+      @@buffer, @@len = @@buffer[@@len .. -1], 0
+      # If this is the first message, set our SessionId and Secret.
+      m = /^(\w+)\|(\w+)$/.match data
+      if m
+        @@connected = true
+        @@sess = [m[1], m[2]]
+        Util::log "Received secret and session ID: #{@@sess.to_json}"
+        @@queue.each {|fun|
+          fun.call
+        }
+        @@queue = []
+        return
+      end
+      # Else, it is a normal message.
+      unser = Util::unserialize data
+      dest = unser['destination']
+      if dest.respond_to? :call
+        dest.call *unser['args']
+      end
+    end
+
+    def self.command cmd, data
+      if cmd == :CONNECT
+        Conn::send(Util::serialize({:command => cmd, :data => data}))
+      else
+        Core::enqueue lambda {
+          Conn::send(Util::serialize({:command => cmd, :data => data}))
+        }
+      end
+    end
+
+    def self.reconnect timeout
+      opts = Bridge::options
+      if opts[:reconnect]
+        Util::log "Attempting to reconnect; waiting at most #{timeout.to_s}s."
+        EventMachine::connect(opts[:host], opts[:port], Conn)
+        EventMachine::Timer.new(timeout) do
+          if not @@connected
+            reconnect timeout * 2
+          end
+        end
+      end
+    end
+
+    def self.disconnect
+      @@connected = false
+      reconnect 0.1
+    end
+  end
+end

data/lib/bb/localref.rb

@@ -0,0 +1,37 @@
+module Bridge
+  # Wrapper for callbacks passed in as arguments.
+  class LocalRef < Ref
+    def initialize path, mod
+      @mod = mod
+      path = ['client', lambda {Core::client_id}] + path
+      super(path)
+    end
+
+    def method_missing atom, *args, &blk
+      (@mod.method atom).call *args
+    end
+
+    def method atom
+      @mod.method(atom)
+    end
+
+    def operations bool
+      @mod.methods(bool)
+    end
+
+    def call *args
+      @mod.call *args
+    end
+
+    def respond_to? atom
+      @mod.respond_to? atom
+    end
+
+    def to_json *a
+      if @path[1].respond_to? :call
+        @path[1] = @path[1].call
+      end
+      {:ref => @path, :operations => @mod.methods(false)}.to_json *a
+    end
+  end
+end

data/lib/bb/ref.rb

@@ -0,0 +1,49 @@
+module Bridge
+  # Instances of this class represent references to remote services.
+  class Ref
+    @@refs = {}
+
+    def self.lookup ref
+      key = ref[2 .. -1].to_json
+      if @@refs[key] == nil
+        @@refs[key] = Ref.new(ref)
+      end
+      @@refs[key]
+    end
+
+    def initialize path
+      @path = path
+      @@refs[path[2 .. -1].to_json] = self
+    end
+
+    def path
+      @path
+    end
+
+    def method_missing atom, *args, &blk
+      Core::lookup(@path + [atom]).call *args
+    end
+ 
+    def method atom
+      Core::lookup(@path + [atom])
+    end
+
+    def call *args
+      Core::command :SEND, {
+        :destination => {:ref => @path},
+        :args        => Util::inflate(args)
+      }
+    end
+
+    def respond_to? atom
+      true
+    end
+
+    def to_json *a
+      if @path[1].respond_to? :call
+        @path[1] = @path[1].call
+      end
+      {:ref => @path}.to_json *a
+    end
+  end
+end

data/lib/bb/svc.rb

@@ -0,0 +1,7 @@
+module Bridge
+  # Wrapper for user-defined Bridge Services. All services passed in
+  # as arguments must include this module in order to be detected and
+  # serialized correctly.
+  module Service
+  end
+end

data/lib/bb/sys.rb

@@ -0,0 +1,17 @@
+module Bridge
+  # These are internal system functions, which should only be called by the
+  # Erlang gateway.
+  module Sys
+    def self.hook_channel_handler name, handler, fun
+      fun.call(Core::store(name, handler, 'channel'))
+    end
+
+    def self.remoteError msg
+      Util::err(msg)
+    end
+
+    def self.get_service name, fun
+      fun.call(Core::lookup(name).methods(false))
+    end
+  end
+end

data/lib/bb/util.rb

@@ -0,0 +1,93 @@
+require 'json'
+
+module Bridge
+  module Util
+    # Traverses an object, replacing funs with refs.
+    def self.inflate obj
+      if obj.is_a?(Array)
+        obj.map do |v|
+          Util::bloat v
+        end
+      else
+        o = {}
+        obj.each do |k, v|
+          o[k] = Util::bloat v
+        end
+        o
+      end
+    end
+
+    def self.bloat v
+      if v.is_a?(Module) || v.is_a?(Bridge::Service)
+        local_ref(v)
+      elsif v.respond_to?(:call) && !v.is_a?(Ref)
+        cb(v)
+      elsif v.is_a?(Hash) || v.is_a?(Array)
+        inflate v
+      else
+        v
+      end
+    end
+
+    def self.deflate obj
+      if obj.is_a?(Array)
+        obj.map do |v|
+          deflate v
+        end
+      elsif obj.is_a? Hash
+        if obj.has_key? 'ref'
+          Core::lookup obj['ref']
+        else
+          o = {}
+          obj.each do |k, v|
+            o[k] = deflate v
+          end
+          o
+        end
+      else
+        obj
+      end
+    end
+
+    def self.serialize obj
+      obj = inflate(obj)
+      str = JSON::generate obj
+      [str.length].pack("N") + str
+    end
+
+    def self.unserialize str
+      obj = deflate(JSON::parse str)
+      deflate obj
+    end
+
+    def self.err msg
+      $stderr.puts msg
+    end
+
+    def self.log msg, level = 3
+      opts = Bridge::options
+      if level <= opts['log_level']
+        puts msg
+      end
+    end
+
+    def self.cb fun
+      Core::store(fun.object_id.to_s(36),
+                  LocalRef.new([fun.hash.to_s(36)], Callback.new(fun)))
+    end
+
+    def self.has_keys? obj, *keys
+      keys.each do |k|
+        if !obj.has_key?(k) && !obj.has_key?(k.to_sym)
+          return false
+        end
+      end
+      true
+    end
+
+    def self.local_ref v
+      key = v.object_id.to_s(36)
+      Core::store key, Bridge::LocalRef.new([key], v)
+    end
+  end
+end

data/lib/bb/version.rb

@@ -0,0 +1,3 @@
+module Bridge
+  VERSION = "0.1.0.beta.2"
+end

data/lib/bridge.rb

@@ -0,0 +1,130 @@
+require 'bb/svc'
+require 'bb/conn'
+require 'bb/ref'
+require 'bb/sys'
+require 'bb/core'
+require 'bb/localref'
+require 'bb/callback'
+require 'bb/util'
+
+require 'eventmachine'
+
+module Bridge
+
+  # Expects to be called inside an EventMachine block in lieu of
+  #   EM::connect.
+  # @param [Hash] configuration options
+  @options = {
+    'reconnect'  => true,
+    'redir_host' => 'redirector.flotype.com',
+    'redir_port' => 80,
+    'log_level'  => 3, # 0 for no output.
+  }
+  def self.initialize(options = {})
+    Util::log 'initialize called.'
+    @options = @options.merge(options)
+
+    if !(@options.has_key? 'api_key')
+      raise ArgumentError, 'No API key specified.'
+    end
+
+    if Util::has_keys?(@options, 'host', 'port')
+      EM::connect(@options['host'], @options['port'], Bridge::Conn)
+    else
+      # Support for redirector.
+      conn = EM::Protocols::HttpClient2.connect(@options['redir_host'],
+                                                @options['redir_port'])
+      req = conn.get({:uri => "/redirect/#{@options['api_key']}"})
+      req.callback do |obj|
+        obj = JSON::parse obj.content
+        if obj.has_key?('data')
+          obj = obj['data']
+          EM::connect(obj['bridge_host'], obj['bridge_port'], Bridge::Conn)
+        else
+          raise Exception, 'Invalid API key.'
+        end
+      end
+    end
+  end
+
+  # Accessor for @options.
+  # @return [Object] options
+  def self.options
+    @options
+  end
+
+  # Similar to $(document).ready of jQuery as well as now.ready: takes
+  #   callbacks that it will call when the connection handshake has been
+  #   completed.
+  # @param [#call] fun Callback to be called when the server connects.
+  def self.ready fun
+    Core::enqueue fun
+  end
+
+  # Calls a remote function specified by `dest` with `args`.
+  # @param [Ref] dest The identifier of the remote function to call.
+  # @param [Array] args Arguments to be passed to `dest`.
+  def self.send dest, args
+    Core::command(:SEND,
+                  { :args        => Util::serialize(args),
+                    :destination => dest })
+  end
+
+  # Broadcasts the availability of certain functionality specified by a
+  #   proc `fun` under the name of `svc`.
+  def self.publish_service svc, handler, fun = nil
+    if svc == 'system'
+      Util::err("Invalid service name: #{svc}")
+    else
+      obj = { :name => svc}
+      if fun.respond_to? :call
+        obj[:callback] = Util::cb(fun)
+      end
+      Core::command(:JOINWORKERPOOL, obj)
+      Core::store(svc, Bridge::LocalRef.new([svc], handler))
+    end
+  end
+
+  # Join the channel specified by `channel`. Messages from this channel
+  #   will be passed in to a handler specified by `handler`. The callback
+  #   `fun` is to be called to confirm successful joining of the channel.
+  def self.join_channel channel, handler, fun = nil
+    obj = { :name => channel, :handler => Util::local_ref(handler)}
+    if fun.respond_to? :call
+      obj[:callback] = Util::cb(fun)
+    end
+    Core::command(:JOINCHANNEL, obj)
+  end
+
+  # Leave a channel.
+  def self.leave_channel channel, handler, fun = nil
+    obj = { :name => channel, :handler => Util::local_ref(handler)}
+    if fun.respond_to? :call
+      obj[:callback] = Util::cb(fun)
+    end
+    Core::command(:LEAVECHANNEL, obj)
+  end
+
+  # Leave a channel.
+  def self.leave_channel channel, handler, fun
+    Core::command(:LEAVECHANNEL,
+                  { :name     => channel,
+                    :handler  => Util::local_ref(handler),
+                    :callback => Util::cb(fun) })
+  end
+
+  # Returns a reference to the service specified by `svc`.
+  def self.get_service svc
+    Core::lookup ['named', svc, svc]
+  end
+
+  # Returns a reference to the channel specified by `channel`.
+  def self.get_channel channel
+    Core::lookup ['channel', channel, "channel:#{channel}"]
+  end
+
+  # The client's ID.
+  def self.client_id
+    Core::client_id
+  end
+end