devp2p 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a9119de12a32ac914f74a103d5544358404a241
-  data.tar.gz: 1f7107a8432d2a9b7a74c676623eeeceec717f42
+  metadata.gz: 7da6641d9e8596c7a5ef84501b60dba802a38c7d
+  data.tar.gz: eb5ae074cca21812736d03f67949648242482b87
 SHA512:
-  metadata.gz: 869067f4897deb649c694a535eedc8d5cee3a725625c3760a6a069f933cdb08c93d5d16141b9a10cdabba60238c472476e5f98c2a32dea4cddafeadd3d65046f
-  data.tar.gz: 8340dc9d8f31803e250ecfc859a9397f9f84e70ad80513fc6874e6a4b825c78d8b777689bb286bbceb8ea934b97b0f037e53933483e8fdbc18ae16f032fa95de
+  metadata.gz: 2580541428dc68edea68859e888e235c940637fe2219759d35a58ba3256d96d7de364a343c74935bf714b7c4f54c8be3fc1291e0a6d099bf32df38973c0678c2
+  data.tar.gz: 95f168e5a41dc87646a55dbc794a0cb64984fc8e10aef647f7b94fa09820f1cc6645bdb6e1b6fa625925d618df1b436a99aabc8a8d07611ca1f28f32a739a634

data/lib/devp2p.rb

@@ -1,16 +1,9 @@
 # -*- encoding : ascii-8bit -*-
 
+require 'concurrent'
 require 'block_logger'
-require 'celluloid/io'
-
 require 'rlp'
 
-#Celluloid.exception_handler do |ex|
-#  puts "!!!!! Exception raised in celluloid actor:"
-#  puts ex
-#  puts ex.backtrace[0,20].join("\n")
-#end
-
 module DEVp2p
   Logger = BlockLogger
 
@@ -22,36 +15,28 @@ end
 
 require 'devp2p/version'
 
-require 'devp2p/configurable'
-require 'devp2p/utils'
 require 'devp2p/exception'
+require 'devp2p/crypto'
+require 'devp2p/utils'
+require 'devp2p/configurable'
 
-require 'devp2p/control'
-require 'devp2p/base_service'
+require 'devp2p/app'
+require 'devp2p/service'
 require 'devp2p/wired_service'
 
-require 'devp2p/kademlia'
-require 'devp2p/discovery'
-
 require 'devp2p/sync_queue'
-
-require 'devp2p/packet'
 require 'devp2p/frame'
+require 'devp2p/packet'
 require 'devp2p/multiplexer'
-
-require 'devp2p/crypto'
-require 'devp2p/rlpx_session'
 require 'devp2p/multiplexed_session'
+require 'devp2p/rlpx_session'
 
-require 'devp2p/command'
-require 'devp2p/base_protocol'
+require 'devp2p/kademlia'
+require 'devp2p/discovery'
 require 'devp2p/connection_monitor'
+require 'devp2p/command'
+require 'devp2p/protocol'
 require 'devp2p/p2p_protocol'
-
-require 'devp2p/peer'
-require 'devp2p/peer_errors'
 require 'devp2p/peer_manager'
-
-require 'devp2p/base_app'
-require 'devp2p/app_helper'
-
+require 'devp2p/peer_errors'
+require 'devp2p/peer'

data/lib/devp2p/app.rb

@@ -0,0 +1,70 @@
+# -*- encoding : ascii-8bit -*-
+require 'hashie'
+
+module DEVp2p
+  class App
+    include Concurrent::Async
+
+    extend Configurable
+    add_config(
+      default_config: {
+        client_version_string: "ruby-devp2p #{VersionString}",
+        deactivated_services: []
+      }
+    )
+
+    attr :config, :services
+
+    def initialize(config=default_config)
+      super()
+
+      @config = Hashie::Mash.new(default_config).merge(config)
+      @registry = {}
+      @services = Hashie::Mash.new
+    end
+
+    def register_service(klass, *args)
+      raise ArgumentError, "service #{klass.name} already registered" if services.has_key?(klass.name)
+
+      logger.info "registering service", service: klass.name
+      @registry[klass.name] = [klass, args]
+      services[klass.name] = klass.new(*args)
+    end
+
+    def deregister_service(klass)
+      raise ArgumentError, "service #{klass.name} not registered" unless services.has_key?(klass.name)
+
+      logger.info "deregistering service", service: klass.name
+      services[klass.name].async.stop
+      services.delete klass.name
+      @registry.delete klass.name
+    end
+
+    def start
+      @registry.each do |name, (klass, args)|
+        services[name] ||= klass.new(*args)
+        services[name].async.start
+      end
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
+    end
+
+    def stop
+      services.keys.each do |name|
+        services[name].async.stop
+        services.delete name
+      end
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new 'app'
+    end
+
+  end
+end

data/lib/devp2p/command.rb

@@ -64,7 +64,7 @@ module DEVp2p
     # optionally implement create
     def create(proto, *args)
       options = args.last.is_a?(Hash) ? args.pop : {}
-      raise ArgumentError, "proto #{proto} must be protocol" unless proto.is_a?(BaseProtocol)
+      raise ArgumentError, "proto #{proto} must be protocol" unless proto.is_a?(Protocol)
       raise ArgumentError, "command structure mismatch" if !options.empty? && structure.instance_of?(RLP::Sedes::CountableList)
       options.empty? ? args : options
     end

data/lib/devp2p/connection_monitor.rb

@@ -6,7 +6,7 @@ module DEVp2p
   # monitors the connection by sending pings and checking pongs
   #
   class ConnectionMonitor
-    include Celluloid
+    include Concurrent::Async
 
     def initialize(proto)
       @proto = proto
@@ -28,8 +28,10 @@ module DEVp2p
       }
       @proto.receive_pong_callbacks.push(track_response)
 
-      monitor = Actor.current
-      @proto.receive_hello_callbacks.push(->(p, **kwargs) { monitor.start })
+      monitor = self
+      # FIXME: sleep 1 to make sure ConnectionMonitor start after connection of
+      # other protocols like ETHProtocol
+      @proto.receive_hello_callbacks.push(->(p, **kwargs) { sleep 1; monitor.start })
     end
 
     def latency(num_samples=@max_samples)
@@ -38,38 +40,42 @@ module DEVp2p
       (0...num_samples).map {|i| @samples[i] }.reduce(0, &:+)
     end
 
-    def run
-      logger.debug 'started', monitor: Actor.current
-      loop do
-        logger.debug 'pinging', monitor: Actor.current
-        @proto.send_ping
+    def start
+      logger.debug 'started', monitor: self
 
-        now = @last_request = Time.now
-        sleep @ping_interval
+      logger.debug 'pinging', monitor: self
+      @proto.async.send_ping
+      now = @last_request = Time.now
+
+      @task = Concurrent::TimerTask.new(execution_interval: @ping_interval) do
         logger.debug('latency', peer: @proto, latency: ("%.3f" % latency))
 
         if now - @last_response > @response_delay_threshold
-          logger.debug "unresponsive_peer", monitor: Actor.current
-          @proto.peer.report_error 'not responding to ping'
-          @proto.stop
-          terminate
+          logger.debug "unresponsive_peer", monitor: self
+          @proto.peer.async.report_error 'not responding to ping'
+          @proto.async.stop
         end
-      end
-    end
 
-    def start
-      async.run
+        logger.debug 'pinging', monitor: self
+        @proto.async.send_ping
+        now = @last_request = Time.now
+      end
+      @task.execute
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
     end
 
     def stop
-      logger.debug 'stopped', monitor: Actor.current
-      terminate
+      logger.debug 'stopped', monitor: self
+      @task.shutdown
+      @task = nil
     end
 
     private
 
     def logger
-      @logger ||= Logger.new("#{@proto.peer.config[:p2p][:listen_port]}.p2p.ctxmonitor.#{object_id}")
+      @logger ||= Logger.new("p2p.ctxmonitor")
     end
 
   end

data/lib/devp2p/discovery.rb

@@ -1,3 +1,4 @@
+# -*- encoding : ascii-8bit -*-
 ##
 # # Node Discovery Protocol
 #
@@ -110,7 +111,6 @@
 #   }
 #
 
-
 require 'devp2p/discovery/address'
 require 'devp2p/discovery/node'
 require 'devp2p/discovery/kademlia_protocol_adapter'

data/lib/devp2p/discovery/protocol.rb

@@ -173,7 +173,7 @@ module DEVp2p
         get_node(nodeid, address) unless @nodes.has_key?(nodeid)
         send cmd, nodeid, payload, mdc
       rescue
-        logger.error 'invalid message', error: $!
+        logger.error 'invalid message', error: $!, from: address
       end
 
       def send_message(node, message)
@@ -319,7 +319,7 @@ module DEVp2p
       private
 
       def logger
-        @logger ||= Logger.new("#{udp_port}.p2p.discovery").tap {|l| l.level = :info }
+        @logger ||= Logger.new("p2p.discovery").tap {|l| l.level = :info }
       end
 
       def encode_cmd_id(cmd_id)

data/lib/devp2p/discovery/service.rb

@@ -3,12 +3,82 @@
 module DEVp2p
   module Discovery
 
-    ##
-    # Persist the list of known nodes with their reputation.
-    #
-    class Service < BaseService
-      include Celluloid::IO
+    class Receiver
+      include Concurrent::Async
 
+      def initialize(service, socket)
+        super()
+
+        @service = service
+        @socket = socket
+
+        @stopped = false
+      end
+
+      def start
+        maxlen = Multiplexer.max_window_size * 2
+
+        loop do
+          break if @stopped || @socket.closed?
+
+          message, info = @socket.recvfrom maxlen
+          handle_packet message, info[3], info[1]
+        end
+      rescue
+        puts $!
+        puts $!.backtrace[0,10].join("\n")
+      end
+
+      def stop
+        @stopped = true
+      end
+
+      def handle_packet(message, ip, port)
+        logger.debug "handling packet", ip: ip, port: port, size: message.size
+        @service.async.receive_message Address.new(ip, port), message
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new "p2p.discovery"
+      end
+    end
+
+    class Sender
+      include Concurrent::Async
+
+      def initialize(service, socket)
+        super()
+
+        @service = service
+        @socket = socket
+
+        @stopped = false
+      end
+
+      def start
+        # do nothing
+      end
+
+      def send_message(address, message)
+        raise ArgumentError, 'address must be Address' unless address.instance_of?(Address)
+        logger.debug "sending", size: message.size, to: address
+
+        @socket.send message, 0, address.ip, address.udp_port
+      rescue
+        puts $!
+        puts $!.backtrace[0,10].join("\n")
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new "p2p.discovery"
+      end
+    end
+
+    class Service < ::DEVp2p::Service
       name 'discovery'
 
       default_config(
@@ -27,33 +97,8 @@ module DEVp2p
         super(app)
         logger.info "Discovery service init"
 
-        @server = nil # will be UDPSocket
-        @protocol = Protocol.new app, Actor.current
-      end
-
-      def address
-        ip = @app.config[:discovery][:listen_host]
-        port = @app.config[:discovery][:listen_port]
-        Address.new ip, port
-      end
-
-      def send_message(address, message)
-        raise ArgumentError, 'address must be Address' unless address.instance_of?(Address)
-        logger.debug "sending", size: message.size, to: address
-
-        begin
-          @server.send message, 0, address.ip, address.udp_port
-        rescue
-          # should never reach here? udp has no connection!
-          logger.error "udp write error", error: $!
-          logger.error "waiting for recovery"
-          sleep 5
-        end
-      end
-
-      def receive_message(address, message)
-        raise ArgumentError, 'address must be Address' unless address.instance_of?(Address)
-        @protocol.receive_message address, message
+        @socket = nil
+        @protocol = Protocol.new app, self
       end
 
       def start
@@ -64,38 +109,52 @@ module DEVp2p
 
         logger.info "starting udp listener", port: port, host: ip
 
-        @server = UDPSocket.new
-        @server.bind ip, port
+        @socket = UDPSocket.new
+        @socket.bind ip, port
 
-        super
+        @receiver = Receiver.new self, @socket
+        @sender = Sender.new self, @socket
+        @receiver.async.start
+        @sender.async.start
 
         nodes = @app.config[:discovery][:bootstrap_nodes] || []
         @protocol.bootstrap( nodes.map {|x| Node.from_uri(x) } )
+      rescue
+        puts $!
+        puts $!.backtrace[0,10].join("\n")
       end
 
       def stop
         logger.info "stopping discovery"
-        super
+
+        @socket.close if @socket
+        @sender.async.stop if @sender
+        @receiver.async.stop if @receiver
+
+        @socket = nil
+        @sender = nil
+        @receiver = nil
       end
 
-      private
+      def address
+        ip = @app.config[:discovery][:listen_host]
+        port = @app.config[:discovery][:listen_port]
+        Address.new ip, port
+      end
 
-      def logger
-        @logger ||= Logger.new "#{@app.config[:discovery][:listen_port]}.p2p.discovery"
+      def receive_message(address, message)
+        raise ArgumentError, 'address must be Address' unless address.instance_of?(Address)
+        @protocol.receive_message address, message
       end
 
-      def _run
-        maxlen = Multiplexer.max_window_size * 2
-        loop do
-          break if stopped?
-          message, info = @server.recvfrom maxlen
-          async.handle_packet message, info[3], info[1]
-        end
+      def send_message(address, message)
+        @sender.async.send_message address, message
       end
 
-      def handle_packet(message, ip, port)
-        logger.debug "handling packet", ip: ip, port: port, size: message.size
-        receive_message Address.new(ip, port), message
+      private
+
+      def logger
+        @logger ||= Logger.new "p2p.discovery"
       end
 
     end