xrbp 0.0.1

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

@@ -0,0 +1,141 @@
+module XRBP
+  module WebSocket
+    module Plugins
+      # Dispatch messages & wait for responses (w/ optional timeout)
+      class MessageDispatcher
+        attr_reader :connection, :messages
+        attr_accessor :message_timeout
+
+        DEFAULT_TIMEOUT = 10
+
+        def initialize(connection)
+          @connection = connection
+          @message_timeout = DEFAULT_TIMEOUT
+          @messages = []
+        end
+
+        def added
+          plugin = self
+
+          connection.define_instance_method(:message_timeout=) do |t|
+            plugin.message_timeout = t
+
+            self.plugins.find { |plg|
+              plg.kind_of?(MessageDipsatcher)
+            }.message_timeout = t if self.kind_of?(MultiConnection)
+          end
+
+          connection.define_instance_method(:msg) do |msg, &bl|
+            return next_connection.msg msg, &bl if self.kind_of?(MultiConnection)
+
+            msg = Message.new(msg) unless msg.kind_of?(Message)
+            msg.connection = self
+            msg.bl = bl if bl
+
+            unless self.open?
+              msg.bl.call nil if msg.bl
+              return nil
+            end
+
+            plugin.messages << msg
+
+            send_data msg.to_s
+
+            return nil if bl
+            msg.wait
+            msg.result
+          end
+
+          connection.on :close do
+            plugin.messages.each { |msg|
+              plugin.cancel_message(msg)
+            }
+          end unless connection.kind_of?(MultiConnection)
+        end
+
+        # Should be overridden in subclass return
+        # request message & formatted response
+        # given raw response
+        def match_message(msg)
+          nil
+        end
+
+        # Return bool if message,response is read to be unlocked / returned to client.
+        # Allows other plugins to block message unlocking
+        def unlock!(req, res)
+          !connection.plugins.any? { |plg|
+            plg != self && plg.respond_to?(:unlock!) && !plg.unlock!(req, res)
+          }
+        end
+
+        # Allows plugins to convert results
+        def parse_result(res)
+          connection.plugins.each { |plg|
+            res = plg.parse_result(res) if plg != self && plg.respond_to?(:parse_result)
+          }
+          res
+        end
+
+        def message(res)
+          req, res = match_message(res)
+          return unless req
+          messages.delete(req)
+
+          return unless unlock!(req, res)
+
+          begin
+            res = parse_result(res)
+          rescue Exception => e
+            if conn = connection.next_connection(req.connection)
+              conn.msg(req, &req.bl)
+              return
+
+            else
+              res = nil
+            end
+          end
+
+          req.bl.call(res)
+        end
+
+        def cancel_message(msg)
+          connection.state_mutex.synchronize {
+            messages.delete(msg)
+            msg.signal
+          }
+        end
+
+        def opened
+          @timeout_thread = Thread.new {
+            # XXX remove force_quit? condition check from this loop,
+            #     so we're sure messages always timeout, even on force quit.
+            #     Always ensure close! is called after websocket is no longer
+            #     being used!
+            until connection.closed? || Thread.current != @timeout_thread
+              now = Time.now
+              tmsgs = Array.new(messages)
+              tmsgs.each { |msg|
+                if now - msg.time > @message_timeout
+                  connection.emit :timeout, msg
+                  cancel_message(msg)
+
+                  # XXX manually close the connection as
+                  #     a broken pipe will not stop websocket polling
+                  connection.close!
+                end
+              }
+
+              connection.rsleep(0.1)
+            end
+          }
+        end
+
+        def closed
+          @timeout_thread.join unless @timeout_thread == Thread.current
+        end
+      end # class MessageDispatcher
+
+      WebSocket.register_plugin :message_dispatcher, MessageDispatcher
+    end # module Plugins
+  end # module WebSocket
+end # module XRBP

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

@@ -0,0 +1,31 @@
+module XRBP
+  module WebSocket
+    module Plugins
+      class ResultParser
+        attr_accessor :parser, :connection
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def added
+          plugin = self
+          connection.define_instance_method(:parse_results) do |&bl|
+            plugin.parser = bl
+
+            self.connections.each { |conn|
+              conn.parse_results &bl
+            } if self.kind_of?(MultiConnection)
+          end
+        end
+
+        def parse_result(res)
+          return res unless parser
+          parser.call(res)
+        end
+      end # class ResultParser
+
+      WebSocket.register_plugin :result_parser, ResultParser
+    end # module Plugins
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket/plugins.rb

@@ -0,0 +1,18 @@
+module XRBP
+  module WebSocket
+    def self.plugins
+      @plugins ||= {}
+    end
+
+    def self.register_plugin(label, cls)
+      plugins[label] = cls
+    end
+  end # module WebSocket
+end # module XRPB
+
+require_relative './plugins/autoconnect'
+require_relative './plugins/connection_timeout'
+require_relative './plugins/message_dispatcher'
+require_relative './plugins/command_dispatcher'
+require_relative './plugins/command_paginator'
+require_relative './plugins/result_parser'

data/lib/xrbp/websocket/socket.rb

@@ -0,0 +1,109 @@
+require 'uri'
+require 'socket'
+require 'openssl'
+
+module XRBP
+  module WebSocket
+    class Socket
+      DEFAULT_PORTS = {:ws    => 80,
+                       :http  => 80,
+                       :wss   => 443,
+                       :https => 443}
+
+
+      attr_reader :connection, :socket, :pipe_broken
+
+      def options
+        connection.options
+      end
+
+      def initialize(connection)
+        @connection = connection
+        @pipe_broken = false
+      end
+
+      def connect
+        uri = URI.parse connection.url
+        host = uri.host
+        port = uri.port || DEFAULT_PORTS[uri.scheme.intern]
+
+        @socket = TCPSocket.new(host, port)
+        socket.setsockopt(::Socket::IPPROTO_TCP, ::Socket::TCP_NODELAY, 1)
+
+        init_ssl_socket if ['https', 'wss'].include? uri.scheme
+      end
+
+      def init_ssl_socket
+        ssl_context = options[:ssl_context] || begin
+          ctx = OpenSSL::SSL::SSLContext.new
+          ctx.ssl_version = options[:ssl_version] || 'SSLv23'
+
+          # use VERIFY_PEER for verification:
+          ctx.verify_mode = options[:verify_mode] ||
+                              OpenSSL::SSL::VERIFY_NONE
+
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.set_default_paths
+          ctx.cert_store = cert_store
+
+          ctx
+        end
+
+        @socket = ::OpenSSL::SSL::SSLSocket.new(socket, ssl_context)
+        socket.connect
+      end
+
+      ###
+
+      def close
+        socket.close if socket
+      end
+
+      def write(data)
+        socket.write data
+      end
+
+      def write_nonblock(data)
+        begin
+          socket.write_nonblock(data)
+
+        rescue IO::WaitReadable
+          IO.select([socket]) # OpenSSL needs to read internally
+          retry
+
+        rescue IO::WaitWritable, Errno::EINTR
+          IO.select(nil, [socket])
+          retry
+
+        rescue Errno::EPIPE => e
+          @pipe_broken = true
+          raise
+
+        rescue OpenSSL::SSL::SSLError => e
+          @pipe_broken = true
+          raise
+        end
+      end
+
+      def read_next(dest)
+        begin
+          read_sockets, _, _ = IO.select([socket], nil, nil, 10)
+
+          if read_sockets && read_sockets[0]
+            dest << socket.read_nonblock(1024)
+
+            if socket.respond_to?(:pending) # SSLSocket
+              dest << socket.read(socket.pending) while socket.pending > 0
+            end
+          end
+        rescue IO::WaitReadable
+          # No op
+
+        rescue IO::WaitWritable
+          IO.select(nil, [socket])
+          retry
+        end
+      end
+    end # class Socket
+  end # module WebSocket
+end # module XRBP

data/lib/xrbp/websocket.rb

@@ -0,0 +1,15 @@
+require 'xrbp/websocket/socket'
+require 'xrbp/websocket/client'
+require 'xrbp/websocket/connection'
+
+require 'xrbp/websocket/multi/multi_connection'
+require 'xrbp/websocket/multi/round_robin'
+require 'xrbp/websocket/multi/prioritized'
+require 'xrbp/websocket/multi/fallback'
+require 'xrbp/websocket/multi/parallel'
+
+require 'xrbp/websocket/message'
+require 'xrbp/websocket/command'
+require 'xrbp/websocket/plugins'
+
+require 'xrbp/websocket/cmds'

data/lib/xrbp.rb

@@ -0,0 +1,5 @@
+require 'event_emitter'
+
+require 'xrbp/websocket'
+require 'xrbp/model'
+require 'xrbp/network'

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: xrbp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dev Null Productions
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: event_emitter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: Ruby XRP Tools
+email:
+- devnullproductions@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- examples/autoconnect_timeout.rb
+- examples/cmd.rb
+- examples/ledger.rb
+- examples/ledger_multi_subscribe.rb
+- examples/ledger_subscribe.rb
+- examples/multi.rb
+- examples/paginate.rb
+- examples/prioritized.rb
+- examples/round_robin.rb
+- examples/websocket.rb
+- lib/xrbp.rb
+- lib/xrbp/model.rb
+- lib/xrbp/model/account.rb
+- lib/xrbp/model/base.rb
+- lib/xrbp/model/ledger.rb
+- lib/xrbp/network.rb
+- lib/xrbp/network/nodes.rb
+- lib/xrbp/version.rb
+- lib/xrbp/websocket.rb
+- lib/xrbp/websocket/client.rb
+- lib/xrbp/websocket/cmds.rb
+- lib/xrbp/websocket/cmds/account_info.rb
+- lib/xrbp/websocket/cmds/account_lines.rb
+- lib/xrbp/websocket/cmds/account_objects.rb
+- lib/xrbp/websocket/cmds/account_offers.rb
+- lib/xrbp/websocket/cmds/account_tx.rb
+- lib/xrbp/websocket/cmds/book_offers.rb
+- lib/xrbp/websocket/cmds/ledger.rb
+- lib/xrbp/websocket/cmds/ledger_entry.rb
+- lib/xrbp/websocket/cmds/paginated.rb
+- lib/xrbp/websocket/cmds/server_info.rb
+- lib/xrbp/websocket/cmds/subscribe.rb
+- lib/xrbp/websocket/command.rb
+- lib/xrbp/websocket/connection.rb
+- lib/xrbp/websocket/has_plugin.rb
+- lib/xrbp/websocket/message.rb
+- lib/xrbp/websocket/multi/fallback.rb
+- lib/xrbp/websocket/multi/multi_connection.rb
+- lib/xrbp/websocket/multi/parallel.rb
+- lib/xrbp/websocket/multi/prioritized.rb
+- lib/xrbp/websocket/multi/round_robin.rb
+- lib/xrbp/websocket/plugins.rb
+- lib/xrbp/websocket/plugins/autoconnect.rb
+- lib/xrbp/websocket/plugins/command_dispatcher.rb
+- lib/xrbp/websocket/plugins/command_paginator.rb
+- lib/xrbp/websocket/plugins/connection_timeout.rb
+- lib/xrbp/websocket/plugins/message_dispatcher.rb
+- lib/xrbp/websocket/plugins/result_parser.rb
+- lib/xrbp/websocket/socket.rb
+homepage: https://devnull.network
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Helper module to read and write data from the XRP Ledger and related resources!
+test_files: []