vpndetection 5.4.2 → 5.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ccf5841f50ec64ff7328341110f3ec6cd0affc6260a0588fe22cb746d5d62f1
-  data.tar.gz: 99459a01b5d0139a64d039a2259a08c965cd4319c9cae6283dbbc0b113ac5b2c
+  metadata.gz: ba80a879812af8dc9d6cdefdb305d97fe38281550cad1b2c9bd76ab31b416bf2
+  data.tar.gz: 602fb1b3b602fa0ec12ca8d465dcda92e22d87610714ca31ec735033a83b61f6
 SHA512:
-  metadata.gz: fbdbee3d38ba2e223be9fc4e1cb53193f71e1891f0e59351d4c59f2eb2a8cc418476f48e0b866fb7c0b6d36fbb166686c46c22049deae80403f8a9a0675ab797
-  data.tar.gz: 94d1e3c266372d5b7fe571ea2d370a38dbd91cd11f184f3f06ef7b3f231ddddbc6a261551185a9020453d0704d8911c6c8b21e6de569cb43d4a4cba562d6684f
+  metadata.gz: 340fbe8a1a6265f5dec5d5e93fecd2c63c171af83699fdc073ac98410d83e2ec4924c2b358c4a30785f3aeebb8b606cbefa0eeba0c54f402fda60a03dda1f843
+  data.tar.gz: eae9ca20b51fbb6d12060add25b281625c5096e9b54fd7ef1b596a8c54c476589fc09662c117c4eeb879556482fe7caa9056c0b81581af98d739079df544d557

data/lib/vpndetection/client.rb

@@ -49,6 +49,9 @@ module VPNDetection
         Transport::Config.new(api_key: api_key, base_url: base_url, timeout: timeout),
       )
       @cache = cache ? Cache.new(max_size: cache_max_size, ttl: cache_ttl) : nil
+      # The addresses with a request in flight, each a Flight its waiters block on.
+      @flights = {}
+      @flights_lock = Mutex.new
       @concurrency = concurrency
       @retries = retries
       @database = DatabaseApi.new(@transport, retries: retries)
@@ -78,14 +81,26 @@ module VPNDetection
       Transport.checked_timeout(timeout) unless timeout.nil?
       return Bogon.result(ip) if Bogon.bogon?(ip)
 
-      hit = @cache&.get(ip)
-      return hit unless hit.nil?
+      loop do
+        hit = @cache&.get(ip)
+        return hit unless hit.nil?
 
-      result = Retries.with_retries(retries || @retries) do
-        Transport.lookup_result(@transport.lookup_request(ip, timeout: timeout).run)
+        flight, leader = board(ip)
+        return fetch(ip, retries, timeout) if flight.nil?
+
+        if leader
+          # Read once more now the address is boarded: a leader that landed
+          # between the miss above and boarding has already cached its answer.
+          hit = @cache.get(ip)
+          return unboard(ip, flight, :served, hit) unless hit.nil?
+
+          return lead(ip, flight) { fetch(ip, retries, timeout) }
+        end
+        state, value = flight.wait
+        return value if state == :served
+        raise value if state == :failed
+        # :abandoned - its leader never finished, so this caller asks again.
       end
-      @cache&.set(ip, result)
-      result
     end
 
     # Classify the address this client is calling from.
@@ -160,9 +175,27 @@ module VPNDetection
         hit = Bogon.bogon?(ip) ? Bogon.result(ip) : @cache&.get(ip)
         hit.nil? ? pending << ip : answers[ip] = hit
       end
-      unless pending.empty?
-        run_batch(pending.each_slice(BATCH_MAX).to_a, answers, limit, retries || @retries, timeout)
+      # Boarded before any chunk is built, so a lookup arriving meanwhile waits
+      # for this batch; an address already in flight is not sent again.
+      boarded = {}
+      joined = {}
+      pending.each do |ip|
+        flight, leader = board(ip)
+        if leader == false
+          joined[ip] = flight
+        else
+          boarded[ip] = flight
+        end
+      end
+      begin
+        unless boarded.empty?
+          chunks = boarded.keys.each_slice(BATCH_MAX).to_a
+          run_batch(chunks, answers, limit, retries || @retries, timeout, boarded)
+        end
+      ensure
+        boarded.each { |ip, flight| unboard(ip, flight, :abandoned) unless flight.nil? }
       end
+      joined.each { |ip, flight| answers[ip] = joined_answer(ip, flight, retries, timeout) }
 
       # Reinstated in input order: a hydra settles in completion order, and a
       # caller iterating the hash should see what they passed in.
@@ -171,11 +204,83 @@ module VPNDetection
 
     private
 
+    # Concurrent misses for one address share ONE request (docs/sdk/contract.md,
+    # UMAN-4645): 5.4.2 sent one per calling thread. The first miss boards the
+    # address and every miss after it, a batch's included, waits on its Flight.
+    class Flight
+      def initialize
+        @lock = Mutex.new
+        @landed = ConditionVariable.new
+        @state = :pending
+      end
+
+      # Settles the flight once, for every waiter: :served with a Result,
+      # :failed with an Error, or :abandoned when its leader never finished.
+      def land(state, value = nil)
+        @lock.synchronize do
+          next unless @state == :pending
+
+          @state = state
+          @value = value
+          @landed.broadcast
+        end
+      end
+
+      # Blocks until the flight lands, then [state, value].
+      def wait
+        @lock.synchronize do
+          @landed.wait(@lock) while @state == :pending
+          [@state, @value]
+        end
+      end
+    end
+
+    # [flight, true] when this caller leads the request for `ip`, [flight,
+    # false] when one is already in flight, and nil without a cache: every
+    # lookup is then served, so nothing is shared.
+    def board(ip)
+      return nil if @cache.nil?
+
+      @flights_lock.synchronize do
+        existing = @flights[ip]
+        existing ? [existing, false] : [@flights[ip] = Flight.new, true]
+      end
+    end
+
+    # Takes `ip` off the board and lands its flight. Returns `value`.
+    def unboard(ip, flight, state, value = nil)
+      @flights_lock.synchronize { @flights.delete(ip) if @flights[ip].equal?(flight) }
+      flight.land(state, value)
+      value
+    end
+
+    # Runs the request a flight is waiting on, under the options of the call
+    # that leads it. A served answer is cached before it lands; a failure
+    # reaches every waiter and is cached for none; and a leader that never
+    # finishes - a killed thread, a Timeout.timeout - abandons the flight, so
+    # its waiters ask again rather than failing with it.
+    def lead(ip, flight)
+      unboard(ip, flight, :served, yield)
+    rescue Error => e
+      unboard(ip, flight, :failed, e)
+      raise
+    ensure
+      unboard(ip, flight, :abandoned)
+    end
+
+    def fetch(ip, retries, timeout)
+      result = Retries.with_retries(retries || @retries) do
+        Transport.lookup_result(@transport.lookup_request(ip, timeout: timeout).run)
+      end
+      @cache&.set(ip, result)
+      result
+    end
+
     # One hydra per call, sized for THIS call. Reusing an instance-level hydra
     # would silently cap a per-call concurrency at the client's setting, and
     # would not be safe to drive from two threads either. Each request is one
     # chunk of up to 1000 addresses.
-    def run_batch(chunks, answers, concurrency, retries, timeout)
+    def run_batch(chunks, answers, concurrency, retries, timeout, boarded)
       hydra = Typhoeus::Hydra.new(max_concurrency: concurrency)
       attempts = Hash.new(0)
 
@@ -183,7 +288,11 @@ module VPNDetection
         request = @transport.batch_request(chunk, timeout: timeout)
         request.on_complete do |response|
           outcome = settle(chunk, response, attempts, retries, enqueue)
-          answers.merge!(outcome) unless outcome.nil?
+          outcome&.each do |ip, answer|
+            answers[ip] = answer
+            flight = boarded[ip]
+            unboard(ip, flight, answer.is_a?(Result) ? :served : :failed, answer) unless flight.nil?
+          end
         end
         hydra.queue(request)
       end
@@ -214,6 +323,17 @@ module VPNDetection
       nil
     end
 
+    # What a batch takes for an address another call was fetching: that call's
+    # answer or error, or, when its leader never finished, its own lookup.
+    def joined_answer(ip, flight, retries, timeout)
+      state, value = flight.wait
+      return value unless state == :abandoned
+
+      lookup(ip, retries: retries, timeout: timeout)
+    rescue Error => e
+      e
+    end
+
     # Every address lands in exactly one of `results` and `errors`; an address in
     # neither is the server breaking its own contract, and is reported as such
     # rather than lost.

data/lib/vpndetection/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module VPNDetection
-  VERSION = '5.4.2'
+  VERSION = '5.4.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vpndetection
 version: !ruby/object:Gem::Version
-  version: 5.4.2
+  version: 5.4.3
 platform: ruby
 authors:
 - Mslm Dev