devp2p 0.2.0 → 0.3.0

data/lib/devp2p/p2p_protocol.rb

@@ -7,7 +7,7 @@ module DEVp2p
   #
   # @see https://github.com/ethereum/wiki/wiki/%C3%90%CE%9EVp2p-Wire-Protocol
   #
-  class P2PProtocol < BaseProtocol
+  class P2PProtocol < Protocol
 
     class Ping < Command
       cmd_id 2
@@ -52,14 +52,14 @@ module DEVp2p
           return proto.send_disconnect(reason: reasons[:connected_to_self])
         end
 
-        proto.peer.receive_hello proto, data
+        proto.peer.async.receive_hello proto, data
         super(proto, data)
       end
 
       private
 
       def logger
-        @logger = Logger.new "#{::Celluloid::Actor.current.peer.config[:p2p][:listen_port]}.p2p.protocol"
+        @logger = Logger.new "p2p.protocol"
       end
 
     end
@@ -99,23 +99,23 @@ module DEVp2p
         raise ArgumentError, "unknown reason" unless reason_key(reason)
         logger.debug "send_disconnect", peer: proto.peer, reason: reason_name(reason)
 
-        proto.peer.report_error "sending disconnect #{reason_name(reason)}"
+        proto.peer.async.report_error "sending disconnect #{reason_name(reason)}"
 
-        Celluloid::Actor.current.after(0.5) { proto.peer.stop }
+        Concurrent::ScheduledTask.execute(0.5) { proto.peer.async.stop }
 
         {reason: reason}
       end
 
       def receive(proto, data)
         logger.debug "receive_disconnect", peer: proto.peer, reason: reason_name(data[:reason])
-        proto.peer.report_error "disconnected #{reason_name(data[:reason])}"
-        proto.peer.stop
+        proto.peer.async.report_error "disconnected #{reason_name(data[:reason])}"
+        proto.peer.async.stop
       end
 
       private
 
       def logger
-        @logger = Logger.new "#{::Celluloid::Actor.current.peer.config[:p2p][:listen_port]}.p2p.protocol"
+        @logger = Logger.new "p2p.protocol"
       end
 
     end
@@ -154,7 +154,7 @@ module DEVp2p
     private
 
     def logger
-      @logger = Logger.new "#{@config[:p2p][:listen_port]}.p2p.protocol"
+      @logger = Logger.new "p2p.protocol"
     end
 
   end

data/lib/devp2p/peer.rb

@@ -3,7 +3,7 @@
 module DEVp2p
 
   class Peer
-    include Celluloid::IO
+    include Concurrent::Async
 
     DUMB_REMOTE_TIMEOUT = 10.0
 
@@ -16,12 +16,12 @@ module DEVp2p
 
       @protocols = {}
 
-      @stopped = true
+      @stopped = false
       @hello_received = false
 
       _, @port, _, @ip = @socket.peeraddr
       @remote_client_version = ''
-      logger.debug "peer init", peer: Actor.current
+      logger.debug "peer init", peer: self
 
       privkey = Utils.decode_hex @config[:node][:privkey_hex]
       hello_packet = P2PProtocol.get_hello_packet hello_data
@@ -32,16 +32,37 @@ module DEVp2p
       connect_service @peermanager
 
       # assure, we don't get messages while replies are not read
-      # TODO: is it safe to use flag + cond to mimic gevent.event.Event?
-      @safe_to_read = true
-      @safe_to_read_cond = Celluloid::Condition.new
+      @safe_to_read = Concurrent::Event.new
+      @safe_to_read.set
 
       # stop peer if hello not received in DUMB_REMOTE_TIMEOUT
-      after(DUMB_REMOTE_TIMEOUT) { check_if_dumb_remote }
+      Concurrent::ScheduledTask.execute(DUMB_REMOTE_TIMEOUT) { check_if_dumb_remote }
+    end
+
+    def start
+      @stopped = false
+      @run = Thread.new { run }
+    end
+
+    def stop
+      if !stopped?
+        @stopped = true
+
+        @protocols.each_value {|proto| proto.async.stop }
+        @peermanager.async.delete self
+
+        logger.info "peer stopped", peer: self
+        @run.kill
+        @run_decoded_packets.kill
+        @run_egress_message.kill
+      end
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
     end
 
-    def wait_to_read
-      @safe_to_read_cond.wait unless @safe_to_read
+    def stopped?
+      @stopped
     end
 
     ##
@@ -60,8 +81,10 @@ module DEVp2p
     def to_s
       pn = "#@ip:#@port"
       cv = @remote_client_version.split('/')[0,2].join('/')
-      "<Peer #{pn} #{cv}>"
+      pn = "#{pn} #{cv}" unless cv.empty?
+      "<Peer #{pn}>"
     end
+    alias inspect to_s
 
     def report_error(reason)
       pn = "#@ip:#@port"
@@ -73,11 +96,11 @@ module DEVp2p
 
       # create protocol instance which connects peer with service
       protocol_class = service.wire_protocol
-      protocol = protocol_class.new Actor.current, service
+      protocol = protocol_class.new self, service
 
       # register protocol
       raise PeerError, 'protocol already connected' if @protocols.has_key?(protocol_class)
-      logger.debug "registering protocol", protocol: protocol.name, peer: Actor.current
+      logger.debug "registering protocol", protocol: protocol.name, peer: self
 
       @protocols[protocol_class] = protocol
       @mux.add_protocol protocol.protocol_id
@@ -144,7 +167,7 @@ module DEVp2p
     def send_packet(packet)
       protocol = @protocols.values.find {|pro| pro.protocol_id == packet.protocol_id }
       raise PeerError, "no protocol found" unless protocol
-      logger.debug "send packet", cmd: protocol.cmd_by_id[packet.cmd_id], protocol: protocol.name, peer: Actor.current
+      logger.debug "send packet", cmd: protocol.cmd_by_id[packet.cmd_id], protocol: protocol.name, peer: self
 
       # rewrite cmd_id (backwards compatibility)
       if @offset_based_dispatch
@@ -166,13 +189,12 @@ module DEVp2p
     def send_data(data)
       return if data.nil? || data.empty?
 
-      @safe_to_read = false
+      @safe_to_read.reset
 
       @socket.write data
       logger.debug "wrote data", size: data.size
 
-      @safe_to_read = true
-      @safe_to_read_cond.broadcast
+      @safe_to_read.set
     rescue Errno::ETIMEDOUT
       logger.debug "write timeout"
       report_error "write timeout"
@@ -183,31 +205,22 @@ module DEVp2p
       stop
     end
 
-    def run_ingress_message
+    def run
       logger.debug "peer starting main loop"
       raise PeerError, 'connection is closed' if @socket.closed?
 
-      async.run_decoded_packets
-      async.run_egress_message
+      @run_decoded_packets = Thread.new { run_decoded_packets }
+      @run_egress_message = Thread.new { run_egress_message }
 
       while !stopped?
-        wait_to_read
+        @safe_to_read.wait
 
         begin
-          @socket.wait_readable
-        rescue SystemCallError => e
-          logger.debug "read error", error: e, peer: Actor.current
-          report_error "network error #{e}"
-          if Errno::EBADF === e # bad file descriptor
+          imsg = @socket.recv(4096)
+          if imsg.empty?
+            logger.info "socket closed"
             stop
-          else
-            raise e
-            break
           end
-        end
-
-        begin
-          imsg = @socket.recv(4096)
         rescue EOFError # imsg is empty
           if @socket.closed?
             logger.info "socket closed"
@@ -216,7 +229,7 @@ module DEVp2p
             imsg = ''
           end
         rescue SystemCallError => e
-          logger.debug "read error", error: e, peer: Actor.current
+          logger.debug "read error", error: e, peer: self
           report_error "network error #{e}"
           if [Errno::ECONNRESET, Errno::ETIMEDOUT, Errno::ENETDOWN, Errno::EHOSTUNREACH].any? {|syserr| e.instance_of?(syserr) }
             stop
@@ -232,45 +245,23 @@ module DEVp2p
         end
       end
     rescue RLPxSessionError, DecryptionError => e
-      logger.debug "rlpx session error", peer: Actor.current, error: e
+      logger.debug "rlpx session error", peer: self, error: e
       report_error "rlpx session error"
       stop
     rescue MultiplexerError => e
-      logger.debug "multiplexer error", peer: Actor.current, error: e
+      logger.debug "multiplexer error", peer: self, error: e
       report_error "multiplexer error"
       stop
     rescue
-      logger.debug "ingress message error", peer: Actor.current, error: $!
+      logger.debug "ingress message error", peer: self, error: $!
       report_error "ingress message error"
       stop
     end
-    alias run run_ingress_message
-
-    def start
-      @stopped = false
-      async.run
-    end
-
-    def stop
-      if !stopped?
-        @stopped = true
-
-        @protocols.each_value {|proto| proto.stop }
-        @peermanager.delete Actor.current
-
-        logger.info "peer stopped", peer: Actor.current
-        terminate
-      end
-    end
-
-    def stopped?
-      @stopped
-    end
 
     private
 
     def logger
-      @logger ||= Logger.new "#{@config[:p2p][:listen_port]}.p2p.peer"
+      @logger ||= Logger.new "p2p.peer"
     end
 
     def hello_data
@@ -291,6 +282,9 @@ module DEVp2p
       protocol.receive_packet packet
     rescue UnknownCommandError => e
       logger.error 'received unknown cmd', error: e, packet: packet
+    rescue
+      logger.error $!
+      logger.error $!.backtrace[0,10].join("\n")
     end
 
     def protocol_cmd_id_from_packet(packet)

data/lib/devp2p/peer_manager.rb

@@ -12,8 +12,43 @@ module DEVp2p
   #       connect closest node
   #
   class PeerManager < WiredService
-    include Celluloid::IO
-    finalizer :finalize
+
+    class ServiceListener
+      include Concurrent::Async
+
+      def initialize(service, server)
+        super()
+
+        @service = service
+        @server = server
+
+        @stopped = false
+      end
+
+      def start
+        loop do
+          break if @stopped
+          @service.async.handle_connection @server.accept
+        end
+      rescue IOError
+        logger.error "listening error: #{$!}"
+        puts $!
+        @stopped = true
+      rescue
+        logger.error $!
+        logger.error $!.backtrace[0,10].join("\n")
+      end
+
+      def stop
+        @stopped = true
+      end
+
+      private
+
+      def logger
+        @logger ||= Logger.new "p2p.peermgr"
+      end
+    end
 
     name 'peermanager'
     required_services []
@@ -52,6 +87,8 @@ module DEVp2p
 
       @host = @config[:p2p][:listen_host]
       @port = @config[:p2p][:listen_port]
+
+      @stopped = false
     end
 
     def start
@@ -60,8 +97,13 @@ module DEVp2p
       logger.info "starting tcp listener", host: @host, port: @port
       @server = TCPServer.new @host, @port
 
-      super
-      after(0.01) { discovery_loop }
+      @service_listener = ServiceListener.new self, @server
+      @service_listener.async.start
+
+      @discovery_loop = Thread.new do
+        sleep 0.1
+        discovery_loop
+      end
     end
 
     def stop
@@ -69,19 +111,13 @@ module DEVp2p
 
       @server.close if @server
       @peers.each(&:stop)
+      @discovery_loop.kill
 
-      super
+      @stopped = true
     end
 
-    def _run
-      loop do
-        break if stopped?
-        async.handle_connection @server.accept
-      end
-    rescue IOError
-      logger.error "listening error: #{$!}"
-      puts $!
-      @stopped = true
+    def stopped?
+      @stopped
     end
 
     def add(peer)
@@ -94,7 +130,7 @@ module DEVp2p
 
     def exclude(peer)
       @excluded.push peer.remote_pubkey
-      peer.stop
+      peer.async.stop
     end
 
     def on_hello_received(proto, version, client_version_string, capabilities, listen_port, remote_pubkey)
@@ -134,7 +170,7 @@ module DEVp2p
         args.push kwargs
         peer.protocols[protocol].send "send_#{command_name}", *args
 
-        peer.wait_to_read
+        peer.safe_to_read.wait
         logger.debug "broadcasting done", ts: Time.now
       end
     end
@@ -160,6 +196,11 @@ module DEVp2p
       logger.debug "connection error #{$!}"
       @errors.add address, "connection error #{$!}"
       false
+    rescue
+      address = "#{host}:#{port}"
+      logger.debug $!
+      @errors.add address, "connection error #{$!}"
+      false
     end
 
     def num_peers
@@ -176,10 +217,20 @@ module DEVp2p
       @errors.add *args
     end
 
+    def handle_connection(socket)
+      _, port, host = socket.peeraddr
+      logger.debug "incoming connection", host: host, port: port
+
+      start_peer socket
+    rescue EOFError
+      logger.debug "connection disconnected", host: host, port: port
+      socket.close
+    end
+
     private
 
     def logger
-      @logger ||= Logger.new "#{@config[:p2p][:listen_port]}.p2p.peermgr"
+      @logger ||= Logger.new "p2p.peermgr"
     end
 
     def bootstrap(bootstrap_nodes=[])
@@ -195,33 +246,25 @@ module DEVp2p
       end
     end
 
-    def handle_connection(socket)
-      _, port, host = socket.peeraddr
-      logger.debug "incoming connection", host: host, port: port
-
-      peer = start_peer socket
-      #Celluloid::Actor.join peer
-    rescue EOFError
-      logger.debug "connection disconnected", host: host, port: port
-      socket.close
-    end
-
     # FIXME: TODO: timeout is ignored!
     def create_connection(host, port, timeout)
-      Celluloid::IO::TCPSocket.new ::TCPSocket.new(host, port)
+      ::TCPSocket.new(host, port)
     end
 
     def start_peer(socket, remote_pubkey=nil)
-      peer = Peer.new Actor.current, socket, remote_pubkey
+      peer = Peer.new self, socket, remote_pubkey
       logger.debug "created new peer", peer: peer, fileno: socket.to_io.fileno
 
       add peer
-      peer.start
+      peer.async.start
 
       logger.debug "peer started", peer: peer, fileno: socket.to_io.fileno
       raise PeerError, 'connection closed' if socket.closed?
 
       peer
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
     end
 
     def discovery_loop
@@ -274,14 +317,9 @@ module DEVp2p
 
         sleep @connect_loop_delay
       end
-
-      # TODO: ???
-      cond = Celluloid::Condition.new
-      cond.wait
-    end
-
-    def finalize
-      @server.close if @server && !@server.closed?
+    rescue
+      puts $!
+      puts $!.backtrace[0,10].join("\n")
     end
 
   end