aws-sessionstore-dynamodb 2.2.0 → 3.0.0

data/lib/aws/session_store/dynamo_db/errors/default_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws::SessionStore::DynamoDB::Errors
   # This class handles errors raised from DynamoDB.
   class DefaultHandler < Aws::SessionStore::DynamoDB::Errors::BaseHandler
@@ -5,38 +7,37 @@ module Aws::SessionStore::DynamoDB::Errors
     HARD_ERRORS = [
       Aws::DynamoDB::Errors::ResourceNotFoundException,
       Aws::DynamoDB::Errors::ConditionalCheckFailedException,
-      Aws::SessionStore::DynamoDB::MissingSecretKeyError,
-      Aws::SessionStore::DynamoDB::LockWaitTimeoutError
-    ]
+      Aws::SessionStore::DynamoDB::Errors::MissingSecretKeyError,
+      Aws::SessionStore::DynamoDB::Errors::LockWaitTimeoutError
+    ].freeze
 
     # Determines behavior of DefaultErrorHandler
     # @param [true] raise_errors Pass all errors up the Rack stack.
     def initialize(raise_errors)
+      super()
       @raise_errors = raise_errors
     end
 
     # Raises {HARD_ERRORS} up the Rack stack.
     # Places all other errors in Racks error stream.
     def handle_error(error, env = {})
-      if HARD_ERRORS.include?(error.class) || @raise_errors
-        raise error
-      else
-        store_error(error, env)
-        false
-      end
+      raise error if HARD_ERRORS.include?(error.class) || @raise_errors
+
+      store_error(error, env)
+      false
     end
 
     # Sends error to error stream
     def store_error(error, env = {})
-      env["rack.errors"].puts(errors_string(error)) if env
+      env['rack.errors'].puts(errors_string(error)) if env
     end
 
     # Returns string to be placed in error stream
     def errors_string(error)
       str = []
       str << "Exception occurred: #{error.message}"
-      str << "Stack trace:"
-      str += error.backtrace.map {|l| "  " + l }
+      str << 'Stack trace:'
+      str += error.backtrace.map { |l| "  #{l}" }
       str.join("\n")
     end
   end

data/lib/aws/session_store/dynamo_db/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Aws::SessionStore::DynamoDB::Errors
+  # This error is raised when no secret key is provided.
+  class MissingSecretKeyError < RuntimeError
+    def initialize(msg = 'No secret key provided!')
+      super
+    end
+  end
+
+  # This error is raised when an invalid session ID is provided.
+  class InvalidIDError < RuntimeError
+    def initialize(msg = 'Corrupt Session ID!')
+      super
+    end
+  end
+
+  # This error is raised when the maximum time spent to acquire lock has been exceeded.
+  class LockWaitTimeoutError < RuntimeError
+    def initialize(msg = 'Maximum time spent to acquire lock has been exceeded!')
+      super
+    end
+  end
+end
+
+require_relative 'errors/base_handler'
+require_relative 'errors/default_handler'

data/lib/aws/session_store/dynamo_db/garbage_collection.rb

@@ -1,115 +1,106 @@
+# frozen_string_literal: true
+
 require 'aws-sdk-dynamodb'
 
 module Aws::SessionStore::DynamoDB
   # Collects and deletes unwanted sessions based on
   # their creation and update dates.
   module GarbageCollection
-    module_function
-
-    # Scans DynamoDB session table to find
-    # sessions that match the max age and max stale period
-    # requirements. it then deletes all of the found sessions.
-    def collect_garbage(options = {})
-      config = load_config(options)
-      last_key = eliminate_unwanted_sessions(config)
-      while !last_key.empty?
-        last_key = eliminate_unwanted_sessions(config, last_key)
+    class << self
+      # Scans DynamoDB session table to find sessions that match the max age and
+      # max stale period requirements. it then deletes all of the found sessions.
+      def collect_garbage(options = {})
+        config = load_config(options)
+        last_key = eliminate_unwanted_sessions(config)
+        last_key = eliminate_unwanted_sessions(config, last_key) until last_key.empty?
       end
-    end
 
-    # Loads configuration options.
-    # @option (see Configuration#initialize)
-    # @api private
-    def load_config(options = {})
-      Aws::SessionStore::DynamoDB::Configuration.new(options)
-    end
+      private
 
-    # Sets scan filter attributes based on attributes specified.
-    # @api private
-    def scan_filter(config)
-      hash = {}
-      hash['created_at'] = oldest_date(config.max_age) if config.max_age
-      hash['updated_at'] = oldest_date(config.max_stale) if config.max_stale
-      { :scan_filter => hash }
-    end
+      # Loads configuration options.
+      # @option (see Configuration#initialize)
+      def load_config(options = {})
+        Aws::SessionStore::DynamoDB::Configuration.new(options)
+      end
 
-    # Scans and deletes batch.
-    # @api private
-    def eliminate_unwanted_sessions(config, last_key = nil)
-      scan_result = scan(config, last_key)
-      batch_delete(config, scan_result[:items])
-      scan_result[:last_evaluated_key] || {}
-    end
+      # Sets scan filter attributes based on attributes specified.
+      def scan_filter(config)
+        hash = {}
+        hash['created_at'] = oldest_date(config.max_age) if config.max_age
+        hash['updated_at'] = oldest_date(config.max_stale) if config.max_stale
+        { scan_filter: hash }
+      end
 
-    # Scans the table for sessions matching the max age and
-    # max stale time specified.
-    # @api private
-    def scan(config, last_item = nil)
-      options = scan_opts(config)
-      options = options.merge(start_key(last_item)) if last_item
-      config.dynamo_db_client.scan(options)
-    end
+      # Scans and deletes batch.
+      def eliminate_unwanted_sessions(config, last_key = nil)
+        scan_result = scan(config, last_key)
+        batch_delete(config, scan_result[:items])
+        scan_result[:last_evaluated_key] || {}
+      end
 
-    # Deletes the batch gotten from the scan result.
-    # @api private
-    def batch_delete(config, items)
-      begin
-        subset = items.shift(25)
-        sub_batch = write(subset)
-        process!(config, sub_batch)
-      end until subset.empty?
-    end
+      # Scans the table for sessions matching the max age and
+      # max stale time specified.
+      def scan(config, last_item = nil)
+        options = scan_opts(config)
+        options = options.merge(start_key(last_item)) if last_item
+        config.dynamo_db_client.scan(options)
+      end
 
-    # Turns array into correct format to be passed in to
-    # a delete request.
-    # @api private
-    def write(sub_batch)
-      sub_batch.inject([]) do |rqst_array, item|
-        rqst_array << {:delete_request => {:key => item}}
-        rqst_array
+      # Deletes the batch gotten from the scan result.
+      def batch_delete(config, items)
+        loop do
+          subset = items.shift(25)
+          sub_batch = write(subset)
+          process!(config, sub_batch)
+          break if subset.empty?
+        end
       end
-    end
 
-    # Proccesses pending request items.
-    # @api private
-    def process!(config, sub_batch)
-      return if sub_batch.empty?
-      opts = {}
-      opts[:request_items] = {config.table_name => sub_batch}
-      begin
-        response = config.dynamo_db_client.batch_write_item(opts)
-        opts[:request_items] = response[:unprocessed_items]
-      end until opts[:request_items].empty?
-    end
+      # Turns array into correct format to be passed in to
+      # a delete request.
+      def write(sub_batch)
+        sub_batch.each_with_object([]) do |item, rqst_array|
+          rqst_array << { delete_request: { key: item } }
+        end
+      end
 
-    # Provides scan options.
-    # @api private
-    def scan_opts(config)
-      table_opts(config).merge(scan_filter(config))
-    end
+      # Processes pending request items.
+      def process!(config, sub_batch)
+        return if sub_batch.empty?
 
-    # Provides table options
-    # @api private
-    def table_opts(config)
-      {
-        :table_name => config.table_name,
-        :attributes_to_get => [config.table_key]
-      }
-    end
+        opts = { request_items: { config.table_name => sub_batch } }
+        loop do
+          response = config.dynamo_db_client.batch_write_item(opts)
+          opts[:request_items] = response[:unprocessed_items]
+          break if opts[:request_items].empty?
+        end
+      end
 
-    # @return [Hash] Hash with specified date attributes.
-    # @api private
-    def oldest_date(sec)
-      hash = {}
-      hash[:attribute_value_list] = [:n => "#{((Time.now - sec).to_f)}"]
-      hash[:comparison_operator] = 'LT'
-      hash
-    end
+      # Provides scan options.
+      def scan_opts(config)
+        table_opts(config).merge(scan_filter(config))
+      end
+
+      # Provides table options
+      def table_opts(config)
+        {
+          table_name: config.table_name,
+          attributes_to_get: [config.table_key]
+        }
+      end
 
-    # Provides start key.
-    # @api private
-    def start_key(last_item)
-      { :exclusive_start_key => last_item }
+      # Provides specified date attributes.
+      def oldest_date(sec)
+        {
+          attribute_value_list: [n: (Time.now - sec).to_f.to_s],
+          comparison_operator: 'LT'
+        }
+      end
+
+      # Provides start key.
+      def start_key(last_item)
+        { exclusive_start_key: last_item }
+      end
     end
   end
 end

data/lib/aws/session_store/dynamo_db/locking/base.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 module Aws::SessionStore::DynamoDB::Locking
-  # This class provides a framework for implementing
-  # locking strategies.
+  # Handles session management.
   class Base
-
-    # Creates configuration object.
+    # @param [Aws::SessionStore::DynamoDB::Configuration] cfg
     def initialize(cfg)
       @config = cfg
     end
@@ -11,6 +11,7 @@ module Aws::SessionStore::DynamoDB::Locking
     # Updates session in database
     def set_session_data(env, sid, session, options = {})
       return false if session.empty?
+
       packed_session = pack_data(session)
       handle_error(env) do
         save_opts = update_opts(env, sid, packed_session, options)
@@ -19,12 +20,7 @@ module Aws::SessionStore::DynamoDB::Locking
       end
     end
 
-    # Packs session data.
-    def pack_data(data)
-      [Marshal.dump(data)].pack("m*")
-    end
-
-    # Gets session data.
+    # Retrieves session data based on id
     def get_session_data(env, sid)
       raise NotImplementedError
     end
@@ -36,19 +32,17 @@ module Aws::SessionStore::DynamoDB::Locking
       end
     end
 
+    private
+
     # Each database operation is placed in this rescue wrapper.
     # This wrapper will call the method, rescue any exceptions and then pass
     # exceptions to the configured error handler.
-    def handle_error(env = nil, &block)
-      begin
-        yield
-      rescue Aws::DynamoDB::Errors::ServiceError => e
-        @config.error_handler.handle_error(e, env)
-      end
+    def handle_error(env = nil)
+      yield
+    rescue Aws::DynamoDB::Errors::ServiceError => e
+      @config.error_handler.handle_error(e, env)
     end
 
-    private
-
     # @return [Hash] Options for deleting session.
     def delete_opts(sid)
       table_opts(sid)
@@ -57,11 +51,10 @@ module Aws::SessionStore::DynamoDB::Locking
     # @return [Hash] Options for updating item in Session table.
     def update_opts(env, sid, session, options = {})
       if env['dynamo_db.new_session']
-        updt_options = save_new_opts(env, sid, session)
+        save_new_opts(env, sid, session)
       else
-        updt_options = save_exists_opts(env, sid, session, options)
+        save_exists_opts(env, sid, session, options)
       end
-      updt_options
     end
 
     # @return [Hash] Options for saving a new session in database.
@@ -78,16 +71,21 @@ module Aws::SessionStore::DynamoDB::Locking
       merge_all(table_opts(sid), attribute_opts)
     end
 
+    # Marshal the data.
+    def pack_data(data)
+      [Marshal.dump(data)].pack('m*')
+    end
+
     # Unmarshal the data.
     def unpack_data(packed_data)
-      Marshal.load(packed_data.unpack("m*").first)
+      Marshal.load(packed_data.unpack1('m*'))
     end
 
     # Table options for client.
     def table_opts(sid)
       {
-        :table_name => @config.table_name,
-        :key => { @config.table_key => sid }
+        table_name: @config.table_name,
+        key: { @config.table_key => sid }
       }
     end
 
@@ -102,12 +100,12 @@ module Aws::SessionStore::DynamoDB::Locking
 
     # Update client with current time attribute.
     def updated_at
-      { :value => "#{(Time.now).to_f}", :action  => "PUT" }
+      { value: Time.now.to_f.to_s, action: 'PUT' }
     end
 
     # Attribute for creation of session.
     def created_attr
-      { "created_at" => updated_at }
+      { 'created_at' => updated_at }
     end
 
     # Update client with current time + max_stale.
@@ -124,35 +122,36 @@ module Aws::SessionStore::DynamoDB::Locking
     # Attribute for updating session.
     def updated_attr
       {
-        "updated_at" => updated_at
+        'updated_at' => updated_at
       }
     end
 
     def data_attr(session)
-       { "data" => {:value => session, :action  => "PUT"} }
+      { 'data' => { value: session, action: 'PUT' } }
     end
 
     # Determine if data has been manipulated
     def data_unchanged?(env, session)
       return false unless env['rack.initial_data']
+
       env['rack.initial_data'] == session
     end
 
     # Expected attributes
     def expected_attributes(sid)
-      { :expected => { @config.table_key => {:value => sid, :exists => true} } }
+      { expected: { @config.table_key => { value: sid, exists: true } } }
     end
 
     # Attributes to be retrieved via client
     def attr_opts
-      {:attributes_to_get => ["data"],
-      :consistent_read => @config.consistent_read}
+      { attributes_to_get: ['data'],
+        consistent_read: @config.consistent_read }
     end
 
     # @return [Hash] merged hash of all hashes passed in.
     def merge_all(*hashes)
       new_hash = {}
-      hashes.each{|hash| new_hash.merge!(hash)}
+      hashes.each { |hash| new_hash.merge!(hash) }
       new_hash
     end
   end

data/lib/aws/session_store/dynamo_db/locking/null.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws::SessionStore::DynamoDB::Locking
   # This class gets and sets sessions
   # without a locking strategy.
@@ -18,9 +20,8 @@ module Aws::SessionStore::DynamoDB::Locking
 
     # @return [String] Session data.
     def extract_data(env, result = nil)
-      env['rack.initial_data'] = result[:item]["data"] if result[:item]
-      unpack_data(result[:item]["data"]) if result[:item]
+      env['rack.initial_data'] = result[:item]['data'] if result[:item]
+      unpack_data(result[:item]['data']) if result[:item]
     end
-
   end
 end

data/lib/aws/session_store/dynamo_db/locking/pessimistic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Aws::SessionStore::DynamoDB::Locking
   # This class implements a pessimistic locking strategy for the
   # DynamoDB session handler. Sessions obtain an exclusive lock
@@ -19,6 +21,7 @@ module Aws::SessionStore::DynamoDB::Locking
     private
 
     # Get session with implemented locking strategy.
+    # rubocop:disable Metrics/MethodLength
     def get_session_with_lock(env, sid)
       expires_at = nil
       result = nil
@@ -30,19 +33,21 @@ module Aws::SessionStore::DynamoDB::Locking
         rescue Aws::DynamoDB::Errors::ConditionalCheckFailedException
           expires_at ||= get_expire_date(sid)
           next if expires_at.nil?
+
           result = bust_lock(sid, expires_at)
           wait_to_retry(result)
         end
       end
       get_data(env, result)
     end
+    # rubocop:enable Metrics/MethodLength
 
     # Determine if session has waited too long to obtain lock.
     #
     # @raise [Error] When time for attempting to get lock has
     #   been exceeded.
     def exceeded_wait_time?(max_attempt_date)
-      lock_error = Aws::SessionStore::DynamoDB::LockWaitTimeoutError
+      lock_error = Aws::SessionStore::DynamoDB::Errors::LockWaitTimeoutError
       raise lock_error if Time.now.to_f > max_attempt_date
     end
 
@@ -54,22 +59,22 @@ module Aws::SessionStore::DynamoDB::Locking
     # @return [Time] Time stamp for which the session was locked.
     def lock_time(sid)
       result = @config.dynamo_db_client.get_item(get_lock_time_opts(sid))
-      (result[:item]["locked_at"]).to_f if result[:item]["locked_at"]
+      (result[:item]['locked_at']).to_f if result[:item]['locked_at']
     end
 
     # @return [String] Session data.
     def get_data(env, result)
-      lock_time = result[:attributes]["locked_at"]
-      env["locked_at"] = (lock_time).to_f
-      env['rack.initial_data'] = result[:item]["data"] if result.members.include? :item
-      unpack_data(result[:attributes]["data"])
+      lock_time = result[:attributes]['locked_at']
+      env['locked_at'] = lock_time.to_f
+      env['rack.initial_data'] = result[:item]['data'] if result.members.include? :item
+      unpack_data(result[:attributes]['data'])
     end
 
     # Attempt to bust the lock if the expiration date has expired.
     def bust_lock(sid, expires_at)
-      if expires_at < Time.now.to_f
-        @config.dynamo_db_client.update_item(obtain_lock_opts(sid))
-      end
+      return unless expires_at < Time.now.to_f
+
+      @config.dynamo_db_client.update_item(obtain_lock_opts(sid))
     end
 
     # @return [Hash] Options hash for obtaining the lock.
@@ -96,20 +101,20 @@ module Aws::SessionStore::DynamoDB::Locking
     # Lock attribute - time stamp of when session was locked.
     def lock_attr
       {
-        :attribute_updates => {"locked_at" => updated_at},
-        :return_values => "ALL_NEW"
+        attribute_updates: { 'locked_at' => updated_at },
+        return_values: 'ALL_NEW'
       }
     end
 
     # Time in which session was updated.
     def updated_at
-      { :value => "#{(Time.now).to_f}", :action  => "PUT" }
+      { value: Time.now.to_f.to_s, action: 'PUT' }
     end
 
     # Attributes for locking.
     def add_lock_attrs(env)
       {
-        :add_attrs => add_attr, :expect_attr => expect_lock_time(env)
+        add_attrs: add_attr, expect_attr: expect_lock_time(env)
       }
     end
 
@@ -120,25 +125,32 @@ module Aws::SessionStore::DynamoDB::Locking
 
     # Lock expectation.
     def lock_expect
-      { :expected => { "locked_at" => { :exists => false } } }
+      { expected: { 'locked_at' => { exists: false } } }
     end
 
     # Option to delete lock.
     def add_attr
-      { "locked_at" => {:action => "DELETE"} }
+      { 'locked_at' => { action: 'DELETE' } }
     end
 
     # Expectation of when lock was set.
     def expect_lock_time(env)
-      { :expected => {"locked_at" => {
-        :value => "#{env["locked_at"]}", :exists => true}} }
+      {
+        expected: {
+          'locked_at' => {
+            value: (env['locked_at']).to_s,
+            exists: true
+          }
+        }
+      }
     end
 
     # Attributes to be retrieved via client
     def lock_opts
-      {:attributes_to_get => ["locked_at"],
-      :consistent_read => @config.consistent_read}
+      {
+        attributes_to_get: ['locked_at'],
+        consistent_read: @config.consistent_read
+      }
     end
-
   end
 end