dcha 0.1.0

data/lib/dcha/peer.rb

@@ -0,0 +1,90 @@
+require 'dcha/peer/remote_executable'
+require 'dcha/peer/can_heartbeat'
+require 'dcha/peer/has_trie'
+require 'dcha/peer/has_blockchain'
+
+module Dcha
+  # :nodoc:
+  class Peer
+    include Observable
+    include RemoteExecutable
+    include HasTrie
+    include HasBlockchain
+    include CanHeartbeat
+
+    MULTICAST_ADDR = '224.5.5.55'.freeze
+    BIND_ADDR = '0.0.0.0'.freeze
+    PORT = '5555'.freeze
+
+    attr_reader :peers, :hostname, :ipaddr
+
+    def initialize
+      @hostname = Socket.gethostname
+      @ipaddr = Addrinfo.getaddrinfo(hostname, nil, :INET).first
+      @peers = []
+      @thread = nil
+      @packets = PacketManager.new
+    end
+
+    def join
+      return if listening?
+      listen
+      ping
+    end
+
+    def listening?
+      @listening == true
+    end
+
+    def transmit(data)
+      transmit_to MULTICAST_ADDR, data
+    end
+
+    def transmit_to(address, data)
+      Chunk.split(data).each do |bytes|
+        socket.send(bytes.pack('C*'), 0, address, PORT)
+      end
+    end
+
+    private
+
+    def listen
+      socket.bind(BIND_ADDR, PORT)
+      puts "Listen #{ipaddr.ip_address}:#{PORT} on #{hostname} "
+      @thread = Thread.new { process }
+      @listening = true
+    end
+
+    def process
+      loop do
+        resolve @packets.todo.pop(true) until @packets.todo.empty?
+        receive
+      end
+    end
+
+    def resolve(event)
+      raise StandardError, event if event == 'store_set'
+      execute event[:action], event[:on], event[:params]
+      changed
+      notify_observers event[:action], event[:on], event[:params], Time.now
+    end
+
+    def receive
+      bytes, = socket.recvfrom(512)
+      chunk = Chunk.new(bytes.unpack('C*'))
+      @packets << chunk
+    end
+
+    def socket
+      @socket ||= UDPSocket.open.tap do |socket|
+        socket.setsockopt(:IPPROTO_IP, :IP_ADD_MEMBERSHIP, bind_address)
+        socket.setsockopt(:IPPROTO_IP, :IP_MULTICAST_TTL, 1)
+        socket.setsockopt(:SOL_SOCKET, :SO_REUSEPORT, 1)
+      end
+    end
+
+    def bind_address
+      IPAddr.new(MULTICAST_ADDR).hton + IPAddr.new(BIND_ADDR).hton
+    end
+  end
+end

data/lib/dcha/peer/can_heartbeat.rb

@@ -0,0 +1,17 @@
+module Dcha
+  class Peer
+    # :nodoc:
+    module CanHeartbeat
+      def ping
+        transmit action: :pong, params: [ipaddr.ip_address]
+      end
+
+      def pong(address)
+        @peers.push(address).uniq!
+        transmit action: :mine, params: [chain.blocks]
+        return if ipaddr.ip_address == address
+        transmit_to address, action: :pong, params: [ipaddr.ip_address]
+      end
+    end
+  end
+end

data/lib/dcha/peer/has_blockchain.rb

@@ -0,0 +1,59 @@
+module Dcha
+  class Peer
+    # :nodoc:
+    module HasBlockchain
+      def chain
+        @chain ||= Chain.new
+      end
+
+      def blocks(_address)
+        transmit action: :mine, params: [chain.blocks]
+      end
+
+      def mine(blocks)
+        blocks.sort! { |x, y| x.index <=> y.index }
+        return unless blocks.last.index > chain.blocks.last.index
+        append_blocks(blocks)
+      end
+
+      def create_block(root_hash)
+        return unless chain.create_and_add_block(root_hash)
+        transmit action: :mine, params: [chain.blocks.last(1)]
+      end
+
+      private
+
+      def append_blocks(blocks)
+        if block_linked?(blocks)
+          add_block(blocks)
+        elsif blocks.length == 1
+          ask_blocks
+        elsif blocks.length > 1
+          replace_blocks(blocks)
+        end
+      end
+
+      def add_block(blocks)
+        return unless blocks.last.valid_proof?
+        chain.add_block(blocks.last)
+        reset(blocks.last.root_hash)
+        transmit action: :mine, params: [blocks.last(1)]
+      end
+
+      def ask_blocks
+        transmit action: :blocks, params: [ipaddr.ip_address]
+      end
+
+      def replace_blocks(blocks)
+        blocks.shift if blocks.first.index.zero?
+        chain.replace_with(blocks)
+        reset(blocks.last.root_hash)
+        transmit action: :mine, params: [blocks.last(1)]
+      end
+
+      def block_linked?(blocks)
+        blocks.last.parent_hash == chain.blocks.last.hash
+      end
+    end
+  end
+end

data/lib/dcha/peer/has_trie.rb

@@ -0,0 +1,54 @@
+module Dcha
+  class Peer
+    # :nodoc:
+    module HasTrie
+      def trie
+        @retry = false
+        @trie ||= MPT::Trie.new
+      end
+
+      def reset(root_hash)
+        return if root_hash == trie.root_hash
+        @trie = MPT::Trie.new(root_hash)
+      rescue Store::DataUnavailableError => e
+        transmit action: :store_get, params: [
+          root_hash,
+          e.message,
+          ipaddr.ip_address
+        ]
+      end
+
+      def store_get(root_hash, key, _address)
+        return if root_hash != trie.root_hash
+        changed
+        transmit action: :store_set, params: [
+          root_hash,
+          key,
+          Config.store[key]
+        ]
+      rescue Store::DataUnavailableError
+        nil
+      end
+
+      def store_set(root_hash, key, value)
+        Config.store[key] = value
+        reset(root_hash) if root_hash != trie.root_hash
+      end
+
+      def write(key, value)
+        trie[key] = value
+      end
+
+      def read(key)
+        trie[key]
+      rescue Store::DataUnavailableError => e
+        transmit action: :store_get, params: [
+          trie.root_hash,
+          e.message,
+          ipaddr.ip_address
+        ]
+        '[SYNCING]'
+      end
+    end
+  end
+end

data/lib/dcha/peer/remote_executable.rb

@@ -0,0 +1,25 @@
+module Dcha
+  class Peer
+    # :nodoc:
+    module RemoteExecutable
+      EXECUTABLE_OBJECT = %w[trie chain].freeze
+
+      def execute(action, object_name = nil, params = [])
+        return execute_on(self, action, params) if object_name.nil?
+        object = pickup_object(object_name)
+        return if object.nil?
+        execute_on(object, action, params)
+      end
+
+      def execute_on(object, action, params = [])
+        return unless object.respond_to?(action)
+        object.send(action, *params)
+      end
+
+      def pickup_object(name)
+        return unless EXECUTABLE_OBJECT.include?(name)
+        instance_variable_get("@#{name}")
+      end
+    end
+  end
+end

data/lib/dcha/store.rb

@@ -0,0 +1,9 @@
+module Dcha
+  # :nodoc:
+  module Store
+    class DataUnavailableError < StandardError; end
+
+    autoload :Memory, 'dcha/store/memory'
+    autoload :File, 'dcha/store/file'
+  end
+end

data/lib/dcha/store/file.rb

@@ -0,0 +1,37 @@
+module Dcha
+  module Store
+    # :nodoc:
+    class File < Hash
+      def initialize(path)
+        @path = Pathname.new(path).realdirpath
+        Dir.mkdir(path) unless Dir.exist?(path)
+      end
+
+      def [](key)
+        super || load_from(key)
+      end
+
+      def []=(key, value)
+        save_to(key, value)
+        super
+      end
+
+      def clear!
+        FileUtils.rm_rf(path)
+      end
+
+      private
+
+      def load_from(key)
+        path = "#{@path}/#{key}"
+        raise DataUnavailableError, key unless File.exist?(path)
+        self[key] = File.read(path)
+      end
+
+      def save_to(key, value)
+        path = "#{@path}/#{key}"
+        File.write(path, value) unless File.exist?(path)
+      end
+    end
+  end
+end

data/lib/dcha/store/memory.rb

@@ -0,0 +1,12 @@
+module Dcha
+  module Store
+    # :nodoc:
+    class Memory < Hash
+      def [](key)
+        value = super
+        raise DataUnavailableError, key if value.nil?
+        value
+      end
+    end
+  end
+end

data/lib/dcha/ui.rb

@@ -0,0 +1,84 @@
+require 'dcha/ui/window'
+
+module Dcha
+  # TODO: Implement `curses` ui
+  # :nodoc:
+  class UI
+    include Curses
+
+    def initialize(peer)
+      @window = Window.new(0, 0, 0, 0)
+      @peer = peer
+      @logs = []
+      @input = ''
+      @peer.add_observer(self)
+    end
+
+    def show
+      until @input == 'exit'
+        parse
+        refresh
+        @input = @window.getstr
+      end
+      @window.close
+    end
+
+    def update(action, _, _params, time)
+      @logs.push("Execute #{action} at #{time}")
+      refresh
+    end
+
+    private
+
+    def refresh
+      @window.update do
+        show_logs
+        show_peers
+      end
+    end
+
+    def read
+      key = @input.split(' ').last
+      @logs.push "#{key} -> #{@peer.read(key)}"
+    end
+
+    def write
+      _, key, value = @input.split(' ')
+      @peer.write(key, value)
+      @peer.create_block(@peer.trie.root_hash)
+    end
+
+    def chain
+      @logs.push "CHAIN BLOCKS: #{@peer.chain.blocks.size}"
+    end
+
+    def root
+      @logs.push "TRIE ROOT: #{@peer.trie.root_hash}"
+    end
+
+    def parse
+      return if @input.empty?
+      return read if @input.start_with?('GET')
+      return write if @input.start_with?('SET')
+      return chain if @input.start_with?('CHAIN')
+      return root if @input.start_with?('ROOT')
+    end
+
+    def show_peers
+      message = "Peers: #{@peer.peers.size} >"
+      offset = message.size + 2
+      @window.setpos(@window.maxy - 2, offset)
+      @window.heading = message
+      @window.peers = @peer.peers
+    end
+
+    def show_logs
+      max_log = @window.maxy - 5
+      start_pos = @window.maxx * 0.3 + 2
+      @logs.last(max_log).each.with_index do |log, index|
+        @window.setpos(index + 1, start_pos)
+        @window.addstr(log)
+      end
+    end
+  end
+end

data/lib/dcha/ui/window.rb

@@ -0,0 +1,52 @@
+module Dcha
+  class UI
+    # :nodoc:
+    class Window < Curses::Window
+      def initialize(*)
+        super
+
+        @sidebar = subwin(maxy - 2, maxx * 0.3, 0, 0)
+        @input = subwin(3, 0, maxy - 3, 0)
+      end
+
+      def update(&_block)
+        clear
+        update_sidebar
+        box('|', '-')
+        update_input
+        yield if block_given?
+        refresh
+      end
+
+      def heading=(head)
+        @input.setpos(1, 1)
+        @input.addstr(head)
+      end
+
+      # TODO: Cut off string if overflow
+      def peers=(peers)
+        peers = peers.take(maxy - 5)
+        peers.push('And more ...') if peers.size == maxy - 5
+        peers.each.with_index do |peer, index|
+          @sidebar.setpos(index + 1, 2)
+          @sidebar.addstr(peer)
+        end
+      end
+
+      private
+
+      def update_sidebar
+        @sidebar.clear
+        @sidebar.resize(maxy - 2, maxx * 0.3)
+        @sidebar.box('|', '-')
+      end
+
+      # TODO: Fix position incorrect after resize
+      def update_input
+        @input.clear
+        @input.move(maxy - 3, 0)
+        @input.box('|', '-')
+      end
+    end
+  end
+end