zold 0.17.3 → 0.17.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b180bc5d7ff240eafaa73f624652f2842cd576f3c43b87642e77d37716249a1
-  data.tar.gz: '0279c65c274f3725bf91ab3ba0b93ed60aca6b9db2edf7ab2a4f546818104acb'
+  metadata.gz: 622a8738f318299d195dd0efbe8cdb8bc41aac3432a964b775a31a1b78cc592f
+  data.tar.gz: 06ed79ff0550b5e4f66eb28af66051b14b3d840caf4ea936cfd40b36e6693124
 SHA512:
-  metadata.gz: d840735668e54a0d8c88f7161c273631de34c06a938f7232cecbe61e11fe74ebac60fd0f810fcb832ff3b26b73ceb37e4d45a7d9529d6e7f0dda18bce433ad69
-  data.tar.gz: 9ebec3e75b50640543bf569f0957e1808af5f7bb5d82316bf21b58c7f98cec23961a40ed4297a73a52693c9054923c719a34b68bdf2f6e8cf586cad2256c013f
+  metadata.gz: d0e4e8282e87e826b31e3662f0139aa4e0634c4d5e7d2cdb13b48a8958bb48557c007605a4f07d79f50b678acf7beab1860ddb1283b2819b00b66f208ab3b850
+  data.tar.gz: 9a4fb162a36f9db69b3c5916ffca1658c75ea3450b975e05d29054a6b6da991e46e4bdb6c201394a724dcf1461284e1d1a101a000a09bdfebec2420a5c9957f5

data/lib/zold/commands/node.rb

@@ -251,8 +251,8 @@ module Zold
       ).start do |entrance|
         Front.set(:entrance, entrance)
         farmer = opts['no-spawn'] ? Farmers::Plain.new : Farmers::Fork.new(log: @log)
-        Farm.new(invoice, File.join(home, 'farm'), log: @log, farmer: farmer)
-          .start(host, opts[:port], threads: opts[:threads], strength: opts[:strength]) do |farm|
+        Farm.new(invoice, File.join(home, 'farm'), log: @log, farmer: farmer, strength: opts[:strength])
+          .start(host, opts[:port], threads: opts[:threads]) do |farm|
           Front.set(:farm, farm)
           metronome(farm, opts).start do |metronome|
             Front.set(:metronome, metronome)

data/lib/zold/node/farm.rb

@@ -58,7 +58,7 @@ module Zold
     # it's the entire day, since the Score expires in 24 hours; can be decreased for the
     # purpose of unit testing.
     def initialize(invoice, cache = File.join(Dir.pwd, 'farm'), log: Log::NULL,
-      farmer: Farmers::Plain.new, lifetime: 24 * 60 * 60)
+      farmer: Farmers::Plain.new, lifetime: 24 * 60 * 60, strength: Score::STRENGTH)
       @log = log
       @cache = File.expand_path(cache)
       @invoice = invoice
@@ -66,6 +66,7 @@ module Zold
       @farmer = farmer
       @threads = []
       @lifetime = lifetime
+      @strength = strength
     end
 
     # Returns the list of best scores the farm managed to find up to now. The
@@ -112,7 +113,7 @@ module Zold
     #
     # The farm will stop all its threads and close all resources safely
     # right after the block provided exists.
-    def start(host, port, strength: Score::STRENGTH, threads: Concurrent.processor_count)
+    def start(host, port, threads: Concurrent.processor_count)
       raise 'Block is required for the farm to start' unless block_given?
       @log.info('Zero-threads farm won\'t score anything!') if threads.zero?
       if best.empty?
@@ -124,7 +125,7 @@ module Zold
         Thread.new do
           Thread.current.thread_variable_set(:tid, t.to_s)
           Endless.new("f#{t}", log: @log).run do
-            cycle(host, port, strength, threads)
+            cycle(host, port, threads)
           end
         end
       end
@@ -132,7 +133,7 @@ module Zold
         ready = false
         @threads << Thread.new do
           Endless.new('cleanup', log: @log).run do
-            cleanup(host, port, strength, threads)
+            cleanup(host, port, threads)
             ready = true
             sleep(1)
           end
@@ -140,26 +141,26 @@ module Zold
         loop { break if ready }
       end
       if @threads.empty?
-        cleanup(host, port, strength, threads)
+        cleanup(host, port, threads)
         @log.info("Farm started with no threads (there will be no score) at #{host}:#{port}")
       else
         @log.info("Farm started with #{@threads.count} threads (one for cleanup) \
-at #{host}:#{port}, strength is #{strength}")
+at #{host}:#{port}, strength is #{@strength}")
       end
       begin
         yield(self)
       ensure
         @threads.each(&:kill)
-        @log.info("Farm stopped (threads=#{threads}, strength=#{strength})")
+        @log.info("Farm stopped (threads=#{threads}, strength=#{@strength})")
       end
     end
 
     private
 
-    def cleanup(host, port, strength, threads)
+    def cleanup(host, port, threads)
       scores = load
       before = scores.map(&:value).max.to_i
-      save(threads, [Score.new(host: host, port: port, invoice: @invoice, strength: strength)])
+      save(threads, [Score.new(host: host, port: port, invoice: @invoice, strength: @strength)])
       scores = load
       free = scores.reject { |s| @threads.find { |t| t.name == s.to_mnemo } }
       @pipeline << free[0] if @pipeline.size.zero? && !free.empty?
@@ -168,7 +169,7 @@ at #{host}:#{port}, strength is #{strength}")
       @log.debug("#{Thread.current.name}: best score of #{scores.count} is #{scores[0]}")
     end
 
-    def cycle(host, port, strength, threads)
+    def cycle(host, port, threads)
       s = []
       loop do
         begin
@@ -183,13 +184,13 @@ at #{host}:#{port}, strength is #{strength}")
       return unless s.valid?
       return unless s.host == host
       return unless s.port == port
-      return unless s.strength >= strength
+      return unless s.strength >= @strength
       Thread.current.name = s.to_mnemo
       Thread.current.thread_variable_set(:start, Time.now.utc.iso8601)
       score = @farmer.up(s)
-      @log.debug("New score discovered: #{score}") if strength > 4
+      @log.debug("New score discovered: #{score}") if @strength > 4
       save(threads, [score])
-      cleanup(host, port, strength, threads)
+      cleanup(host, port, threads)
     end
 
     def save(threads, list = [])
@@ -200,6 +201,7 @@ at #{host}:#{port}, strength is #{strength}")
           f,
           scores.select(&:valid?)
             .reject(&:expired?)
+            .reject { |s| s.strength < @strength }
             .sort_by(&:value)
             .reverse
             .uniq(&:time)

data/lib/zold/version.rb

@@ -25,6 +25,6 @@
 # Copyright:: Copyright (c) 2018 Yegor Bugayenko
 # License:: MIT
 module Zold
-  VERSION = '0.17.3'
+  VERSION = '0.17.4'
   PROTOCOL = 2
 end

data/test/node/test_farm.rb

@@ -30,8 +30,8 @@ require_relative '../../lib/zold/node/farm'
 class FarmTest < Zold::Test
   def test_renders_in_json
     Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'), log: test_log)
-      farm.start('localhost', 80, threads: 2, strength: 2) do
+      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'), log: test_log, strength: 2)
+      farm.start('localhost', 80, threads: 2) do
         assert_wait { !farm.best.empty? && !farm.best[0].value.zero? }
         count = 0
         100.times { count += farm.to_json[:best].length }
@@ -42,8 +42,8 @@ class FarmTest < Zold::Test
 
   def test_renders_in_text
     Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX7@ffffffffffffffff', File.join(dir, 'f'), log: test_log)
-      farm.start('localhost', 80, threads: 2, strength: 1) do
+      farm = Zold::Farm.new('NOPREFIX7@ffffffffffffffff', File.join(dir, 'f'), log: test_log, strength: 1)
+      farm.start('localhost', 80, threads: 2) do
         assert(!farm.to_text.nil?)
       end
     end
@@ -52,8 +52,8 @@ class FarmTest < Zold::Test
   def test_makes_many_scores
     Dir.mktmpdir do |dir|
       farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'),
-        log: test_log, lifetime: 10, farmer: Zold::Farmers::Plain.new)
-      farm.start('localhost', 80, threads: 4, strength: 1) do
+        log: test_log, lifetime: 10, farmer: Zold::Farmers::Plain.new, strength: 1)
+      farm.start('localhost', 80, threads: 4) do
         assert_wait { farm.best.length == 4 }
       end
     end
@@ -67,8 +67,8 @@ class FarmTest < Zold::Test
   #  that it's usually a few microseconds, but sometimes over 200ms.
   def test_reads_scores_at_high_speed
     Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'), log: test_log)
-      farm.start('localhost', 80, threads: 4, strength: 4) do
+      farm = Zold::Farm.new('NOPREFIX6@ffffffffffffffff', File.join(dir, 'f'), log: test_log, strength: 4)
+      farm.start('localhost', 80, threads: 4) do
         assert_wait { !farm.best.empty? && !farm.best[0].value.zero? }
         cycles = 100
         speed = (0..cycles - 1).map do
@@ -83,8 +83,8 @@ class FarmTest < Zold::Test
 
   def test_makes_best_score_in_background
     Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX1@ffffffffffffffff', File.join(dir, 'f'), log: test_log)
-      farm.start('localhost', 80, threads: 1, strength: 3) do
+      farm = Zold::Farm.new('NOPREFIX1@ffffffffffffffff', File.join(dir, 'f'), log: test_log, strength: 3)
+      farm.start('localhost', 80, threads: 1) do
         assert_wait { !farm.best.empty? && farm.best[0].value >= 3 }
         score = farm.best[0]
         assert(!score.expired?)
@@ -95,8 +95,8 @@ class FarmTest < Zold::Test
 
   def test_correct_score_from_empty_farm
     Dir.mktmpdir do |dir|
-      farm = Zold::Farm.new('NOPREFIX2@cccccccccccccccc', File.join(dir, 'f'), log: test_log)
-      farm.start('example.com', 8080, threads: 0, strength: 1) do
+      farm = Zold::Farm.new('NOPREFIX2@cccccccccccccccc', File.join(dir, 'f'), log: test_log, strength: 1)
+      farm.start('example.com', 8080, threads: 0) do
         score = farm.best[0]
         assert(!score.expired?)
         assert_equal(0, score.value)
@@ -109,8 +109,8 @@ class FarmTest < Zold::Test
   def test_pre_loads_history
     Dir.mktmpdir do |dir|
       cache = File.join(dir, 'a/b/c/cache')
-      farm = Zold::Farm.new('NOPREFIX3@cccccccccccccccc', cache, log: test_log)
-      farm.start('example.com', 8080, threads: 0, strength: 1) do
+      farm = Zold::Farm.new('NOPREFIX3@cccccccccccccccc', cache, log: test_log, strength: 1)
+      farm.start('example.com', 8080, threads: 0) do
         score = farm.best[0]
         assert(!score.nil?, 'The list of best scores can\'t be empty!')
         assert(File.exist?(cache), 'The cache file has to be created!')
@@ -132,8 +132,8 @@ class FarmTest < Zold::Test
         strength: 6
       )
       IO.write(cache, score.to_s)
-      farm = Zold::Farm.new('NOPREFIX4@ffffffffffffffff', cache, log: test_log)
-      farm.start(score.host, score.port, threads: 1, strength: score.strength) do
+      farm = Zold::Farm.new('NOPREFIX4@ffffffffffffffff', cache, log: test_log, strength: score.strength)
+      farm.start(score.host, score.port, threads: 1) do
         100.times do
           sleep(0.1)
           b = farm.best[0]
@@ -170,7 +170,7 @@ class FarmTest < Zold::Test
   end
 
   def test_terminates_farm_entirely
-    Zold::Farm.new('NOPREFIX4@ffffffffffffffff', log: test_log).start('localhost', 4096, threads: 1, strength: 10) do
+    Zold::Farm.new('NOPREFIX4@ffffffffffffffff', log: test_log, strength: 10).start('localhost', 4096, threads: 1) do
       sleep 1
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zold
 version: !ruby/object:Gem::Version
-  version: 0.17.3
+  version: 0.17.4
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -711,7 +711,7 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: |-
-  Thanks for installing Zold 0.17.3!
+  Thanks for installing Zold 0.17.4!
     Study our White Paper: https://papers.zold.io/wp.pdf
     Read our blog posts: https://blog.zold.io
     Try online wallet at: https://wts.zold.io