xrbp 0.0.1 → 0.1.0

data/lib/xrbp/model/parsers/account.rb

@@ -0,0 +1,44 @@
+module XRBP
+  module Model
+    # @private
+    module Parsers
+      # Account Info data parser
+      #
+      # @private
+      class AccountInfo < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          j = JSON.parse(res)
+          # return res unless j.key?("accounts")
+
+          accts = (j["accounts"] || []).collect { |a|
+                    {:id        => a["account"],
+                     :inception => a["inception"],
+                     :parent_id => a["parent"]}
+                  }
+
+          {:marker   => j["marker"],
+           :accounts => accts}
+        end
+      end
+
+      # Account Username data parser
+      #
+      # @private
+      class AccountUsername < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          j = JSON.parse(res)
+          # return res unless j.key?("exists")
+          j["exists"] ? j["username"] : nil
+        end
+      end
+    end # module Parsers
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/parsers/gateway.rb

@@ -0,0 +1,40 @@
+module XRBP
+  module Model
+    # @private
+    module Parsers
+      # Gateway list data parser
+      #
+      # @private
+      class Gateway < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          gateways = []
+
+          j = JSON.parse(res)
+          j.each_key { |currency|
+            j[currency].each { |currency_gateway|
+              id   = currency_gateway["account"]
+              name = currency_gateway["name"]
+              gateway = gateways.find { |gw| gw[:id] == id }
+              if gateway
+                gateway[:currencies] << "#{currency}"
+                gateway[:names]      << "#{name}" unless gateway[:names].include?(name)
+
+              else
+                gateways << {:id          => id,
+                             :names       => [name],
+                             :currencies  => [currency],
+                             :start_date  => currency_gateway["start_date"]}
+              end
+            }
+          }
+
+          gateways
+        end
+      end # class GatewayParser
+    end # module Parsers
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/parsers/market.rb

@@ -0,0 +1,28 @@
+module XRBP
+  module Model
+    # @private
+    module Parsers
+      # Market List data parser
+      #
+      # @private
+      class Market < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          j = JSON.parse(res)
+          return res unless j["result"] &&
+                            j["result"]["markets"] &&
+                            j["result"]["markets"]["base"]
+          j["result"]["markets"]["base"]
+              .collect { |market|
+            {:exchange => market["exchange"],
+             :currency => market["pair"][3..-1],
+             :route    => market["route"]}
+          }
+        end
+      end
+    end # module Parsers
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/parsers/node.rb

@@ -0,0 +1,19 @@
+module XRBP
+  module Model
+    # @private
+    module Parsers
+      # Node Peers data parser
+      #
+      # @private
+      class NodePeers < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          JSON.parse(res)["overlay"]["active"]
+        end
+      end
+    end # module Parsers
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/parsers/quote.rb

@@ -0,0 +1,47 @@
+module XRBP
+  module Model
+    # @private
+    module Parsers
+      # Market quotes data parser
+      #
+      # @private
+      class Quote < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          return [] unless res && res != ''
+
+          j = JSON.parse(res)
+          return [] unless j["result"]
+
+          j["result"].collect { |p, quotes|
+            next nil unless quotes
+            quotes.collect { |q|
+              t   = q[0]
+              o   = q[1]
+              h   = q[2]
+              l   = q[3]
+              c   = q[4]
+              vol = q[5]
+
+              # discard invalid data
+              # (some exchanges periodically
+              #  return '0's for some timestamps,
+              #  perhaps for periods with no trades?)
+              next nil if o.zero? || h.zero? || l.zero? || c.zero? || vol.zero?
+
+              {:timestamp => Time.at(t).to_datetime,
+               :open      => o,
+               :high      => h,
+               :low       => l,
+               :close     => c,
+               :volume    => vol}
+            }
+          }.flatten.compact
+        end
+      end
+    end # module Parsers
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/parsers/validator.rb

@@ -0,0 +1,25 @@
+module XRBP
+  module Model
+    # @private
+    module Parsers
+      # Validator list data parser
+      #
+      # @private
+      class Validator < PluginBase
+        def parser_priority
+          0
+        end
+
+        def parse_result(res, req)
+          JSON.parse(res)["validators"].collect { |v|
+            id = v["validation_public_key"]
+            next nil unless id
+
+            {:id     => id,
+             :domain => v["domain"]}
+          }.compact
+        end
+      end # class ValidatorParser
+    end # module Parsers
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/validator.rb

@@ -0,0 +1,24 @@
+require_relative './parsers/validator'
+
+module XRBP
+  module Model
+    class Validator < Base
+      extend Base::ClassMethods
+
+      # Retrieve list of validators via WebClient::Connection
+      #
+      # @param opts [Hash] options to retrieve validator list with
+      # @option opts [WebClient::Connection] :connection Connection
+      #   to use to retrieve validator list
+      def self.all(opts={})
+        set_opts(opts)
+        connection.url = "https://data.ripple.com/v2/network/validators/"
+
+        connection.add_plugin :result_parser     unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::Validator unless connection.plugin?(Parsers::Validator)
+
+        connection.perform
+      end
+    end # class Validator
+  end # module Model
+end # module XRBP

data/lib/xrbp/plugins.rb

@@ -0,0 +1,6 @@
+require_relative './plugins/base'
+require_relative './plugins/has_plugin'
+require_relative './plugins/plugin_registry'
+
+require_relative './plugins/result_parser'
+require_relative './plugins/has_result_parsers'

data/lib/xrbp/plugins/base.rb

@@ -0,0 +1,10 @@
+module XRBP
+  # Base plugin definition, common logic shared by all connection plugins.
+  class PluginBase
+    attr_accessor :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+  end # class PluginBase
+end # module XRBP

data/lib/xrbp/plugins/has_plugin.rb

@@ -0,0 +1,45 @@
+module XRBP
+  # Helper mixin provding plugin management capabilities.
+  #
+  # @private
+  module HasPlugin
+    # should be overridden
+    def plugin_namespace
+      raise
+    end
+
+    def plugins
+      @plugins ||= []
+    end
+
+    def add_plugin(*plgs)
+      plgs.each { |plg|
+        plg = plugin_namespace.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)
+      clss = plugins.collect { |plg| plg.class }
+       cls = plugin_namespace.plugins[plg]
+      clss.include?(plg) || clss.include?(cls)
+    end
+
+    def plugin(plg)
+       cls = plugin_namespace.plugins[plg]
+       plugins.find { |_plg|
+         (plg.is_a?(Class) && _plg.kind_of?(plg)) ||
+         (cls.is_a?(Class) && _plg.class.kind_of?(cls))
+       }
+    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 XRBP

data/lib/xrbp/plugins/has_result_parsers.rb

@@ -0,0 +1,27 @@
+module XRBP
+  # Helper mixing providing result parser management capabilities.
+  #
+  # @private
+  module HasResultParsers
+    def parsing_plugins
+      raise
+    end
+
+    def parse_result(res, req)
+      _res = res
+
+      prioritized = parsing_plugins.select { |p|
+        p != self && p.respond_to?(:parse_result)
+
+      }.sort { |p1, p2|
+        (p1.respond_to?(:parser_priority) ? p1.parser_priority : 1) <=>
+        (p2.respond_to?(:parser_priority) ? p2.parser_priority : 1)
+      }
+
+      prioritized.each { |plg|
+        _res = plg.parse_result(_res, req)
+      }
+      _res
+    end
+  end # module HasResultParsers
+end # module XRBP

data/lib/xrbp/plugins/plugin_registry.rb

@@ -0,0 +1,20 @@
+module XRBP
+  # Helper mixin providing list of plugins.
+  #
+  # @private
+  module PluginRegistry
+    module ClassMethods
+      def plugins
+        @plugins ||= {}
+      end
+
+      def register_plugin(label, cls)
+        plugins[label] = cls
+      end
+    end # module ClassMethods
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end # module PluginRegistry
+end # module XRBP

data/lib/xrbp/plugins/result_parser.rb

@@ -0,0 +1,19 @@
+module XRBP
+  # Result Parser plugin base class, allows request results
+  # to be converted before returning / invoking callback.
+  class ResultParserBase < PluginBase
+    attr_accessor :parser
+
+    def added
+      plugin = self
+      connection.define_instance_method(:parse_results) do |&bl|
+        plugin.parser = bl
+      end
+    end
+
+    def parse_result(res, req)
+      return res unless parser
+      parser.call(res, req)
+    end
+  end # class ResultParserBase
+end # module XRBP

data/lib/xrbp/terminatable.rb

@@ -0,0 +1,19 @@
+module XRBP
+  # Helper mixin facilitating controlled termination of
+  # asynchronous components.
+  #
+  # @private
+  module Terminatable
+    def terminate_queue
+      @terminate_queue ||= Queue.new
+    end
+
+    def terminate?
+      !!terminate_queue.pop_or_nil
+    end
+
+    def terminate!
+      terminate_queue << true
+    end
+  end
+end

data/lib/xrbp/thread_registry.rb

@@ -0,0 +1,22 @@
+require 'concurrent'
+
+module XRBP
+  # Helper mixin providing internal thread management.
+  #
+  # @private
+  module ThreadRegistry
+    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
+  end # module ThreadRegistry
+end # module XRBP

data/lib/xrbp/version.rb

@@ -1,3 +1,3 @@
 module XRBP
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end # module XRBP

data/lib/xrbp/webclient.rb

@@ -0,0 +1,2 @@
+require 'xrbp/webclient/connection'
+require 'xrbp/webclient/plugins'

data/lib/xrbp/webclient/connection.rb

@@ -0,0 +1,100 @@
+require 'curb'
+require_relative '../thread_registry'
+
+module XRBP
+  module WebClient
+    # HTTP interface, use Connection to perform web requests.
+    #
+    # @example retrieve data from the web
+    #   connection = WebClient::Connection.new
+    #   connection.url = "https://devnull.network"
+    #   connection.perform
+    class Connection
+      include EventEmitter
+      include HasPlugin
+      include HasResultParsers
+      include ThreadRegistry
+
+      DELEGATED_METHODS = [:url=,
+                           :timeout=,
+                           :ssl_verify_peer=,
+                           :ssl_verify_host=]
+
+      # @private
+      def plugin_namespace
+        WebClient
+      end
+
+      # @private
+      def parsing_plugins
+        plugins
+      end
+
+      # Return current url
+      def url
+        c.url
+      end
+
+      # delegated methods
+      DELEGATED_METHODS.each { |m|
+        define_method(m) do |v|
+          c.send(m, v)
+        end
+      }
+
+      def initialize(url=nil)
+        self.url = url
+        @force_quit = false
+
+        yield self if block_given?
+      end
+
+      def force_quit?
+        @force_quit
+      end
+
+      # Immediate terminate outstanding requests
+      def force_quit!
+        @force_quit = true
+        wake_all
+        # TODO immediate terminate outstanding requests
+      end
+
+      private
+
+      def c
+        @curl ||= Curl::Easy.new
+      end
+
+      def handle_error
+        plugins.select { |plg|
+          plg.respond_to?(:handle_error)
+        }.last&.handle_error
+      end
+
+      public
+
+      # Execute web request, retrieving results and returning
+      def perform
+        # TODO fault tolerance plugins:
+        #        configurable timeout,
+        #        round-robin urls,
+        #        redirect handling, etc
+        begin
+          c.perform
+        rescue => e
+          emit :error, e
+          return handle_error
+        end
+
+        if c.response_code != 200
+          emit :http_error, c.response_code
+          return handle_error
+        end
+
+        emit :success, c.body_str
+        parse_result(c.body_str, c)
+      end
+    end # class Connection
+  end # module WebClient
+end # module XRBP