lapidar 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d024f24e254ae420266eb80b779cdca010785af1
-  data.tar.gz: 8012ac6e40bfcd0be7644d9b4b002466a63cd841
+  metadata.gz: 7550a6712aa1a4ec73b55dd89292c037e9d7c518
+  data.tar.gz: 157f2757955b82097def09ccd07e8d34e6bd49e2
 SHA512:
-  metadata.gz: c6ee55f3749e40f80d361be1d8ddbde43bdb9c1abdbbd572c4fa6845320006e3ac800a4a80f2ac35a3ab04b6378829f4ec5005633ef2e368b45bd666ffe8cfb0
-  data.tar.gz: 7cc94309a33288b6d48d89ac6dd1a45ff5cd83fe1d21e39d69de32940b4e72dbc8c600e0a990fcd167f1855f9855877f823b59da71f37741eb96d418f4f46744
+  metadata.gz: 2d7af0295583b6e07a2a329c9a93f478c1ec61f33d140262768dd2f384fd7cf341e5bac0a0efd10255399f60eab826baf527c78dceef95a7d5b42757013fa910
+  data.tar.gz: a1b80a2db11d67d29c80a03113040ab8309e679961e71476282bdc4c64315865fb7dcb2bdd45da0a096fb127c89e5df1bc087e062b72ce4fe3f643a162ea7d3b

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.2.0
+
+* Better threading
+* Blocks now use Unix timestamp
+* Blocks with equal hashes are only added to the chain once
+* Chains can be persisted and loaded.
+* Data can be fed to new blocks.
+
+## 0.1.0
+
+* Initial release

data/README.md

@@ -21,17 +21,34 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Have a look at `bin/run`. You'll see that 5 nodes spin up and connect to each other
+via [buschtelefon](https://github.com/renuo/lapidar) and contest each other
+in a race which looks like this:
+
+![](docs/visualization.png)
+
+To get a colorful output like this you need to install the gem [*paint*](https://github.com/janlelis/paint).
+
+### Persistence
+
+The chain will we loaded from `~/.lapidar/<port>.json` depending on the port
+on which you start the runner. And it will be saved there after you stop the runner.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies.
+Then, run `rake spec` to run the tests. You can also run `bin/console`
+for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then
+run `bundle exec rake release`, which will create a git tag for the version,
+push git commits and tags, and push the `.gem` file
+to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/lapidar.
+Bug reports and pull requests are welcome on GitHub at <https://github.com/renuo/lapidar>.
 
 ## License
 

data/bin/run

@@ -1,17 +1,51 @@
 #!/usr/bin/env ruby
+Thread.abort_on_exception = true
 
+require "paint"
 require "bundler"
 Bundler.setup(:default)
 
-require_relative '../lib/lapidar'
+require_relative "../lib/lapidar"
 
-puts 'Starting experiment…'
+puts "Starting experiment…"
 
-[
-  Thread.new { Lapidar.start_mining(port: 9999, neighbors: [{ host: 'localhost', port: 9995 }]) },
-  Thread.new { Lapidar.start_mining(port: 9998, neighbors: [{ host: 'localhost', port: 9996 }]) },
-  Thread.new { Lapidar.start_mining(port: 9997, neighbors: [{ host: 'localhost', port: 9997 }]) },
-  Thread.new { Lapidar.start_mining(port: 9996, neighbors: [{ host: 'localhost', port: 9998 }]) },
-  Thread.new { Lapidar.start_mining(port: 9995, neighbors: [{ host: 'localhost', port: 9999 }]) }
-].each(&:join)
+runners = [
+  Lapidar.runner(port: 9999, neighbors: [
+    { host: "localhost", port: 9995 },
+    { host: "localhost", port: 9996 },
+    { host: "localhost", port: 9997 },
+    { host: "localhost", port: 9998 },
+  ]),
+  Lapidar.runner(port: 9998, neighbors: [{ host: "localhost", port: 9996 }]),
+  Lapidar.runner(port: 9997, neighbors: [{ host: "localhost", port: 9997 }]),
+  Lapidar.runner(port: 9996, neighbors: [{ host: "localhost", port: 9998 }]),
+  Lapidar.runner(port: 9995, neighbors: [{ host: "localhost", port: 9999 }])
+]
 
+threads = runners.map do |runner|
+  [
+    Thread.new { runner.start },
+    Thread.new { loop { runner.punch_queue << rand.to_s } }
+  ]
+end.flatten
+
+logger_thread = Thread.new do
+  sleep(1)
+
+  loop do
+    system("clear")
+    puts(runners.map do |runner|
+      "Runner on port #{runner.network_endpoint.port}:\n#{runner.chain.to_colorful_string(5)}"
+    end.join("\n"))
+    sleep(1)
+  end
+end
+
+trap "SIGINT" do
+  puts "Shutting down…"
+  runners.each(&:stop)
+  logger_thread.exit
+end
+
+threads.each(&:join)
+logger_thread.join

data/lapidar.gemspec

@@ -30,9 +30,11 @@ and evaluates block order and correctness. Build any distributed business logic
 
   spec.required_ruby_version = ">= 2.3.0"
 
-  spec.add_dependency "buschtelefon", "~> 0.2"
+  spec.add_dependency "buschtelefon", "~> 0.3"
+  spec.add_dependency "oj", ">= 1.0"
   spec.add_development_dependency "bundler", ">= 1.17"
   spec.add_development_dependency "factory_bot", "~> 5.0"
+  spec.add_development_dependency "paint", "~> 2.0"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.8"
   spec.add_development_dependency "simplecov", "~> 0.17"

data/lib/lapidar.rb

@@ -1,81 +1,20 @@
+require "json"
+require "buschtelefon"
+
 require_relative "lapidar/assessment"
 require_relative "lapidar/block"
 require_relative "lapidar/chain"
 require_relative "lapidar/miner"
+require_relative "lapidar/persistence"
+require_relative "lapidar/runner"
 require_relative "lapidar/version"
 
-require "json"
-require "buschtelefon"
-
 module Lapidar
-  def self.start_mining(port:, neighbors:)
-    chain = Chain.new
-    miner = Miner.new
-    incoming_blocks = Queue.new
-
-    me = Buschtelefon::NetTattler.new(port: port)
+  def self.runner(port:, neighbors:)
+    network_endpoint = Buschtelefon::NetTattler.new(port: port)
     neighbors.map! { |neighbor_location| Buschtelefon::RemoteTattler.new(neighbor_location) }
-    neighbors.each { |neighbor| me.connect(neighbor) }
-
-    Thread.abort_on_exception = true
-
-    consumer = Thread.new {
-      until_shutdown do
-        begin
-          chain.add(incoming_blocks.pop)
-          print "+"
-        rescue
-          puts "Consumer error"
-        end
-      end
-    }
-
-    network_producer = Thread.new {
-      until_shutdown do
-        me.listen do |message|
-          begin
-            incoming_json = JSON.parse(message, symbolize_names: true)
-
-            incoming_blocks << Block.new(
-              number: incoming_json[:number].to_i,
-              hash: incoming_json[:hash].to_s,
-              nonce: incoming_json[:none].to_i,
-              data: incoming_json[:data].to_s,
-              created_at: Time.parse(incoming_json[:created_at])
-            )
-          rescue JSON::ParserError, ArgumentError => e
-            puts "Incoming block isn't valid: #{e.message}"
-          end
-        end
-      end
-    }
-
-    local_producer = Thread.new {
-      until_shutdown do
-        new_block = miner.mine(chain.blocks.last)
-
-        me.feed(Buschtelefon::Gossip.new(new_block.to_h.to_json))
-        incoming_blocks << new_block
-
-        print "⚒ "
-      end
-    }
-
-    local_producer.join
-    network_producer.join
-    consumer.join
-
-    puts "\nShutting down…"
-  end
-
-  def self.until_shutdown
-    trap "SIGINT" do
-      puts "\nshutting down"
-      exit
-    end
+    neighbors.each { |neighbor| network_endpoint.connect(neighbor) }
 
-    loop do
-      yield
-    end
+    Runner.new(network_endpoint)
   end
 end

data/lib/lapidar/block.rb

@@ -2,7 +2,7 @@ module Lapidar
   class Block
     attr_reader :number, :hash, :data, :nonce, :created_at
 
-    def initialize(number:, hash:, nonce:, data: nil, created_at: Time.now)
+    def initialize(number:, hash:, nonce:, data: nil, created_at: Time.now.to_f)
       @number = number
       @hash = hash
       @nonce = nonce

data/lib/lapidar/chain.rb

@@ -1,17 +1,19 @@
 module Lapidar
   class Chain
+    attr_reader :block_stacks
+
     def initialize
-      @blocks = []
+      @block_stacks = []
     end
 
     # TODO: Queue up future blocks for later use
     # TODO: Check for duplicates and dont add them to the chains
     def add(block)
-      raise "future block?" if block.number > @blocks.count
+      raise "future block?" if block.number > @block_stacks.count
       raise "invalid block" unless valid?(block)
 
-      @blocks[block.number] ||= []
-      @blocks[block.number].push(block)
+      @block_stacks[block.number] ||= []
+      @block_stacks[block.number].push(block) unless @block_stacks[block.number].map(&:hash).include?(block.hash)
 
       # Rebalance if second to last block has more than one candidate
       rebalance if !contested?(block.number) && contested?(block.number - 1)
@@ -19,7 +21,25 @@ module Lapidar
 
     # For each positition in the chain the candidate positioned first is considered the valid one
     def blocks
-      @blocks.map { |candidates| candidates&.first }
+      @block_stacks.map { |candidates| candidates&.first }
+    end
+
+    def to_colorful_string(depth = 0)
+      [*0..depth].map { |level|
+        @block_stacks.map { |block_stack|
+          if block_stack[level]
+            number_display = block_stack[level].number.to_s
+            if defined? Paint
+              number_display = Paint[number_display, block_stack[level].hash[-6..-1]] # use last hash digits as color
+              number_display = Paint[number_display, :bright, :underline] if level == 0 # emphasize preferred chain
+              number_display
+            end
+            number_display
+          else
+            " " * block_stack[0].number.to_s.length # padding by digit count
+          end
+        }.join(" ")
+      }.join("\n")
     end
 
     private
@@ -30,30 +50,30 @@ module Lapidar
       return false unless Assessment.meets_difficulty?(block) # early invalid if difficulty not met
 
       # Check if there's an existing parent
-      @blocks[block.number - 1].any? do |previous_block|
+      @block_stacks[block.number - 1].any? do |previous_block|
         Assessment.valid_link?(previous_block, block)
       end
     end
 
     # If a new last block comes in, we realign the first blocks to build the longest chain
     def rebalance
-      winning_block = @blocks.last.first
-      parent_position = @blocks.count - 2
+      winning_block = @block_stacks.last.first
+      parent_position = @block_stacks.count - 2
 
       while contested?(parent_position)
         # TODO: Is there's a smarter way to persistently select a winner than sorting the competition
-        @blocks[parent_position].sort_by! do |previous_block|
+        @block_stacks[parent_position].sort_by! do |previous_block|
           Assessment.valid_link?(previous_block, winning_block) ? 0 : 1
         end
 
-        winning_block = @blocks[parent_position].first
+        winning_block = @block_stacks[parent_position].first
         parent_position -= 1
       end
     end
 
     # Contested evaluates to true if there blocks are competing for the same position in the blockchain
     def contested?(block_number)
-      @blocks[block_number].count > 1
+      @block_stacks[block_number].count > 1
     end
   end
 end

data/lib/lapidar/miner.rb

@@ -9,7 +9,14 @@ module Lapidar
     def mine(base_block, data = "")
       base_block ||= god
       nonce = 0
-      nonce += 1 until meets_difficulty?(digest(base_block, nonce, data))
+
+      until meets_difficulty?(digest(base_block, nonce, data))
+        nonce += 1
+
+        # Let others do work as well (TODO: nicer solution without thread context in the miner?)
+        Thread.pass if (nonce % 1000).zero?
+      end
+
       Block.new(number: base_block.number + 1, hash: digest(base_block, nonce, data), nonce: nonce, data: data)
     end
 

data/lib/lapidar/persistence.rb

@@ -0,0 +1,18 @@
+require "oj"
+
+module Lapidar
+  class Persistence
+    CONFIG_DIR = File.join(ENV["HOME"], ".lapidar")
+
+    def self.save_chain(filename, chain)
+      Dir.mkdir(CONFIG_DIR) unless File.exist?(CONFIG_DIR)
+      File.write(File.join(CONFIG_DIR, filename), Oj.dump(chain))
+    end
+
+    def self.load_chain(filename)
+      Oj.load(File.read(File.join(CONFIG_DIR, filename)))
+    rescue
+      nil
+    end
+  end
+end

data/lib/lapidar/runner.rb

@@ -0,0 +1,86 @@
+require "logger"
+
+module Lapidar
+  class Runner
+    attr_reader :chain, :punch_queue, :network_endpoint, :logger
+
+    def initialize(network_endpoint)
+      @logger = Logger.new(StringIO.new)
+      @network_endpoint = network_endpoint
+      @chain = Persistence.load_chain("#{@network_endpoint.port}.json") || Chain.new
+      @incoming_blocks = Queue.new
+      @punch_queue = SizedQueue.new(1)
+      @should_stop = nil
+      @threads = []
+    end
+
+    def start
+      @should_stop = false
+      @threads = [consumer, local_producer, network_producer]
+      @threads.each { |t| t.abort_on_exception = true }
+      @threads.each(&:join)
+    end
+
+    def stop
+      @should_stop = true
+      Thread.pass
+      Persistence.save_chain("#{@network_endpoint.port}.json", @chain)
+      @threads.each(&:exit)
+    end
+
+    private
+
+    def consumer
+      Thread.new do
+        until @should_stop
+          begin
+            @chain.add(@incoming_blocks.pop)
+            @logger.info("consumer") { "+" }
+          rescue => e
+            @logger.debug("consumer") { "Block cannot be added to chain: #{e.message}" }
+            @logger.info("consumer") { "_" }
+          end
+        end
+      end
+    end
+
+    def local_producer
+      Thread.new do
+        miner = Miner.new
+        until @should_stop
+          begin
+            new_block = miner.mine(@chain.blocks.last, @punch_queue.pop)
+            @network_endpoint.feed(Buschtelefon::Gossip.new(new_block.to_h.to_json))
+            @incoming_blocks << new_block
+            @logger.info("local_producer") { "!" }
+          rescue => e
+            @logger.debug("local_producer") { "Mint block isn't valid: #{e.message}" }
+            @logger.info("local_producer") { "F" }
+          end
+        end
+      end
+    end
+
+    def network_producer
+      Thread.new do
+        @network_endpoint.listen do |gossip|
+          break if @should_stop
+
+          begin
+            incoming_json = JSON.parse(gossip.message, symbolize_names: true)
+
+            @incoming_blocks << Block.new(
+              number: incoming_json[:number].to_i,
+              hash: incoming_json[:hash].to_s,
+              nonce: incoming_json[:nonce].to_i,
+              data: incoming_json[:data].to_s,
+              created_at: incoming_json[:created_at].to_f
+            )
+          rescue JSON::ParserError, ArgumentError => e
+            @logger.debug("network_producer") { "Incoming block isn't valid: #{e.message}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lapidar/version.rb

@@ -1,3 +1,3 @@
 module Lapidar
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lapidar
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Josua Schmid
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2019-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: buschtelefon
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: paint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -130,12 +158,15 @@ files:
 - bin/console
 - bin/run
 - bin/setup
+- docs/visualization.png
 - lapidar.gemspec
 - lib/lapidar.rb
 - lib/lapidar/assessment.rb
 - lib/lapidar/block.rb
 - lib/lapidar/chain.rb
 - lib/lapidar/miner.rb
+- lib/lapidar/persistence.rb
+- lib/lapidar/runner.rb
 - lib/lapidar/version.rb
 homepage: https://github.com/renuo/lapidar
 licenses: