xrbp 0.0.1 → 0.1.0

data/lib/xrbp/dsl/validators.rb

@@ -0,0 +1,10 @@
+module XRBP
+  module DSL
+    # Return list of all validators
+    #
+    # @return [Array<Hash>] list of validators retrieved
+    def validators
+      Model::Validator.all :connection => webclient
+    end
+  end # module DSL
+end # module XRBP

data/lib/xrbp/dsl/webclient.rb

@@ -0,0 +1,8 @@
+module XRBP
+  module DSL
+    # Client which may be used to access HTTP resources
+    def webclient
+      @webclient ||= WebClient::Connection.new
+    end
+  end # module DSL
+end # module XRBP

data/lib/xrbp/dsl/websocket.rb

@@ -0,0 +1,28 @@
+module XRBP
+  module DSL
+    # Default websocket endpoints. Override to specify
+    # different ones.
+    def websocket_endpoints
+      ["wss://s1.ripple.com:443", "wss://s2.ripple.com:443"]
+    end
+
+    # Client which may be used to access websocket endpoints.
+    #
+    # By default a RoundRobin strategy will be used to cycle
+    # through specified endpoints.
+    def websocket
+      @websocket ||= WebSocket::RoundRobin.new *websocket_endpoints
+    end
+
+    # Register a callback to be invoked when messages are received
+    # via websocket connections
+    def websocket_msg(&bl)
+      websocket.on :message, &bl
+    end
+
+    # Block until all websocket connections are closed
+    def websocket_wait
+      websocket.wait_for_close
+    end
+  end # module DSL
+end # module XRBP

data/lib/xrbp/model.rb

@@ -1,3 +1,7 @@
 require_relative './model/base'
 require_relative './model/ledger'
 require_relative './model/account'
+require_relative './model/validator'
+require_relative './model/gateway'
+require_relative './model/market'
+require_relative './model/node'

data/lib/xrbp/model/account.rb

@@ -1,27 +1,168 @@
+require 'fileutils'
+require_relative './parsers/account'
+
 module XRBP
   module Model
     class Account < Base
       extend Base::ClassMethods
 
+     DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
+
       attr_accessor :id
 
-      def self.create(opts={})
+      # Local data cache location
+      def self.cache
+        @cache ||= File.expand_path("~/.xrbp/accounts/")
+      end
+
+      # All cached accounts
+      def self.cached
+        Dir.glob("#{cache}/*").collect { |f|
+          next nil if f == "#{cache}marker" ||
+                      f == "#{cache}start"
+          begin
+            JSON.parse(File.read(f))
+          rescue
+            nil
+          end
+        }.flatten.compact
       end
 
+      # TODO invoke gen account command via websocket
+      #def self.create(opts={})
+      #end
+
+      # TODO 'parallel accounts' method,
+      #   - split period between Genesis and Time.now into
+      #     N-segments (of configurable length: hours, days,
+      #     months, etc)
+      #   - parallel retrieve segments specifying start param
+      #     & following markers until data is no longer
+      #     in-domain
+      #   - emit :account signal w/ each account during process
+      #     & reassemble complete set after
+
+      # Retrieve all accounts via WebClient::Connection
+      #
+      # @param opts [Hash] options to retrieve accounts with
+      # @option opts [WebClient::Connection] :connection Connection
+      #   to use to retrieve accounts
+      def self.all(opts={})
+        set_opts(opts)
+        FileUtils.mkdir_p(cache) unless File.exist?(cache)
+
+        # start at last marker
+        marker = File.exist?("#{cache}/marker") ?
+                   File.read("#{cache}/marker") : nil
+
+        # load start time, if set
+        start = File.exist?("#{cache}/start") ?
+                  File.read("#{cache}/start") :
+           GENESIS_TIME.strftime(DATE_FORMAT)
+
+        # Parse results
+        connection.add_plugin :result_parser       unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::AccountInfo unless connection.plugin?(Parsers::AccountInfo)
+
+        # Retrieve data until complete
+        accounts = []
+        finished = false
+        until finished || connection.force_quit?
+          # HTTP request
+          connection.url = "https://data.ripple.com/v2/accounts/?"\
+                             "start=#{start}&limit=1000&marker=#{marker}"
+          res = connection.perform
+
+          # Cache data
+          cache_file = "#{cache}/#{marker || "genesis"}"
+          File.write(cache_file, res[:accounts].to_json)
+
+          # Emit signal
+          res[:accounts].each { |acct|
+            break if connection.force_quit?
+            connection.emit :account, acct
+          }
+
+          break if connection.force_quit?
+
+          marker = res[:marker]
+          accounts += res[:accounts]
+
+          # Store state, eval exit condition
+          File.write("#{cache}/marker", marker.to_s)
+          finished = !marker
+        end
+
+        # Store state for next run
+        File.write("#{cache}/start",
+                   accounts.last[:inception]) unless marker
+
+        accounts
+      end
+
+      # Retrieve latest account using specified WebClient::Connection
+      #
+      # @param opts [Hash] options to retrieve account with
+      # @option opts [WebClient::Connection] :connection Connection
+      #   to use to retrieve account
+      def self.latest(opts={})
+        set_opts(opts)
+
+        connection.add_plugin :result_parser       unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::AccountInfo unless connection.plugin?(Parsers::AccountInfo)
+
+        connection.url = "https://data.ripple.com/v2/accounts/?"\
+                           "descending=true&limit=1000"
+        res = connection.perform
+        res[:accounts].first
+      end
+
+      ###
+
+      # Initialize new Account instance
+      #
+      # @param opts [Hash] options to initialize account with
+      # @option opts [String] :id id of account
+      #   to use to retrieve account
       def initialize(opts={})
         @id = opts[:id]
         super(opts)
       end
 
+      # Retrieve account info via WebSocket::Connection
+      #
+      # @param opts [Hash] options to retrieve account info with
+      # @option opts [WebSocket::Connection] :connection Connection
+      #   to use to retrieve account info
       def info(opts={}, &bl)
         set_opts(opts)
         connection.cmd(WebSocket::Cmds::AccountInfo.new(id, full_opts), &bl)
       end
 
+      # Retrieve account objects via WebSocket::Connection
+      #
+      # @param opts [Hash] options to retrieve account objects with
+      # @option opts [WebSocket::Connection] :connection Connection
+      #   to use to retrieve account objects
       def objects(opts={}, &bl)
         set_opts(opts)
         connection.cmd(WebSocket::Cmds::AccountObjects.new(id, full_opts), &bl)
       end
+
+      # Retrieve account username via WebClient::Connection
+      #
+      # @param opts [Hash] options to retrieve account username with
+      # @option opts [WebClient::Connection] :connection Connection
+      #   to use to retrieve account username
+      def username(opts={}, &bl)
+        set_opts(opts)
+        connection.url = "https://id.ripple.com/v1/authinfo?username=#{id}"
+
+        connection.add_plugin :result_parser           unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::AccountUsername unless connection.plugin?(Parsers::AccountUsername)
+
+        connection.perform
+      end
     end # class Account
   end # module Model
 end # module XRBP

data/lib/xrbp/model/base.rb

@@ -1,5 +1,6 @@
 module XRBP
   module Model
+    # Base model definition, provides common logic to set connection & opts.
     class Base
       module ClassMethods
         attr_accessor :opts, :connection

data/lib/xrbp/model/gateway.rb

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

data/lib/xrbp/model/ledger.rb

@@ -10,14 +10,43 @@ module XRBP
         super(opts)
       end
 
+      # Retreive specified ledger via WebSocket::Connection
+      #
+      # @param opts [Hash] options to retrieve ledger with
+      # @option opts [WebSocket::Connection] :connection Connection
+      #   to use to retrieve ledger
       def sync(opts={}, &bl)
         set_opts(opts)
         connection.cmd(WebSocket::Cmds::Ledger.new(id, full_opts), &bl)
       end
 
+      # Subscribe to ledger stream via WebSocket::Connection
+      #
+      # @param opts [Hash] options to subscribe to ledger stream with
+      # @option opts [WebSocket::Connection] :connection Connection
+      #   to use to subscribe to ledger stream
       def self.subscribe(opts={}, &bl)
         set_opts(opts)
-        connection.cmd(WebSocket::Cmds::Subscribe.new(:streams => ["ledger"]), &bl)
+        conn = connection
+        conn.cmd(WebSocket::Cmds::Subscribe.new(:streams => ["ledger"]), &bl)
+        conn.on :message do |*args|
+          c,msg = args.size > 1 ? [args[0], args[1]] :
+                                  [nil,     args[0]]
+
+          begin
+            i = JSON.parse(msg.to_s)
+            if i["ledger_hash"] &&
+               i["ledger_index"]
+              if c
+                conn.emit :ledger, c, i
+              else
+                conn.emit :ledger, i
+                conn.parent.emit :ledger, conn, i if conn.parent
+              end
+            end
+          rescue
+          end
+        end
       end
     end # class Ledger
   end # module Model

data/lib/xrbp/model/market.rb

@@ -0,0 +1,52 @@
+require_relative './parsers/market'
+require_relative './parsers/quote'
+
+module XRBP
+  module Model
+    class Market < Base
+      extend Base::ClassMethods
+      # TODO plugabble system to pull in markets from other sources
+
+      # Retrieve list of markets via WebClient::Connection
+      #
+      # @param opts [Hash] options to retrieve market list with
+      # @option opts [WebClient::Connection] :connection Connection
+      #   to use to retrieve market list
+      def self.all(opts={})
+        set_opts(opts)
+        connection.url = "https://api.cryptowat.ch/assets/xrp"
+
+        connection.add_plugin :result_parser  unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::Market unless connection.plugin?(Parsers::Market)
+
+        connection.perform
+      end
+
+      attr_accessor :route
+
+      def initialize(opts={})
+        set_opts(opts)
+      end
+
+      def set_opts(opts={})
+        super opts
+        @route = opts[:route] if opts[:route]
+      end
+
+      # Retrieve list of quotes for market via WebClient::Connection
+      #
+      # @param opts [Hash] options to retrieve quotes with
+      # @option opts [WebClient::Connection] :connection Connection
+      #   to use to retrieve quotes
+      def quotes(opts={})
+        set_opts(opts)
+        connection.url = self.route
+
+        connection.add_plugin :result_parser unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::Quote unless connection.plugin?(Parsers::Quote)
+
+        connection.perform
+      end
+    end # class Market
+  end # module Model
+end # module XRBP

data/lib/xrbp/model/node.rb

@@ -0,0 +1,131 @@
+require 'uri'
+require 'resolv'
+
+require_relative './parsers/node'
+
+module XRBP
+  module Model
+    class Node < Base
+      extend Base::ClassMethods
+
+      DEFAULT_CRAWL_PORT = 51235
+
+      attr_accessor :ip, :port
+      attr_accessor :addr, :version, :uptime, :type
+
+      # Return unique node id
+      def id
+        "#{ip}:#{port}"
+      end
+
+      # Return node url
+      def url
+        "https://#{ip}:#{port}/crawl"
+      end
+
+      # Return bool indicating if this node is valid for crawling
+      def valid?
+        return false unless ip && port
+
+        # ensure no parsing errs
+        begin
+          # FIXME URI.parse is limiting our ability to traverse entire node-set,
+          #       some nodes are represented as IPv6 addresses which is throwing
+          #       things off.
+          URI.parse(url)
+        rescue
+          false
+        end
+
+        true
+      end
+
+      def ==(o)
+        ip == o.ip && port == o.port
+      end
+
+      # Return new node from the specified url
+      #
+      # @param url [String] node url
+      # @return [Node] new node instance
+      def self.parse_url(url)
+        n = new
+
+        uri    = URI.parse(url)
+        n.ip   = Resolv.getaddress(uri.host)
+        n.port = uri.port
+
+        n
+      end
+
+      # Return new node from the specified peer object
+      #
+      # @param p [Hash] peer data
+      # @return [Node] new node instance
+      def self.from_peer(p)
+        n = new
+
+        n.addr    = p["public_key"]
+        n.ip      = p["ip"]
+        n.port    = p["port"] || DEFAULT_CRAWL_PORT
+        n.version = p["version"].split("-").last
+        n.uptime  = p["uptime"]
+        n.type    = p["type"]
+
+        n
+      end
+
+      # Crawl nodes via WebClient::Connection
+      #
+      # @param opts [Hash] options to crawl nodes with
+      # @option opts [WebSocket::Connection] :connection Connection
+      #   to use to crawl nodes
+      # @option opts [Integer] :delay optional delay to wait between
+      #   crawl iterations
+      def self.crawl(start, opts={})
+        set_opts(opts)
+        delay = opts[:delay] || 1
+
+        queue = Array.new
+        queue << start
+
+        connection.add_plugin :result_parser     unless connection.plugin?(:result_parser)
+        connection.add_plugin Parsers::NodePeers unless connection.plugin?(Parsers::NodePeers)
+
+        connection.ssl_verify_peer = false
+        connection.ssl_verify_host = false
+
+        until connection.force_quit?
+          node = queue.shift
+          node = parse_url node unless node.is_a?(Node)
+
+          connection.emit :precrawl, node
+          connection.url = node.url
+
+          peers = connection.perform
+          if peers.nil? || peers.empty?
+            queue << node
+            connection.emit :crawlerr, node
+            connection.rsleep(delay) unless connection.force_quit?
+            next
+          end
+
+          connection.emit :peers, node, peers
+          peers.each { |peer|
+            break if connection.force_quit?
+
+            peer = Node.from_peer peer
+            next unless peer.valid? # skip unless valid
+
+            connection.emit :peer, node, peer
+            queue << peer unless queue.include?(peer)
+          }
+
+          queue << node
+          connection.emit :postcrawl, node
+          connection.rsleep(delay) unless connection.force_quit?
+        end
+      end
+    end
+  end # module Model
+end # module XRBP