bridge-ruby 0.2.0

data/lib/connection.rb

@@ -0,0 +1,162 @@
+require 'uri'
+require 'util.rb'
+require 'tcp.rb'
+require 'serializer.rb'
+
+module Bridge
+  class Connection #:nodoc: all
+
+    attr_accessor :connected, :client_id, :sock, :options
+  
+    def initialize bridge
+      # Set associated bridge object
+      @bridge = bridge
+
+      @options = bridge.options
+      
+      # Preconnect buffer
+      @sock_buffer = SockBuffer.new
+      @sock = @sock_buffer
+      
+      # Connection configuration
+      @interval = 0.4
+    end
+    
+    # Contact redirector for host and ports
+    def redirector
+      # Support for redirector.
+      uri = URI(@options[:redirector])
+      conn = EventMachine::Protocols::HttpClient2.connect(:host => uri.host, :port => uri.port, :ssl => @options[:secure])
+      req = conn.get({:uri => "/redirect/#{@options[:api_key]}"})
+      req.callback do |obj|
+        begin
+          obj = JSON::parse obj.content
+        rescue Exception => e
+          Util.error "Unable to parse redirector response #{obj.content}"
+          return
+        end
+        if obj.has_key?('data') and obj['data'].has_key?('bridge_host') and obj['data'].has_key?('bridge_port')
+          obj = obj['data']
+          @options[:host] = obj['bridge_host']
+          @options[:port] = obj['bridge_port']
+          establish_connection
+        else
+          Util.error "Could not find host and port in JSON body"
+        end
+      end
+    end
+    
+    def reconnect
+      Util.info "Attempting to reconnect"
+      if @interval < 32768
+        EventMachine::Timer.new(@interval) do
+          establish_connection
+          # Grow timeout for next reconnect attempt
+          @interval *= 2
+        end
+      end
+    end
+    
+    def establish_connection
+      Util.info "Starting TCP connection #{@options[:host]}, #{@options[:port]}"
+      EventMachine::connect(@options[:host], @options[:port], Tcp, self)
+    end
+    
+    def onmessage data, sock
+      # Parse for client id and secret
+      m = /^(\w+)\|(\w+)$/.match data[:data]
+      if not m
+        # Handle message normally if not a correct CONNECT response
+        process_message data
+      else
+        Util.info "client_id received, #{m[1]}"
+        @client_id = m[1]
+        @secret = m[2]
+        # Reset reconnect interval
+        @interval = 0.4
+        # Send preconnect queued messages
+        @sock_buffer.process_queue sock, @client_id
+        # Set connection socket to connected socket
+        @sock = sock
+        Util.info('Handshake complete')
+        # Trigger ready callback
+        if not @bridge.is_ready
+          @bridge.is_ready = true
+          @bridge.emit 'ready'
+        end
+      end
+    end
+
+    def onopen sock
+      Util.info 'Beginning handshake' 
+      msg = Util.stringify(:command => :CONNECT, :data => {:session => [@client_id || nil, @secret || nil], :api_key => @options[:api_key]})
+      sock.send msg
+    end
+    
+    def onclose
+      Util.warn 'Connection closed'
+      # Restore preconnect buffer as socket connection
+      @sock = @sock_buffer
+      if @options[:reconnect]
+        reconnect
+      end
+    end
+    
+    def process_message message
+      begin
+        Util.info "Received #{message[:data]}"
+        message = Util.parse(message[:data])
+      rescue Exception => e
+        Util.error "Message parsing failed"
+      end
+      # Convert serialized ref objects to callable references
+      Serializer.unserialize(@bridge, message['args'])
+      # Extract RPC destination address
+      destination = message['destination']
+      if !destination
+        Util.warn "No destination in message #{message}"
+        return
+      end
+      if message['source']
+        @bridge.context = Client.new(@bridge, message['source'])
+      end
+      @bridge.execute message['destination']['ref'], message['args']
+    end
+    
+    def send_command command, data
+      data.delete :callback if data.key? :callback and data[:callback].nil?
+      msg = Util.stringify :command => command, :data => data
+      Util.info "Sending #{msg}"
+      @sock.send msg
+    end
+    
+    def start 
+      if !@options.has_key? :host or !@options.has_key? :port
+        redirector
+      else
+        # Host and port are specified
+        establish_connection
+      end
+    end
+    
+    class SockBuffer
+      def initialize
+        # Buffer for preconnect messages
+        @buffer = []
+      end
+      
+      def send msg
+        @buffer << msg
+      end
+      
+      def process_queue sock, client_id
+        @buffer.each do |msg|
+          # Replace null client ids with actual client_id after handshake
+          sock.send( msg.gsub '"client",null', '"client","'+ client_id + '"' )
+        end
+        @buffer = []
+      end
+    end
+    
+  end
+end

data/lib/reference.rb

@@ -0,0 +1,49 @@
+module Bridge
+  # Instances of this class represent references to remote services.
+  class Reference #:nodoc: all
+   
+    attr_accessor :operations, :address  
+    
+    def initialize bridge, address, operations = nil
+      @address = address
+      # Store operations supported by this reference if any
+      operations = [] if operations.nil?
+      @operations = operations.map do |val|
+        val.to_s
+      end
+      @bridge = bridge
+    end
+
+    def to_dict op = nil
+      # Serialize the reference
+      result = {}
+      address = @address
+      # Add a method name to address if given
+      if op
+        address = address.slice(0..-1)
+        address << op
+      end
+      result[:ref] = address
+      # Append operations only if address refers to a handler
+      if address.length < 4
+        result[:operations] = @operations
+      end
+      return result
+    end
+
+    def method_missing atom, *args, &blk
+      # If a block is given, add to arguments list
+      args << blk if blk
+      Util.info "Calling #{@address}.#{atom}"
+      # Serialize destination
+      destination = self.to_dict atom.to_s
+      # Send RPC
+      @bridge.send args, destination
+    end
+
+    def respond_to? atom
+      @operations.include?(atom.to_s) || atom == :to_dict || Class.respond_to?(atom)
+    end
+
+  end
+end

data/lib/serializer.rb

@@ -0,0 +1,104 @@
+require 'json'
+require 'util.rb'
+
+module Bridge
+  module Serializer #:nodoc: all
+    
+     def self.serialize bridge, obj
+      # Serialize immediately if obj responds to to_dict
+      if obj.respond_to? :to_dict
+        result = obj.to_dict
+      # Enumerate hash and serialize each member
+      elsif obj.is_a? Hash
+        result = {}
+        obj.each do |k, v|
+          result[k] = serialize bridge, v
+        end
+      # Enumerate array and serialize each member
+      elsif obj.is_a? Array
+        result = obj.map do |v|
+          serialize bridge, v
+        end
+      # Store as callback if callable
+      elsif obj.respond_to?(:call)
+        result = bridge.store_object(Callback.new(obj), ['callback']).to_dict
+      # Return obj itself is JSON serializable
+      elsif JSON::Ext::Generator::GeneratorMethods.constants.include? obj.class.name.to_sym
+        result = obj
+      # Otherwise store as service. Obj is a class instance or module
+      else
+        result = bridge.store_object(obj, Util.find_ops(obj)).to_dict  
+      end
+      return result
+    end
+
+    def self.unserialize bridge, obj
+      if obj.is_a? Hash
+        obj.each do |k, v|
+          unserialize_helper bridge, obj, k, v
+        end
+      elsif obj.is_a? Array
+        obj.each_with_index do |v, k|
+          unserialize_helper bridge, obj, k, v
+        end
+      end
+    end
+    
+    def self.unserialize_helper bridge, obj, k, v
+      if v.is_a? Hash
+        # If object has ref key, convert to reference
+        if v.has_key? 'ref'
+          if v['ref'][1] == bridge.connection.client_id and v['ref'][0] == 'client' and 
+            obj[k] = bridge.store[v['ref'][2]]
+            if obj[k].is_a? Callback
+              obj[k] = obj[k].method :callback
+            end
+          else
+            # Create reference
+            ref = Reference.new(bridge, v['ref'], v['operations'])
+            if v.has_key? 'operations' and v['operations'].length == 1 and v['operations'][0] == 'callback'
+              # Callback wrapper
+              obj[k] = Util.ref_callback ref
+            else
+              obj[k] = ref
+            end
+          end
+          return
+        end
+      end
+      unserialize bridge, v
+    end
+    
+    class Callback
+      def initialize fun
+        @fun = fun
+      end
+
+      def callback *args
+        @fun.call *args
+      end
+
+      def call *args
+        @fun.call(*args)
+      end
+
+      def method atom
+        if atom.to_s == 'callback'
+          @fun
+        else
+          Class.method atom
+        end
+      end
+
+      def methods bool
+        [:callback]
+      end
+
+      def respond_to? atom
+        atom.to_s == 'callback' || Class.respond_to?(atom)
+      end
+      
+    end
+    
+  end
+end

data/lib/ssl_utils.rb

@@ -0,0 +1,68 @@
+require 'openssl'
+
+class OpenSSL::X509::Certificate
+  def ==(other)
+    other.respond_to?(:to_pem) && to_pem == other.to_pem
+  end
+
+  # A serial *must* be unique for each certificate. Self-signed certificates,
+  # and thus root CA certificates, have the same `issuer' as `subject'.
+  def top_level?
+    serial == serial && issuer.to_s == subject.to_s
+  end
+  alias_method :root?, :top_level?
+  alias_method :self_signed?, :top_level?
+end
+
+# Verifies that the peer certificate is a valid chained certificate. That is,
+# it's signed by a root CA or a CA signed by a root CA.
+#
+# This module will also perform hostname verification against the server’s
+# certificate, but _only_ if an instance variable called +@hostname+ exists.
+module SSLCertificateVerification
+  class << self
+    # In PEM format.
+    #
+    # Eg: http://curl.haxx.se/docs/caextract.html
+    attr_accessor :ca_cert_file
+  end
+
+  def ca_store
+    unless @ca_store
+      if file = SSLCertificateVerification.ca_cert_file
+        @ca_store = OpenSSL::X509::Store.new
+        @ca_store.add_file(file)
+      else
+        fail "you must specify a file with root CA certificates as `SSLCertificateVerification.ca_cert_file'"
+      end
+    end
+    @ca_store
+  end
+
+  # It's important that we try to not add a certificate to the store that's
+  # already in the store, because OpenSSL::X509::Store will raise an exception.
+  def ssl_verify_peer(cert_string)
+    cert = OpenSSL::X509::Certificate.new(cert_string)
+    # Some servers send the same certificate multiple times. I'm not even joking... (gmail.com)
+    return true if cert == @last_seen_cert
+    @last_seen_cert = cert
+
+    if ca_store.verify(@last_seen_cert)
+      # A server may send the root certifiacte, which we already have and thus
+      # should not be added to the store again.
+      ca_store.add_cert(@last_seen_cert) unless @last_seen_cert.root?
+      true
+    else
+      fail "unable to verify the server certificate of `#{@hostname}'"
+      false
+    end
+  end
+
+  def ssl_handshake_completed
+    if @hostname
+      unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, @hostname)
+        fail "the hostname `HOSTNAME' does not match the server certificate"
+      end
+    end
+  end
+end

data/lib/tcp.rb

@@ -0,0 +1,73 @@
+require 'eventmachine'
+require 'openssl'
+require 'ssl_utils.rb'
+
+module Bridge
+  class Tcp < EventMachine::Connection #:nodoc: all
+
+    include SSLCertificateVerification
+
+    def initialize connection
+      @buffer = ''
+      @len = 0
+      @pos = 0
+      @callback = nil
+      @connection = connection
+      SSLCertificateVerification.ca_cert_file = File.expand_path('../../include/ssl/cacert.pem', __FILE__)
+      start
+    end
+
+    def post_init
+      start_tls(:verify_peer => true) if @connection.options[:secure]
+    end
+
+    def connection_completed
+      # connection now ready. call the callback
+      @connection.onopen self
+    end
+
+    def receive_data data
+      left = @len - @pos
+      if data.length >= left
+        @buffer << data.slice(0, left)
+        @callback.call @buffer
+        receive_data data.slice(left..-1) unless data.nil?
+      else
+        @buffer << data
+        @pos = @pos + data.length
+      end
+    end
+
+    def read len, &cb
+      @buffer = ''
+      @len = len
+      @pos = 0
+      @callback = cb
+    end
+
+    def start
+      # Read header bytes
+      read 4 do |data|
+        # Read body bytes
+        read data.unpack('N')[0] do |data|
+          # Call message handler
+          @connection.onmessage({:data => data}, self)
+          # Await next message
+          start
+        end
+      end
+    end
+
+    def send arg
+      # Prepend length header to message
+      send_data([arg.length].pack("N") + arg)
+    end
+
+    def unbind
+      @connection.onclose
+    end
+
+  end
+end
+
+