xrbp 0.0.1

data/lib/xrbp/websocket/cmds/paginated.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/hash/except'
+
+module XRBP
+  module WebSocket
+    module Cmds
+      module Paginated
+        attr_reader :prev_cmd
+
+        def root_cmd
+          return self unless prev_cmd
+          prev_cmd.root_cmd
+        end
+
+        def each_ancestor(&bl)
+          bl.call self
+          prev_cmd.each_ancestor &bl if prev_cmd
+        end
+
+        def parse_paginate(args)
+          @paginate = args[:paginate]
+          @prev_cmd = args[:prev_cmd]
+        end
+
+        def paginate_args
+          return :prev_cmd #, :paginate # XXX need to forward paginate
+        end
+
+        def args_without_paginate
+          args.except(*paginate_args)
+        end
+
+        def paginate?
+          !!@paginate
+        end
+
+        def next_page(marker)
+          self.class.from_h(to_h.merge({:marker   => marker,
+                                        :prev_cmd => self}))
+        end
+      end # module Paginated
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/server_info.rb

@@ -0,0 +1,11 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class ServerInfo < Command
+        def initialize
+          super({'command' => 'server_info'})
+        end
+      end
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds/subscribe.rb

@@ -0,0 +1,18 @@
+module XRBP
+  module WebSocket
+    module Cmds
+      class Subscribe < Command
+        attr_accessor :args
+
+        def initialize(args={})
+          @args = args
+          super(to_h)
+        end
+
+        def to_h
+          args.merge(:command => :subscribe)
+        end
+      end # class Subscribe
+    end # module Cmds
+  end # module WebSocket
+end # module Wipple

data/lib/xrbp/websocket/cmds.rb

@@ -0,0 +1,12 @@
+require_relative './cmds/paginated'
+require_relative './cmds/server_info'
+require_relative './cmds/ledger'
+require_relative './cmds/account_lines'
+require_relative './cmds/account_info'
+require_relative './cmds/account_info'
+require_relative './cmds/account_objects'
+require_relative './cmds/account_offers'
+require_relative './cmds/account_tx'
+require_relative './cmds/book_offers'
+require_relative './cmds/subscribe'
+require_relative './cmds/ledger_entry'

data/lib/xrbp/websocket/command.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module XRBP
+  module WebSocket
+    class Command < Message
+      attr_accessor :id
+
+      def initialize(data)
+        @@id ||= 0
+        @id = (@@id += 1)
+
+        json = Hash[data]
+        json['id'] = id
+
+        super(json.to_json)
+      end
+    end # class Command
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/connection.rb

@@ -0,0 +1,169 @@
+require_relative './has_plugin'
+
+module XRBP
+  module WebSocket
+    class Connection
+      include EventEmitter
+      include HasPlugin
+
+      attr_reader :url
+      attr_accessor :parent
+
+      def initialize(url)
+        @url        = url
+        @force_quit = false
+      end
+
+      ###
+
+      def connect
+        client.connect
+      end
+
+      def next_connection(prev)
+        return nil unless !!parent
+        parent.next_connection(prev)
+      end
+
+      def initialized?
+        !!@client
+      end
+
+      def open?
+        initialized? && client.open?
+      end
+
+      def closed?
+        !open?
+      end
+
+      def close!
+        client.close if open?
+      end
+
+      def send_data(data)
+        client.send_data(data)
+      end
+
+      ###
+
+      def force_quit?
+        @force_quit
+      end
+
+      def force_quit!
+        @force_quit = true
+        wake_all
+      end
+
+      def thread_registry
+        @thread_registry ||= Concurrent::Array.new
+      end
+
+      def rsleep(t)
+        thread_registry << Thread.current
+        sleep(t)
+        thread_registry.delete(Thread.current)
+      end
+
+      def wake_all
+        thread_registry.each { |th| th.wakeup }
+      end
+
+      ###
+
+      def wait_for_open
+        return unless initialized?
+
+        state_mutex.synchronize {
+          open_cv.wait(state_mutex, 0.1)
+        } until force_quit? || open?
+      end
+
+      def wait_for_close
+        return unless initialized?
+
+        state_mutex.synchronize {
+          close_cv.wait(state_mutex, 0.1)
+        } while !force_quit? && open?
+      end
+
+      def state_mutex
+        @state_mutex ||= Mutex.new
+      end
+
+      def open_cv
+        @open_cv ||= ConditionVariable.new
+      end
+
+      def close_cv
+        @close_cv ||= ConditionVariable.new
+      end
+
+      ###
+
+      def client
+        @client ||= begin
+          client = Client.new(@url)
+          conn = self
+
+          client.on :connecting do
+            conn.emit :connecting
+            conn.parent.emit :connecting if conn.parent
+          end
+
+          client.on :open do
+            conn.emit :open
+            conn.parent.emit :open if conn.parent
+
+            conn.state_mutex.synchronize {
+              conn.open_cv.signal
+            }
+
+            conn.plugins.each { |plg|
+              plg.opened if plg.respond_to?(:opened)
+            }
+          end
+
+          client.on :close do
+            conn.emit :close
+            conn.parent.emit :close if conn.parent
+
+            conn.state_mutex.synchronize {
+              conn.close_cv.signal
+            }
+
+            conn.plugins.each { |plg|
+              plg.closed if plg.respond_to?(:closed)
+            }
+          end
+
+          client.on :completed do |err|
+            conn.emit :completed
+            conn.parent.emit :completed if conn.parent
+          end
+
+          client.on :error do |err|
+            conn.emit :error, err
+            conn.parent.emit :error, err if conn.parent
+
+            conn.plugins.each { |plg|
+              plg.error err if plg.respond_to?(:error)
+            }
+          end
+
+          client.on :message do |msg|
+            conn.emit :message, msg
+            conn.parent.emit :message, msg if conn.parent
+
+            conn.plugins.each { |plg|
+              plg.message msg if plg.respond_to?(:message)
+            }
+          end
+
+          client
+        end
+      end
+    end # class Connection
+  end # module WebSocket 
+end # module XRBP

data/lib/xrbp/websocket/has_plugin.rb

@@ -0,0 +1,30 @@
+module XRBP
+  module WebSocket
+    module HasPlugin
+      def plugins
+        @plugins ||= []
+      end
+
+      def add_plugin(*plgs)
+        plgs.each { |plg|
+          plg = WebSocket.plugins[plg] if plg.is_a?(Symbol)
+          raise ArgumentError unless !!plg
+          plg = plg.new(self)
+          plugins << plg
+          plg.added if plg.respond_to?(:added)
+        }
+      end
+
+      def plugin?(plg)
+        plugins.collect { |plg| plg.class }.include?(plg)
+      end
+
+      def define_instance_method(name, &block)
+        (class << self; self; end).class_eval do
+          define_method name, &block
+        end
+      end
+
+    end # module HasPlugin
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/message.rb

@@ -0,0 +1,41 @@
+module XRBP
+  module WebSocket
+    class Message
+      attr_reader :result, :time
+      attr_accessor :connection
+
+      def initialize(data)
+        @data = data
+        @result = nil
+        @cv = ConditionVariable.new
+        @signalled = false
+        @time = Time.now
+      end
+
+      def to_s
+        @data
+      end
+
+      def signal
+        @signalled = true
+        @cv.signal
+      end
+
+      def wait
+        connection.state_mutex.synchronize {
+          # only wait if we haven't received response
+          @cv.wait(connection.state_mutex) unless connection.closed? || @signalled
+        }
+      end
+
+      attr_writer :bl
+
+      def bl
+        @bl ||= proc { |res|
+          @result = res
+          signal
+        }
+      end
+    end # class Message
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/multi/fallback.rb

@@ -0,0 +1,18 @@
+module XRBP
+  module WebSocket
+    class Fallback < MultiConnection
+      def initialize(*urls)
+        super(*urls)
+      end
+
+      def next_connection(prev=nil)
+        unless prev.nil?
+          return nil if connections.last == prev
+          return connections[(connections.index(prev) + 1)..-1].find { |c| !c.closed? }
+        end
+
+        connections.find { |c| !c.closed? }
+      end
+    end # class Fallback
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/multi/multi_connection.rb

@@ -0,0 +1,55 @@
+require_relative '../has_plugin'
+
+module XRBP
+  module WebSocket
+    class MultiConnection
+      include EventEmitter
+      include HasPlugin
+
+      attr_reader :connections
+
+      def initialize(*urls)
+        @connections = []
+
+        urls.each { |url|
+          @connections << Connection.new(url)
+        }
+
+        connections.each { |c| c.parent = self }
+
+        yield self if block_given?
+      end
+
+      def force_quit!
+        connections.each { |c| c.force_quit! }
+      end
+
+      def close!
+        connections.each { |c| c.close! }
+      end
+
+      alias :_add_plugin :add_plugin
+
+      def add_plugin(*plg)
+        connections.each { |c|
+          c.add_plugin *plg
+        }
+
+        _add_plugin(*plg)
+      end
+
+      # Always return first connection by default,
+      # override in subclasses
+      def next_connection(prev=nil)
+        return nil unless prev.nil?
+        @connections.first
+      end
+
+      def connect
+        @connections.each { |c|
+          c.connect
+        }
+      end
+    end # class MultiConnection
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/multi/parallel.rb

@@ -0,0 +1,28 @@
+module XRBP
+  module WebSocket
+    class Parallel < MultiConnection
+      class All
+        attr_accessor :connections
+
+        def initialize(connections)
+          @connections = connections
+        end
+
+        def method_missing(m, *args, &bl)
+          connections.collect { |c|
+            c.send(m, *args, &bl) if c.open?
+          }
+        end
+      end # class All
+
+      def initialize(*urls)
+        super(*urls)
+      end
+
+      def next_connection(prev=nil)
+        return nil unless prev.nil?
+        All.new connections
+      end
+    end # class RoundRobin
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/multi/prioritized.rb

@@ -0,0 +1,15 @@
+module XRBP
+  module WebSocket
+    class Prioritized < MultiConnection
+      def initialize(*urls)
+        super(*urls)
+      end
+
+      def next_connection(prev=nil)
+        return nil if prev == connections.last
+        return super if prev.nil?
+        connections[connections.index(prev)+1]
+      end
+    end # class Prioritized
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/multi/round_robin.rb

@@ -0,0 +1,19 @@
+module XRBP
+  module WebSocket
+    class RoundRobin < MultiConnection
+      def initialize(*urls)
+        super(*urls)
+        @current = 0
+      end
+
+      def next_connection(prev=nil)
+        return nil unless prev.nil?
+
+        c = connections[@current]
+        @current += 1
+        @current  = 0 if @current >= connections.size
+        c
+      end
+    end # class RoundRobin
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/plugins/autoconnect.rb

@@ -0,0 +1,42 @@
+module XRBP
+  module WebSocket
+    module Plugins
+      # Automatically reconnects on close events
+      class AutoConnect
+        attr_reader :connection
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def added
+          return if connection.kind_of?(MultiConnection)
+
+          conn = connection
+
+          connection.on :completed do
+            connected = false
+            until conn.force_quit? || connected
+              begin
+                conn.connect
+                connected = true
+              rescue
+                conn.rsleep(3)
+              end
+            end
+          end
+
+          until connection.force_quit? || connection.open?
+            begin
+              connection.connect
+            rescue
+              connection.rsleep(3)
+            end
+          end
+        end
+      end # class AutoConnect
+
+      WebSocket.register_plugin :autoconnect, AutoConnect
+    end # module Plugins
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/plugins/command_dispatcher.rb

@@ -0,0 +1,39 @@
+module XRBP
+  module WebSocket
+    module Plugins
+      # Dispatch commands (based on message dispatcher)
+      class CommandDispatcher < MessageDispatcher
+        def added
+          super
+
+          plugin = self
+
+          connection.define_instance_method(:cmd) do |cmd, &bl|
+            return next_connection.cmd cmd, &bl if self.kind_of?(MultiConnection)
+
+            cmd = Command.new(cmd) unless cmd.kind_of?(Command)
+            msg(cmd, &bl)
+          end
+        end
+
+        def match_message(msg)
+          begin
+            return nil if msg.data == ""
+            parsed = JSON.parse(msg.data)
+
+          rescue => e
+            return nil
+          end
+
+          id = parsed['id']
+          msg = messages.find { |msg| msg.kind_of?(Command) && msg.id == id }
+
+          return nil unless msg
+          [msg, parsed]
+        end
+      end # class CommandDispatcher
+
+      WebSocket.register_plugin :command_dispatcher, CommandDispatcher
+    end # module Plugins
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/plugins/command_paginator.rb

@@ -0,0 +1,45 @@
+module XRBP
+  module WebSocket
+    module Plugins
+      # Handles multi-page messages
+      class CommandPaginator
+        attr_reader :connection
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def added
+          raise "Must also include CommandDispatcher plugin" unless connection.plugin?(CommandDispatcher)
+        end
+
+        def unlock!(cmd, res)
+          return true unless cmd.respond_to?(:paginate?) && cmd.paginate?
+
+          marker = res["result"]["marker"]
+          page   = res["result"][cmd.page_title]
+
+          if marker && next_cmd = cmd.next_page(marker)
+            connection.cmd next_cmd do
+              page
+            end
+
+          else
+            # XXX can't recursively use stack to unwind
+            #     callbacks as there may be too many pages.
+            #     Do it serially.
+            res = Array.new(page)
+            cmd.each_ancestor { |page_cmd|
+              page_res = page_cmd.bl.call res
+              res = page_res + res if page_cmd.prev_cmd
+            }
+          end
+
+          false
+        end
+      end # class CommandPaginator
+
+      WebSocket.register_plugin :command_paginator, CommandPaginator
+    end # module Plugins
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/plugins/connection_timeout.rb

@@ -0,0 +1,54 @@
+module XRBP
+  module WebSocket
+    module Plugins
+      # Automatic disconnection if no server data in certain time
+      class ConnectionTimeout
+        attr_reader :connection
+        attr_accessor :connection_timeout
+
+        DEFAULT_TIMEOUT = 10
+
+        def initialize(connection)
+          @connection = connection
+          @connection_timeout = DEFAULT_TIMEOUT
+        end
+
+        def added
+          plugin = self
+          connection.define_instance_method(:connection_timeout=) do |t|
+            plugin.connection_timeout = t
+
+            self.plugins.find { |plg|
+              plg.is_a?(ConnectionTimeout)
+            }.connection_timeout = t if self.kind_of?(MultiConnection)
+          end
+        end
+
+        def message(msg)
+          @last_msg = Time.now
+        end
+
+        def opened
+          @thread = Thread.new {
+            @last_msg = Time.now
+            until connection.force_quit? ||
+                  connection.closed?     ||
+                  Thread.current != @thread
+              if Time.now - @last_msg > @connection_timeout
+                connection.close!
+              end
+
+              connection.rsleep(0.1)
+            end
+          }
+        end
+
+        def closed
+          @thread.join unless @thread == Thread.current
+        end
+      end # class ConnectionTimeout
+
+      WebSocket.register_plugin :connection_timeout, ConnectionTimeout
+    end # module Plugins
+  end # module WebSocket
+end # module XRBP