ciri 0.0.0

data/lib/ciri/devp2p/actor.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require 'logger'
+
+module Ciri
+  module DevP2P
+
+    # simple actor model implementation
+    # Example:
+    #
+    #   class Hello
+    #     include Actor
+    #
+    #     def say_hello
+    #       puts 'hello world'
+    #       'hello world'
+    #     end
+    #   end
+    #
+    #   actor = Hello.new
+    #   # start actor loop
+    #   actor.start
+    #   # push message to actor inbox
+    #   actor << :say_hello
+    #   # push message and wait until get response
+    #   actor.call(:say_hello).value
+    #
+    #   # raise error
+    #   actor.call(:hello).value # NoMethodError
+    #
+    #   # stop actor
+    #   actor.send_stop
+    #   actor.wait
+    #
+    module Actor
+
+      LOGGER = Logger.new(STDERR, datetime_format: '%Y-%m-%d %H:%M:%S', level: Logger::INFO)
+
+      # future, use this to wait actor msg respond
+      class Future
+        def initialize
+          @value = nil
+          @done = false
+        end
+
+        def value=(val)
+          if @done
+            raise RuntimeError.new('future value duplicated set')
+          end
+          @done = true
+          @queue << :done if @queue
+          @value = val
+        end
+
+        def value
+          loop do
+            if @done
+              return @value
+            elsif @error
+              raise @error
+            else
+              queue.pop
+            end
+          end
+        end
+
+        def raise_error(error)
+          error.set_backtrace(caller) if error.backtrace.nil?
+          @error = error
+          @queue << :error if @queue
+        end
+
+        private
+        def queue
+          @queue ||= Queue.new
+        end
+      end
+
+      class Error < StandardError
+      end
+
+      # stop actor
+      class StopError < Error
+      end
+
+      class StateError < Error
+      end
+
+      attr_accessor :executor
+
+      def initialize(executor: nil)
+        @inbox = Queue.new
+        @executor = executor
+        @future = Future.new
+        @running = false
+      end
+
+      # async call
+      def enqueue(method, *args)
+        self << [method, *args]
+      end
+
+      def <<(args)
+        @inbox << args
+      end
+
+      # sync call, push msg to inbox, and return future
+      #
+      # Example:
+      #   future = actor.call(:result) # future
+      #   future.value # blocking and wait for result
+      #
+      def call(method, *args)
+        future = Future.new
+        self << [future, method, *args]
+        future
+      end
+
+      # start actor
+      def start
+        raise Error.new("must set executor before start") unless executor
+
+        @running = true
+        executor.post do
+          start_loop
+        end
+      end
+
+      # send stop to actor
+      #
+      # Example:
+      #   actor.send_stop
+      #   # wait for actor actually stopped
+      #   actor.wait
+      #
+      def send_stop
+        self << [:raise_error, StopError.new]
+      end
+
+      # wait until an error occurs
+      def wait
+        raise StateError.new('actor not running!') unless @running
+        @future.value
+      end
+
+      # start loop
+      def start_loop
+        loop_callback do |wait_message: true|
+          # check inbox
+          next Thread.pass if @inbox.empty? && !wait_message
+          msg = @inbox.pop
+
+          # extract sync or async call
+          future = nil
+          method, *args = msg
+          if method.is_a?(Future)
+            future = method
+            method, *args = args
+          end
+          begin
+            val = send(method, *args)
+          rescue StandardError => e
+            future.raise_error(e) if future
+            raise
+          end
+          # if future not nil, set value
+          future.value = val if future
+        end while true
+
+      rescue StopError
+        # actor stop
+        @future.value = nil
+      rescue StandardError => e
+        @future.raise_error e
+        LOGGER.error("Actor #{self}") {"#{e}\n#{e.backtrace.join("\n")}"}
+      ensure
+        @running = false
+      end
+
+      # allow inject callback into actor loop
+      # Example:
+      #
+      #   class A
+      #     include Actor
+      #
+      #     def loop_callback
+      #       # before handle msg
+      #       yield
+      #       # after handle msg
+      #     end
+      #   end
+      #
+      def loop_callback
+        yield
+      end
+
+      def raise_error(e)
+        raise e
+      end
+    end
+
+  end
+end

data/lib/ciri/devp2p/peer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require_relative 'rlpx'
+require_relative 'actor'
+require_relative 'protocol_io'
+
+module Ciri
+  module DevP2P
+
+    # represent a connected remote node
+    class Peer
+
+      class DiscoverError < StandardError
+      end
+      class UnknownMessageCodeError < StandardError
+      end
+
+      include Actor
+
+      attr_reader :connection
+
+      def initialize(connection, handshake, protocols)
+        @connection = connection
+        @handshake = handshake
+        @protocols = protocols
+        @protocol_io_hash = make_protocol_io_hash(protocols, handshake.caps, connection)
+        super()
+      end
+
+      def node_id
+        @node_id ||= RLPX::NodeID.from_raw_id(@handshake.id)
+      end
+
+      # start peer
+      # handle msg, handle sub protocols
+      def start
+        executor.post {read_loop}
+        start_protocols
+        super
+      end
+
+      # read and handle msg
+      def read_loop
+        loop do
+          msg = connection.read_msg
+          msg.received_at = Time.now
+          handle(msg)
+        end
+      rescue StandardError => e
+        self << [:raise_error, e]
+      end
+
+      def start_protocols
+        @protocols.each do |protocol|
+          protocol.start.(self, @protocol_io_hash[protocol.name])
+        end
+      end
+
+      def handle(msg)
+        if msg.code == RLPX::MESSAGES[:ping]
+          #TODO send pong
+        elsif msg.code == RLPX::MESSAGES[:discover]
+          reason = RLP.decode_with_type(msg.payload, Integer)
+          raise DiscoverError.new("receive error discovery message, reason: #{reason}")
+        else
+          # send msg to sub protocol
+          if (protocol_io = find_protocol_io_by_msg_code(msg.code)).nil?
+            raise UnknownMessageCodeError.new("can't find protocol with msg code #{msg.code}")
+          end
+          protocol_io.msg_queue << msg
+        end
+      end
+
+      private
+      def find_protocol_io_by_msg_code(code)
+        @protocol_io_hash.values.find do |protocol_io|
+          offset = protocol_io.offset
+          protocol = protocol_io.protocol
+          code >= offset && code < offset + protocol.length
+        end
+      end
+
+      # return protocol_io_hash
+      # handle multiple sub protocols upon one io
+      def make_protocol_io_hash(protocols, caps, io)
+        # sub protocol offset
+        offset = RLPX::BASE_PROTOCOL_LENGTH
+        result = {}
+        # [name, version] as key
+        protocols_hash = protocols.map {|protocol| [[protocol.name, protocol.version], protocol]}.to_h
+        sorted_caps = caps.sort_by {|c| [c.name, c.version]}
+
+        sorted_caps.each do |cap|
+          protocol = protocols_hash[[cap.name, cap.version]]
+          next unless protocol
+          # ignore same name old protocols
+          if (old = result[cap.name])
+            result.delete(cap.name)
+            offset -= old.protocol.length
+          end
+          result[cap.name] = ProtocolIO.new(protocol, offset, io)
+          # move offset, to support next protocol
+          offset += protocol.length
+        end
+        result
+      end
+    end
+
+  end
+end

data/lib/ciri/devp2p/protocol.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require_relative 'actor'
+
+module Ciri
+  module DevP2P
+
+    # protocol represent DevP2P sub protocols
+    class Protocol
+
+      attr_reader :name, :version, :length
+      attr_accessor :node_info, :peer_info, :start
+
+      def initialize(name:, version:, length:)
+        @name = name
+        @version = version
+        @length = length
+      end
+    end
+
+  end
+end

data/lib/ciri/devp2p/protocol_io.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2018, by Jiang Jinyang. <https://justjjy.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+require_relative 'actor'
+require_relative 'rlpx/message'
+
+module Ciri
+  module DevP2P
+
+    # send/read sub protocol msg
+    class ProtocolIO
+
+      class Error < StandardError
+      end
+      class InvalidMessageCode < Error
+      end
+
+      attr_reader :protocol, :offset, :msg_queue
+
+      def initialize(protocol, offset, frame_io)
+        @protocol = protocol
+        @offset = offset
+        @frame_io = frame_io
+        @msg_queue = Queue.new
+      end
+
+      def send_data(code, data)
+        msg = RLPX::Message.new(code: code, size: data.size, payload: data)
+        write_msg(msg)
+      end
+
+      def write_msg(msg)
+        raise InvalidMessageCode, "code #{code} must less than length #{protocol.length}" if msg.code > protocol.length
+        msg.code += offset
+        @frame_io.write_msg(msg)
+      end
+
+      def read_msg
+        msg = msg_queue.pop
+        msg.code -= offset
+        msg
+      end
+    end
+
+  end
+end