bridge_api 0.1.66 → 0.1.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9ca9ab902293aba483f19e3672a1c0c60aa19c2aca4175bf34a2a4db7bae6d8
-  data.tar.gz: 004f3fee360e5c413572bf7f636ed75f8e765936668bf03a6fa7437e6b5b0441
+  metadata.gz: 29e3ffa7d065173483c89fd670fffd88f8b097a9aa90738bbcb89dee537f9b26
+  data.tar.gz: ba246bb521802607f2c7b54796fe3fe37b4e0b54f11f8d034c020d58a7b13604
 SHA512:
-  metadata.gz: 9c5475c3391696f44fc7564fe112bfb07c850bdd9ba4c8d29164f4db30ebbdd7d17f02a096a4dbcbc4b5193c57716d66f733f2ab6e913544216389f13a8c1871
-  data.tar.gz: 82a529c351861196e9a0cce6bcc0e581120af60cc709d75526ac8de6dd6c5f5c8b9ba20c9c4e15b00b646b8144a350f40fa5a1c91ec96b3d28644eb1dca3716a
+  metadata.gz: 0b7cd2e583404e406976e7a6fa264900125772525ab11caa3397d47466c052e825b5f91dc119edcc7fd98990a2b2603afa17c5f083ea57f0e9928855be32ca65
+  data.tar.gz: e63612d06e0049d375ffbcb63e7b912a1baea391565680b5bbcbb6e7aa2fbe43b5cdfe37080d545cb4e7a5ea62feea7b86a8f50d73306504b3de1ad6457dc88b

data/lib/bridge_api/client.rb

@@ -62,13 +62,6 @@ module BridgeAPI
 
     # Override Footrest request for ApiArray support
     def request(method, &block)
-      if has_token_pool?(config)
-        (config[:api_tokens] || config[:api_keys].keys).size.times do
-          break unless rate_limit_reached?
-
-          rotate_token!
-        end
-      end
       enforce_rate_limits if rate_limit_reached?
       response = connection.send(method, &block)
       apply_rate_limits(response)
@@ -80,45 +73,46 @@ module BridgeAPI
         config[:api_tokens].is_a?(Array) && config[:api_tokens].count >= 1
     end
 
-    # Since a pool is passed in, initialize first token with the first token passed in
-    def initialize_from_token_pool(config)
-      if config[:api_keys].is_a?(Hash)
-        creds = config[:api_keys].first
-        config[:api_key]    ||= creds[0]
-        config[:api_secret] ||= creds[1]
-      elsif config[:api_tokens].is_a?(Array)
-        config[:token] ||= config[:api_tokens].first
+    def convert_tokens(config)
+      return config unless config.has_key?(:api_tokens)
+      return config unless config[:api_tokens].is_a?(Array)
+      config[:api_keys] ||= {}
+      config[:api_tokens].each do |token|
+        decoded_token_array = Base64.strict_decode64(token).split(':')
+        config[:api_keys][decoded_token_array[0]] = decoded_token_array[1]
       end
+      config.delete(:api_tokens)
+      config
+    end
+
+    def initialize_from_token_pool(config)
+      config = convert_tokens(config)  
+      creds = config[:api_keys].first
+      config[:api_key]    ||= creds[0]
+      config[:api_secret] ||= creds[1]
       config
     end
 
     # rotates to the next token in the pool (by order in which they were provided)
-    def rotate_token!
-      BridgeAPI.master_mutex.synchronize do
-        old_api_key = config[:api_key]
-        if config[:api_keys].is_a?(Hash)
-          keys = config[:api_keys].keys
-          return if keys.count <= 1
-
-          key                 = get_next_key(keys, config[:api_key])
-          config[:api_key]    = key
-          config[:api_secret] = config[:api_keys][key]
-        elsif config[:api_tokens].is_a?(Array)
-          keys = config[:api_tokens]
-          return if keys.count <= 1
-
-          token = get_next_key(keys, config[:token])
-          config[:token] = token
-        end
-        BridgeAPI.logger.debug('rotating API Keys')
-        set_connection(config)
-      end
+    def rotate_token! 
+      old_api_key = config[:api_key]
+      keys = config[:api_keys].keys
+      return if keys.count <= 1
+      key                 = get_next_key(keys, config[:api_key])
+      config[:api_key]    = key
+      config[:api_secret] = config[:api_keys][key]
+      set_connection(config)
+      BridgeAPI.logger.debug("ROTATED TO KEY: #{config[:api_key]}")
     end
 
     def get_next_key(keys, current_key)
-      i = keys.index(current_key) || -1
-      i = (i + 2) > keys.count ? 0 : (i + 1)
-      keys[i]
+      keys.delete(current_key)
+      usable_key = keys.find do |key|
+        limit = rate_limit(key)
+        current_key_limit = limit.present? ? limit.fetch('current') : 0
+        BridgeAPI.beginning_rate_limit - current_key_limit > BridgeAPI.rate_limit_threshold
+      end
+      usable_key || keys[rand(keys.length)]
     end
 
     def rate_limit_reached?
@@ -130,14 +124,13 @@ module BridgeAPI
     def enforce_rate_limits
       return unless rate_limit_reached?
 
-      tts     = ((BridgeAPI.beginning_rate_limit - limit_remaining) / 5).ceil
-      tts     = BridgeAPI.min_sleep_seconds if tts < BridgeAPI.min_sleep_seconds
-      tts     = BridgeAPI.max_sleep_seconds if tts > BridgeAPI.max_sleep_seconds
-      message = "Bridge API rate limit minimum #{BridgeAPI.rate_limit_threshold} reached for key: '#{config[:api_key]}'. "\
-        "Sleeping for #{tts} second(s) to catch up ~zzZZ~. "\
-        "Limit Remaining: #{limit_remaining}"
-      BridgeAPI.logger.debug(message)
-      sleep(tts)
+      rotate_token! 
+      if rate_limit_reached?
+        sleep_time = rand(BridgeAPI.max_sleep_seconds)
+        sleep_time = BridgeAPI.min_sleep_seconds if sleep_time < BridgeAPI.min_sleep_seconds 
+        BridgeAPI.logger.debug("Rate limit reached sleeping for #{sleep_time}")
+        sleep(sleep_time)
+      end
     end
 
     def using_master_rate_limit?
@@ -148,20 +141,18 @@ module BridgeAPI
       limit = response.headers['x-rate-limit-remaining']
       return if limit.nil?
 
-      BridgeAPI.logger.debug("BRIDGE RATE LIMIT REMAINING: #{limit}")
+      BridgeAPI.logger.debug("BRIDGE RATE LIMIT REMAINING: #{limit} for key #{config[:api_key]}")
       self.limit_remaining = limit.to_i
     end
 
     def limit_remaining
       if using_master_rate_limit?
-        BridgeAPI.master_mutex.synchronize do
-          limit = PaulWalker::RateLimit.get(config[:api_key], config[:api_key])
-          if limit.nil?
-            PaulWalker::RateLimit.add(config[:api_key], config[:api_key], 0, BridgeAPI.beginning_rate_limit)
-            limit = { current: 0 }.with_indifferent_access
-          end
-          limit['current']
+        limit = rate_limit(config[:api_key])
+        if limit.nil?
+          set_rate_limit(config[:api_key], 0)
+          limit = { current: 0 }.with_indifferent_access
         end
+        limit['current']
       else
         BridgeAPI.rate_limits[config[:api_key]]
       end
@@ -169,12 +160,36 @@ module BridgeAPI
 
     def limit_remaining=(value)
       if using_master_rate_limit?
-        BridgeAPI.master_mutex.synchronize do
-          PaulWalker::RateLimit.add(config[:api_key], config[:api_key], value, BridgeAPI.beginning_rate_limit)
-        end
+        set_rate_limit(config[:api_key], value)
       else
         BridgeAPI.rate_limits[config[:api_key]] = value
       end
+      refresh_stale_tokens
+    end
+
+    def set_rate_limit(key, limit)
+      BridgeAPI.master_mutex.synchronize do
+        PaulWalker::RateLimit.add(key, key, limit, BridgeAPI.beginning_rate_limit)
+      end
+    end
+
+    def rate_limit(key)
+      BridgeAPI.master_mutex.synchronize do
+        PaulWalker::RateLimit.get(key, key)
+      end
+    end
+
+    def refresh_stale_tokens
+      return unless using_master_rate_limit?
+      api_keys = config[:api_keys].keys
+      api_keys.delete(config[:api_key])
+      api_keys.each do |key|
+        limit = rate_limit(key)
+        if limit['timestamp'].present? && DateTime.parse(limit['timestamp']) < 1.minute.ago
+          BridgeAPI.logger.debug("Refreshing: #{key}")
+          set_rate_limit(key, 0)
+        end
+      end
     end
 
     def set_connection(config)

data/lib/bridge_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BridgeAPI
-  VERSION = '0.1.66' unless defined?(BridgeAPI::VERSION)
+  VERSION = '0.1.67' unless defined?(BridgeAPI::VERSION)
 end

data/lib/bridge_api.rb

@@ -26,7 +26,7 @@ module BridgeAPI
     end
 
     def max_sleep_seconds
-      @max_sleep_seconds ||= 60
+      @max_sleep_seconds ||= 30
     end
 
     def master_rate_limit

data/spec/bridge_api/client/enrollment_spec.rb

@@ -27,12 +27,6 @@ describe BridgeAPI::Client::Enrollment do
     expect(enrollments.length).to(eq(2))
   end
 
-  it 'should update due date for enrollments' do
-    enrollment = [{ end_at: nil }]
-    response = @client.update_enrollment_due_date(1, enrollment)
-    expect(response.status).to(eq(200))
-  end
-
   it 'should reset an enrollment for a course template' do
     response = @client.reset_enrollment(1)
     expect(response.status).to(eq(204))

data/spec/bridge_api/client_spec.rb

@@ -52,7 +52,7 @@ describe BridgeAPI::Client do
     end
 
     it 'should return true for tokens' do
-      config = { prefix: 'https://www.fake.com', api_tokens: %w[token1 token2] }
+      config = { prefix: 'https://www.fake.com', api_tokens: %w[dGVzdDE6dGVzdDE= dGVzdDI6dGVzdDI=] }
       client = BridgeAPI::Client.new(config)
       expect(client.has_token_pool?(config)).to be_truthy
     end
@@ -74,10 +74,10 @@ describe BridgeAPI::Client do
     end
 
     it 'should take first from tokens' do
-      config     = { prefix: 'https://www.fake.com', api_tokens: %w[token1 token2] }
+      config     = { prefix: 'https://www.fake.com', api_tokens: %w[dGVzdDE6dGVzdDE= dGVzdDI6dGVzdDI=] }
       client     = BridgeAPI::Client.new(config)
       new_config = client.initialize_from_token_pool(config)
-      expect(new_config[:token]).to eq('token1')
+      expect(new_config[:api_key]).to eq('test1')
     end
   end
 
@@ -111,15 +111,16 @@ describe BridgeAPI::Client do
 
     context 'with token pool' do
       it 'should rotate to the next key' do
-        keys   = %w[token1 token2]
+        keys   = %w[dGVzdDE6dGVzdDE= dGVzdDI6dGVzdDI=]
         config = { prefix: 'https://www.fake.com', api_tokens: keys }
         client = BridgeAPI::Client.new(config)
-        expect(client.config[:token]).to eq('token1')
+        expect(client.config[:api_key]).to eq('test1')
         client.rotate_token!
-        expect(client.config[:token]).to eq('token2')
+        expect(client.config[:api_key]).to eq('test2')
         client.rotate_token!
-        expect(client.config[:token]).to eq('token1')
+        expect(client.config[:api_key]).to eq('test1')
       end
     end
   end
 end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bridge_api
 version: !ruby/object:Gem::Version
-  version: 0.1.66
+  version: 0.1.67
 platform: ruby
 authors:
 - Jay Shaffer
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-10 00:00:00.000000000 Z
+date: 2022-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler