devp2p 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c9730d697b44cd5f35301e1010636cfa941e30db
+  data.tar.gz: dc7bed10ffed00dc8353e459906014d541738fcc
+SHA512:
+  metadata.gz: 3b8635533c9b4e6211972ea1d0e3973317553b991dcfd664823ed3cbee5c627b7f68e72d411974d47ceafe8eb241e9137563af6b944f09549b18b56f178c3e45
+  data.tar.gz: 974eae8a51cc88d2668b07c4baa0f75aa305ab59b283307abea19c7edccc9cf5f84e2567dceb223f96739c820394e597fd0c5deb853172d96fab951de00812c1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Jan Xie
+
+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.

data/README.md

@@ -0,0 +1,22 @@
+# ruby-devp2p
+
+[![MIT License](https://img.shields.io/packagist/l/doctrine/orm.svg)](LICENSE)
+[![travis build status](https://travis-ci.org/janx/ruby-devp2p.svg?branch=master)](https://travis-ci.org/janx/ruby-devp2p)
+
+A ruby implementation of Ethereum's DEVp2p framework.
+
+## Fiber Stack Size
+
+DEVp2p is build on [Celluloid](https://github.com/celluloid/celluloid/), which
+uses fibers to schedule tasks. Ruby's default limit on fiber stack size is quite
+small, which need to be increased by setting environment variables:
+
+```
+export RUBY_FIBER_VM_STACK_SIZE=104857600 # 100MB
+export RUBY_FIBER_MACHINE_STACK_SIZE=1048576000
+```
+
+## Resources
+
+* [DEVp2p Whitepaper](https://github.com/ethereum/wiki/wiki/libp2p-Whitepaper)
+* [RLPx](https://github.com/ethereum/devp2p/blob/master/rlpx.md)

data/lib/devp2p.rb

@@ -0,0 +1,57 @@
+# -*- encoding : ascii-8bit -*-
+
+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
+
+  TT16 = 2**16
+  TT256 = 2**256
+
+  NODE_URI_SCHEME = 'enode://'.freeze
+end
+
+require 'devp2p/version'
+
+require 'devp2p/configurable'
+require 'devp2p/utils'
+require 'devp2p/exception'
+
+require 'devp2p/control'
+require 'devp2p/base_service'
+require 'devp2p/wired_service'
+
+require 'devp2p/kademlia'
+require 'devp2p/discovery'
+
+require 'devp2p/sync_queue'
+
+require 'devp2p/packet'
+require 'devp2p/frame'
+require 'devp2p/multiplexer'
+
+require 'devp2p/crypto'
+require 'devp2p/rlpx_session'
+require 'devp2p/multiplexed_session'
+
+require 'devp2p/command'
+require 'devp2p/base_protocol'
+require 'devp2p/connection_monitor'
+require 'devp2p/p2p_protocol'
+
+require 'devp2p/peer'
+require 'devp2p/peer_errors'
+require 'devp2p/peer_manager'
+
+require 'devp2p/base_app'
+require 'devp2p/app_helper'
+

data/lib/devp2p/app_helper.rb

@@ -0,0 +1,85 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+  class AppHelper
+
+    def run(app_class, service_class, num_nodes: 3, seed: 0, min_peers: 2, max_peers: 2, random_port: false)
+      base_port = random_port ? SecureRandom.random_number(50000) + 10000 : 29870
+
+      bootstrap_node_privkey = Crypto.mk_privkey "#{seed}:udp:0"
+      bootstrap_node_pubkey = Crypto.privtopub bootstrap_node_privkey
+      enode = Utils.host_port_pubkey_to_uri "0.0.0.0", base_port, bootstrap_node_pubkey
+
+      services = [Discovery::Transport, PeerManager]#, service_class]
+
+      base_config = {}
+      services.each {|s| Utils.update_config_with_defaults base_config, s.default_config }
+
+      base_config[:discovery][:bootstrap_nodes] = [enode]
+      base_config[:seed] = seed
+      base_config[:base_port] = base_port
+      base_config[:num_nodes] = num_nodes
+      base_config[:min_peers] = min_peers
+      base_config[:max_peers] = max_peers
+
+      apps = []
+      num_nodes.times do |node_num|
+        app = create_app node_num, base_config, services, app_class
+        apps.push app
+      end
+
+      serve_until_stopped apps
+    end
+
+    def create_app(node_num, config, services, app_class)
+      num_nodes = config[:num_nodes]
+      base_port = config[:base_port]
+      seed = config[:seed]
+      min_peers = config[:min_peers]
+      max_peers = config[:max_peers]
+
+      raise "invalid node_num" unless node_num < num_nodes
+      #raise "invalid min/max peers" unless min_peers <= max_peers && max_peers < num_nodes
+
+      config = Marshal.load Marshal.dump(config)
+      config[:node_num] = node_num
+
+      config[:node][:privkey_hex] = Utils.encode_hex Crypto.mk_privkey("#{seed}:udp:#{node_num}")
+      config[:discovery][:listen_port] = base_port + node_num
+      config[:p2p][:listen_port] = base_port + node_num
+      config[:p2p][:min_peers] = [min_peers, 10].min
+      config[:p2p][:max_peers] = max_peers
+      config[:client_version_string] = "NODE#{node_num}"
+
+      app = app_class.new config
+
+      services.each do |service|
+        raise "invalid service" unless service.instance_of?(Class) && service < BaseService
+
+        if !app.config[:deactivated_services].include?(service.name)
+          raise "service should not be active" if app.services.has_key?(service.name)
+          service.register_with_app app
+          raise "servier should be active" unless app.services.has_key?(service.name)
+        end
+      end
+
+      app
+    end
+
+    def serve_until_stopped(apps)
+      apps.each do |app|
+        app.start
+
+        if app.config[:post_app_start_callback]
+          app.config[:post_app_start_callback].call(app)
+        end
+      end
+
+      apps.each(&:join)
+
+      # finally stop
+      apps.each(&:stop)
+    end
+
+  end
+end

data/lib/devp2p/base_app.rb

@@ -0,0 +1,80 @@
+# -*- encoding : ascii-8bit -*-
+require 'hashie'
+
+module DEVp2p
+  class BaseApp
+
+    extend Configurable
+    add_config(
+      default_config: {
+        client_version_string: "ruby-devp2p #{VersionString}",
+        deactivated_services: []
+      }
+    )
+
+    attr :config, :services
+
+    def initialize(config=default_config)
+      @config = Utils.update_config_with_defaults config, default_config
+      @registry = Celluloid::Supervision::Configuration.new
+      @services = Hashie::Mash.new
+    end
+
+    ##
+    # Registers protocol with app, which will be accessible as
+    # `app.services.<protocol_name>` (e.g. `app.services.p2p` or
+    # `app.services.eth`)
+    #
+    def register_service(klass, *args)
+      raise ArgumentError, "service must be instance of BaseService" unless klass.instance_of?(Class) && klass < BaseService
+      raise ArgumentError, "service #{klass.name} already registered" if services.has_key?(klass.name)
+
+      logger.info "registering service", service: klass.name
+
+      registry_name = "#{object_id}__#{klass.name}"
+      @registry.define type: klass, as: registry_name, args: args
+      services[klass.name] = nil
+
+      klass
+    end
+
+    def deregister_service(service)
+      raies NotImplemented
+      #raise ArgumentError, "service must be instance of BaseService" unless service.is_a?(BaseService)
+      #services.delete(service.name)
+      #unlink service
+    end
+
+    def start
+      @registry.deploy
+
+      services.keys.each do |k|
+        registry_name = "#{object_id}__#{k}"
+        services[k] = Celluloid::Actor[registry_name]
+        services[k].start
+      end
+    end
+
+    def stop
+      services.keys.each do |k|
+        services[k].stop if services[k].alive?
+        services[k] = nil
+      end
+
+      @registry.shutdown
+    end
+
+    def join
+      @services.each_value do |service|
+        Celluloid::Actor.join service
+      end
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new 'app'
+    end
+
+  end
+end

data/lib/devp2p/base_protocol.rb

@@ -0,0 +1,136 @@
+# -*- encoding : ascii-8bit -*-
+
+module DEVp2p
+
+  ##
+  # A protocol mediates between the network and the service. It implements a
+  # collection of commands.
+  #
+  # For each command X the following methods are created at initialization:
+  #
+  # * `packet = protocol.create_X(*args, **kwargs)`
+  # * `protocol.send_X(*args, **kwargs)`, which is a shortcut for `send_packet`
+  #   plus `create_X`.
+  # * `protocol.receive_X(data)`
+  #
+  # On `protocol.receive_packet`, the packet is deserialized according to the
+  # `command.structure` and the `command.receive` method called with a hash
+  # containing the received data.
+  #
+  # The default implementation of `command.receive` calls callbacks which can
+  # be registered in a list which is available as: `protocol.receive_X_callbacks`.
+  #
+  class BaseProtocol
+    include Celluloid
+    include Control
+
+    extend Configurable
+    add_config(
+      name: '',
+      protocol_id: 0,
+      version: 0,
+      max_cmd_id: 0 # reserved cmd space
+    )
+
+    attr :peer, :service, :cmd_by_id
+
+    def initialize(peer, service)
+      raise ArgumentError, 'service must be WiredService' unless service.is_a?(WiredService)
+      raise ArgumentError, 'peer.send_packet must be callable' unless peer.respond_to?(:send_packet)
+
+      @peer = peer
+      @service = service
+
+      initialize_control
+
+      setup
+    end
+
+    def start
+      logger.debug 'starting', proto: Actor.current
+      service.on_wire_protocol_start Actor.current
+      super
+    end
+
+    def stop
+      logger.debug 'stopping', proto: Actor.current
+      service.on_wire_protocol_stop Actor.current
+      super
+    end
+
+    def _run
+      # pass
+    end
+
+    def receive_packet(packet)
+      cmd_name = @cmd_by_id[packet.cmd_id]
+      cmd = "receive_#{cmd_name}"
+      send cmd, packet
+    rescue ProtocolError => e
+      logger.warn "protocol exception, stopping", error: e
+      stop
+    end
+
+    def send_packet(packet)
+      peer.send_packet packet
+    end
+
+    def to_s
+      "<#{name} #{peer}>"
+    end
+    alias :inspect :to_s
+
+    private
+
+    def logger
+      @logger ||= Logger.new('protocol')
+    end
+
+    def setup
+      klasses = []
+      self.class.constants.each do |name|
+        c = self.class.const_get name
+        klasses.push(c) if c.instance_of?(Class) && c < Command
+      end
+
+      raise DuplicatedCommand unless klasses.map(&:cmd_id).uniq.size == klasses.size
+
+      proto = Actor.current
+
+      klasses.each do |klass|
+        instance = klass.new
+
+        # decode rlp, create hash, call receive
+        receive = lambda do |packet|
+          raise ArgumentError unless packet.is_a?(Packet)
+          instance.receive proto, klass.decode_payload(packet.payload)
+        end
+
+        # get data, rlp encode, return packet
+        create = lambda do |*args|
+          res = instance.create(proto, *args)
+          payload = klass.encode_payload res
+          Packet.new protocol_id, klass.cmd_id, payload
+        end
+
+        # create and send packet
+        send_packet = lambda do |*args|
+          packet = create.call *args
+          send_packet packet
+        end
+
+        name = klass.name.split('::').last.downcase
+        singleton_class.send(:define_method, "receive_#{name}", &receive)
+        singleton_class.send(:define_method, "create_#{name}", &create)
+        singleton_class.send(:define_method, "send_#{name}", &send_packet)
+        singleton_class.send(:define_method, "receive_#{name}_callbacks") do
+          instance.receive_callbacks
+        end
+      end
+
+      @cmd_by_id = klasses.map {|k| [k.cmd_id, Utils.underscore(k.name)] }.to_h
+    end
+
+  end
+
+end

data/lib/devp2p/base_service.rb

@@ -0,0 +1,55 @@
+# -*- encoding : ascii-8bit -*-
+module DEVp2p
+
+  ##
+  # Service instances are added to the application under
+  # `app.services.<service_name>`.
+  #
+  # App should be passed to the service in order to query other services.
+  #
+  # Services must be an actor. If a service spawns additional services, it's
+  # responsible to stop them.
+  #
+  class BaseService
+    include Celluloid
+    #finalizer :stop
+    include Control
+
+    extend Configurable
+    add_config(
+      name: '',
+      default_config: {name: {}},
+      required_services: []
+    )
+
+    class <<self
+      ##
+      # Services know best how to initiate themselves. Create a service
+      # instance, probably based on `app.config` and `app.services`.
+      #
+      def register_with_app(app)
+        app.register_service self, app
+      end
+    end
+
+    attr :app, :config
+
+    def initialize(app)
+      @app = app
+      @config = Utils.update_config_with_defaults app.config, default_config
+
+      initialize_control
+
+      available_services = app.services.each_value.map(&:class)
+      required_services.each do |r|
+        raise MissingRequiredServiceError, "require service #{r}" unless available_services.include?(r)
+      end
+    end
+
+    def to_s
+      "<Service #{name}##{object_id}>"
+    end
+    alias inspect to_s
+
+  end
+end