knapsack_pro 2.2.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da894046fe3bb6c6f7d3042ed03e9181a795d039c53ccd11bb94e40f0435d7c8
-  data.tar.gz: 246cc29e1c0d255e2a822847de009f4efe1c5bee09bf2c79453a2fa146e5c241
+  metadata.gz: a36ff1388dd1ad1c95c0fd5041fc771d27f28b36c0d02773fa8205ae4812818b
+  data.tar.gz: c07a145c9d4f62d9901cb1bb2122662ca57c69a75d8dd500771799af215204a0
 SHA512:
-  metadata.gz: bed442bb1ea7c2aacd84f8ee7989f03cf8fe1ef4ebe051d07f1b1261e9cee94abd355625c31d682faf9c077e978dd3876c2b6fd18497590dd919692e76640812
-  data.tar.gz: 3e3938594bc73b62871689fb649fe6e5b74ce5c4fac8e935f805d2a3030e19f96db5424f8c78d32fd74cbe7922f3385483d2deb91d85c9d2920eaf3085e2d61a
+  metadata.gz: 8aeb03d459916e73d5281fc28293300acc6e375747954afd070ef34cc062e08d603dee4bea5e614850ca723f15f3e926a69e7f0efee1399c02320baee0d18100
+  data.tar.gz: 1ac8483c14d798c0b4f8f163846e2f3e922223dad285516674568998ada15a917633a34b243b571b5f2e11f3d2a8d1086390ac1c39abd3205cb3c17aedf26c4f

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Change Log
 
+### 2.3.0
+
+* When you use Regular Mode then try 6 attempts to connect to the API instead of 3 attempts
+
+    Add `KNAPSACK_PRO_MAX_REQUEST_RETRIES` environment variable to let user define their own number of request retries to the API. It is useful to set it to `0` for [forked repos](https://knapsackpro.com/faq/question/how-to-make-knapsack_pro-works-for-forked-repositories-of-my-project) when you want to relay on Fallback Mode.
+
+    https://github.com/KnapsackPro/knapsack_pro-ruby/pull/124
+
+https://github.com/KnapsackPro/knapsack_pro-ruby/compare/v2.2.1...v2.3.0
+
 ### 2.2.1
 
 * Improve detection of test file path in test-unit runner for test files with shared examples

data/README.md

@@ -2320,11 +2320,19 @@ There are a few ways to reproduce tests executed on CI node in your development
 
 ##### for knapsack_pro regular mode
 
-knapsack_pro gem will retry requests to Knapsack Pro API multiple times every few seconds til it switch to fallback behavior and it will split test files across CI nodes based on popular test directory names. When knapsack_pro starts fallback mode then you will see a warning in the output.
+knapsack_pro gem will retry requests to Knapsack Pro API multiple times every few seconds till it switchs to fallback behavior (Fallback Mode) and it will split test files across CI nodes based on popular test directory names. When knapsack_pro starts Fallback Mode then you will see a warning in the output.
+
+Note there is an unlikely scenario when some of the CI nodes may start in Fallback Mode but others don't and then it could happen that some of test files might be skipped. You should [read this to learn more](https://github.com/KnapsackPro/knapsack_pro-ruby/pull/124) and decide if you like to use Fallback Mode when running tests with knapsack_pro Regular Mode.
+
+If your CI provider allows to retry only one of parallel CI nodes then please [read about this edge case as well](#required-ci-configuration-if-you-use-retry-single-failed-ci-node-feature-on-your-ci-server-when-knapsack_pro_fixed_queue_splittrue-in-queue-mode-or-knapsack_pro_fixed_test_suite_splittrue-in-regular-mode).
 
 ##### for knapsack_pro queue mode
 
-knapsack_pro gem will retry requests to Knapsack Pro API multiple times every few seconds till it switches to fallback behavior and it will split test files across CI nodes based on popular test directory names. Note that if one of CI nodes will lose connection to Knapsack Pro API but other not then you may see that some of the test files will be executed on multiple CI nodes. Fallback mode guarantees each of test files is run at least once across CI nodes. Thanks to that we know if the whole test suite is green or not. When knapsack_pro starts fallback mode then you will see a warning in the output.
+knapsack_pro gem will retry requests to Knapsack Pro API multiple times every few seconds till it switches to fallback behavior (Fallback Mode) and it will split test files across CI nodes based on popular test directory names.
+
+Note that if one of the CI nodes will lose connection to Knapsack Pro API but other not then you may see that some of the test files will be executed on multiple CI nodes. **Fallback Mode guarantees each of the test files is run at least once across CI nodes when you use knapsack_pro in Queue Mode.** Thanks to that we know if the whole test suite is green or not. When knapsack_pro starts Fallback Mode then you will see a warning in the output.
+
+If your CI provider allows to retry only one of parallel CI nodes then please [read about this edge case as well](#required-ci-configuration-if-you-use-retry-single-failed-ci-node-feature-on-your-ci-server-when-knapsack_pro_fixed_queue_splittrue-in-queue-mode-or-knapsack_pro_fixed_test_suite_splittrue-in-regular-mode).
 
 #### How can I change log level?
 

data/lib/knapsack_pro/client/connection.rb

@@ -4,7 +4,6 @@ module KnapsackPro
       class ServerError < StandardError; end
 
       TIMEOUT = 15
-      MAX_RETRY = -> { KnapsackPro::Config::Env.fallback_mode_enabled? ? 3 : 6 }
       REQUEST_RETRY_TIMEBOX = 8
 
       def initialize(action)
@@ -118,7 +117,7 @@ module KnapsackPro
       rescue ServerError, Errno::ECONNREFUSED, Errno::ETIMEDOUT, Errno::EPIPE, EOFError, SocketError, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError => e
         logger.warn(e.inspect)
         retries += 1
-        if retries < MAX_RETRY.call
+        if retries < max_request_retries
           wait = retries * REQUEST_RETRY_TIMEBOX
           logger.warn("Wait #{wait}s and retry request to Knapsack Pro API.")
           print_every = 2 # seconds
@@ -156,6 +155,22 @@ module KnapsackPro
           http.get(uri, json_headers)
         end
       end
+
+      def max_request_retries
+        # when user defined max request retries
+        return KnapsackPro::Config::Env.max_request_retries if KnapsackPro::Config::Env.max_request_retries
+
+        # when Fallback Mode is disabled then try more attempts to connect to the API
+        return 6 unless KnapsackPro::Config::Env.fallback_mode_enabled?
+
+        # when Regular Mode then try more attempts to connect to the API
+        # if only one CI node starts Fallback Mode instead of all then we can't guarantee all test files will be run
+        # https://github.com/KnapsackPro/knapsack_pro-ruby/pull/124
+        return 6 if KnapsackPro::Config::Env.regular_mode?
+
+        # default number of attempts
+        3
+      end
     end
   end
 end

data/lib/knapsack_pro/config/env.rb

@@ -36,6 +36,13 @@ module KnapsackPro
           ).to_i
         end
 
+        def max_request_retries
+          number = ENV['KNAPSACK_PRO_MAX_REQUEST_RETRIES']
+          if number
+            number.to_i
+          end
+        end
+
         def commit_hash
           ENV['KNAPSACK_PRO_COMMIT_HASH'] ||
             ci_env_for(:commit_hash)
@@ -83,6 +90,10 @@ module KnapsackPro
           recording_enabled == 'true'
         end
 
+        def regular_mode?
+          recording_enabled?
+        end
+
         def queue_recording_enabled
           ENV['KNAPSACK_PRO_QUEUE_RECORDING_ENABLED']
         end

data/lib/knapsack_pro/version.rb

@@ -1,3 +1,3 @@
 module KnapsackPro
-  VERSION = '2.2.1'
+  VERSION = '2.3.0'
 end

data/spec/knapsack_pro/client/connection_spec.rb

@@ -108,6 +108,53 @@ shared_examples 'when retry request' do
       expect(connection.errors?).to be true
     end
 
+    context 'when max request retries defined' do
+      before do
+        expect(KnapsackPro::Config::Env).to receive(:max_request_retries).at_least(1).and_return(4)
+      end
+
+      it do
+        expect(logger).to receive(:debug).exactly(4).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+        expect(logger).to receive(:debug).exactly(4).with('API request UUID: fake-uuid')
+        expect(logger).to receive(:debug).exactly(4).with('API response:')
+
+        parsed_response = { 'error' => 'Internal Server Error' }
+
+        expect(logger).to receive(:error).exactly(4).with(parsed_response)
+
+        server_error = described_class::ServerError.new(parsed_response)
+        expect(logger).to receive(:warn).exactly(4).with(server_error.inspect)
+
+        expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("Next request in 8s...")
+        expect(logger).to receive(:warn).with("Next request in 6s...")
+        expect(logger).to receive(:warn).with("Next request in 4s...")
+        expect(logger).to receive(:warn).with("Next request in 2s...")
+
+        expect(logger).to receive(:warn).with("Wait 16s and retry request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("Next request in 16s...")
+        expect(logger).to receive(:warn).with("Next request in 14s...")
+        expect(logger).to receive(:warn).with("Next request in 12s...")
+        expect(logger).to receive(:warn).with("Next request in 10s...")
+        expect(logger).to receive(:warn).with("Next request in 8s...")
+        expect(logger).to receive(:warn).with("Next request in 6s...")
+        expect(logger).to receive(:warn).with("Next request in 4s...")
+        expect(logger).to receive(:warn).with("Next request in 2s...")
+
+        expect(logger).to receive(:warn).with("Wait 24s and retry request to Knapsack Pro API.")
+        12.times do |i|
+          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        end
+
+        expect(Kernel).to receive(:sleep).exactly(4+8+12).with(2)
+
+        expect(subject).to eq(parsed_response)
+
+        expect(connection.success?).to be false
+        expect(connection.errors?).to be true
+      end
+    end
+
     context 'when Fallback Mode is disabled' do
       before do
         expect(KnapsackPro::Config::Env).to receive(:fallback_mode_enabled?).at_least(1).and_return(false)
@@ -164,6 +211,63 @@ shared_examples 'when retry request' do
         expect(connection.errors?).to be true
       end
     end
+
+    context 'when Regular Mode' do
+      before do
+        expect(KnapsackPro::Config::Env).to receive(:regular_mode?).at_least(1).and_return(true)
+      end
+
+      it do
+        expect(logger).to receive(:debug).exactly(6).with("#{expected_http_method} http://api.knapsackpro.test:3000/v1/fake_endpoint")
+        expect(logger).to receive(:debug).exactly(6).with('API request UUID: fake-uuid')
+        expect(logger).to receive(:debug).exactly(6).with('API response:')
+
+        parsed_response = { 'error' => 'Internal Server Error' }
+
+        expect(logger).to receive(:error).exactly(6).with(parsed_response)
+
+        server_error = described_class::ServerError.new(parsed_response)
+        expect(logger).to receive(:warn).exactly(6).with(server_error.inspect)
+
+        expect(logger).to receive(:warn).with("Wait 8s and retry request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("Next request in 8s...")
+        expect(logger).to receive(:warn).with("Next request in 6s...")
+        expect(logger).to receive(:warn).with("Next request in 4s...")
+        expect(logger).to receive(:warn).with("Next request in 2s...")
+
+        expect(logger).to receive(:warn).with("Wait 16s and retry request to Knapsack Pro API.")
+        expect(logger).to receive(:warn).with("Next request in 16s...")
+        expect(logger).to receive(:warn).with("Next request in 14s...")
+        expect(logger).to receive(:warn).with("Next request in 12s...")
+        expect(logger).to receive(:warn).with("Next request in 10s...")
+        expect(logger).to receive(:warn).with("Next request in 8s...")
+        expect(logger).to receive(:warn).with("Next request in 6s...")
+        expect(logger).to receive(:warn).with("Next request in 4s...")
+        expect(logger).to receive(:warn).with("Next request in 2s...")
+
+        expect(logger).to receive(:warn).with("Wait 24s and retry request to Knapsack Pro API.")
+        12.times do |i|
+          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        end
+
+        expect(logger).to receive(:warn).with("Wait 32s and retry request to Knapsack Pro API.")
+        16.times do |i|
+          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        end
+
+        expect(logger).to receive(:warn).with("Wait 40s and retry request to Knapsack Pro API.")
+        20.times do |i|
+          expect(logger).to receive(:warn).with("Next request in #{(i+1)*2}s...")
+        end
+
+        expect(Kernel).to receive(:sleep).exactly(60).with(2)
+
+        expect(subject).to eq(parsed_response)
+
+        expect(connection.success?).to be false
+        expect(connection.errors?).to be true
+      end
+    end
   end
 end
 

data/spec/knapsack_pro/config/env_spec.rb

@@ -100,6 +100,19 @@ describe KnapsackPro::Config::Env do
     end
   end
 
+  describe '.max_request_retries' do
+    subject { described_class.max_request_retries }
+
+    context 'when ENV exists' do
+      before { stub_const("ENV", { 'KNAPSACK_PRO_MAX_REQUEST_RETRIES' => '2' }) }
+      it { should eq 2 }
+    end
+
+    context "when ENV doesn't exist" do
+      it { should be_nil }
+    end
+  end
+
   describe '.commit_hash' do
     subject { described_class.commit_hash }
 
@@ -267,6 +280,25 @@ describe KnapsackPro::Config::Env do
     end
   end
 
+
+  describe '.regular_mode?' do
+    subject { described_class.regular_mode? }
+
+    before do
+      expect(described_class).to receive(:recording_enabled?).and_return(recording_enabled)
+    end
+
+    context 'when recording is enabled' do
+      let(:recording_enabled) { true }
+      it { should be true }
+    end
+
+    context 'when recording is not enabled' do
+      let(:recording_enabled) { false }
+      it { should be false }
+    end
+  end
+
   describe '.recording_enabled?' do
     subject { described_class.recording_enabled? }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: knapsack_pro
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.3.0
 platform: ruby
 authors:
 - ArturT
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-04 00:00:00.000000000 Z
+date: 2020-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake