aws-sessionstore-dynamodb 0.5.0

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

@@ -0,0 +1,45 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+module AWS::SessionStore::DynamoDB::Errors
+  # BaseErrorHandler provides an interface for error handlers
+  # that can be passed in to {AWS::SessionStore::DynamoDB::RackMiddleware}.
+  # Each error handler must implement a handle_error method.
+  #
+  # @example Sample ErrorHandler class
+  #   class MyErrorHandler < BaseErrorHandler
+  #    # Handles error passed in
+  #    def handle_error(e, env = {})
+  #      File.open(path_to_file, 'w') {|f| f.write(e.message) }
+  #      false
+  #    end
+  #   end
+  class BaseHandler
+    # An error and an environment (optionally) will be passed in to
+    # this method and it will determine how to deal
+    # with the error.
+    # Must return false if you have handled the error but are not reraising the
+    # error up the stack.
+    # You may reraise the error passed.
+    #
+    # @param [AWS::DynamoDB::Errors::Base] error error passed in from
+    #  AWS::SessionStore::DynamoDB::RackMiddleware.
+    # @param [Rack::Request::Environment,nil] env Rack environment
+    # @return [false] If exception was handled and will not reraise exception.
+    # @raise [AWS::DynamoDB::Errors] If error has be reraised.
+    def handle_error(error, env = {})
+      raise NotImplementedError
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+module AWS::SessionStore::DynamoDB::Errors
+  # This class handles errors raised from DynamoDB.
+  class DefaultHandler < AWS::SessionStore::DynamoDB::Errors::BaseHandler
+    # Array of errors that will always be passed up the Rack stack.
+    HARD_ERRORS = [
+      AWS::DynamoDB::Errors::ResourceNotFoundException,
+      AWS::DynamoDB::Errors::ConditionalCheckFailedException,
+      AWS::SessionStore::DynamoDB::MissingSecretKeyError,
+      AWS::SessionStore::DynamoDB::LockWaitTimeoutError
+    ]
+
+    # Determines behavior of DefaultErrorHandler
+    # @param [true] raise_errors Pass all errors up the Rack stack.
+    def initialize(raise_errors)
+      @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
+    end
+
+    # Sends error to error stream
+    def store_error(error, 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.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'aws-sdk'
+
+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)
+      end
+    end
+
+    # Loads configuration options.
+    # @option (see Configuration#initialize)
+    # @api private
+    def load_config(options = {})
+      AWS::SessionStore::DynamoDB::Configuration.new(options)
+    end
+
+    # 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
+
+    # 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[:member])
+      scan_result[:last_evaluated_key] || {}
+    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.merge(start_key(last_item)) if last_item
+      config.dynamo_db_client.scan(options)
+    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
+
+    # 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
+      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
+
+    # Provides scan options.
+    # @api private
+    def scan_opts(config)
+      table_opts(config).merge(scan_filter(config))
+    end
+
+    # Provides table options
+    # @api private
+    def table_opts(config)
+      {
+        :table_name => config.table_name,
+        :attributes_to_get => [config.table_key]
+      }
+    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 start key.
+    # @api private
+    def start_key(last_item)
+      { :exclusive_start_key => last_item }
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+module AWS::SessionStore::DynamoDB
+  class InvalidIDError < RuntimeError
+    def initialize(msg = "Corrupt Session ID!")
+      super
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+module AWS::SessionStore::DynamoDB
+  class LockWaitTimeoutError < RuntimeError
+    def initialize(msg = 'Maximum time spent to acquire lock has been exceeded!')
+      super
+    end
+  end
+end

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

@@ -0,0 +1,162 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+module AWS::SessionStore::DynamoDB::Locking
+  # This class provides a framework for implementing
+  # locking strategies.
+  class Base
+
+    # Creates configuration object.
+    def initialize(cfg)
+      @config = cfg
+    end
+
+    # 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)
+        result = @config.dynamo_db_client.update_item(save_opts)
+        sid
+      end
+    end
+
+    # Packs session data.
+    def pack_data(data)
+      [Marshal.dump(data)].pack("m*")
+    end
+
+    # Gets session data.
+    def get_session_data(env, sid)
+      raise NotImplementedError
+    end
+
+    # Deletes session based on id
+    def delete_session(env, sid)
+      handle_error(env) do
+        @config.dynamo_db_client.delete_item(delete_opts(sid))
+      end
+    end
+
+    # 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::Base => e
+        @config.error_handler.handle_error(e, env)
+      end
+    end
+
+    private
+
+    # @return [Hash] Options for deleting session.
+    def delete_opts(sid)
+      merge_all(table_opts(sid), expected_attributes(sid))
+    end
+
+    # @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)
+      else
+        updt_options = save_exists_opts(env, sid, session, options)
+      end
+      updt_options
+    end
+
+    # @return [Hash] Options for saving a new session in database.
+    def save_new_opts(env, sid, session)
+      attribute_opts = attr_updts(env, session, created_attr)
+      merge_all(table_opts(sid), attribute_opts)
+    end
+
+    # @return [Hash] Options for saving an existing sesison in the database.
+    def save_exists_opts(env, sid, session, options = {})
+      add_attr = options[:add_attrs] || {}
+      expected = options[:expect_attr] || {}
+      attribute_opts = merge_all(attr_updts(env, session, add_attr), expected)
+      merge_all(table_opts(sid), attribute_opts)
+    end
+
+    # Unmarshal the data.
+    def unpack_data(packed_data)
+      Marshal.load(packed_data.unpack("m*").first)
+    end
+
+    # Table options for client.
+    def table_opts(sid)
+      {
+        :table_name => @config.table_name,
+        :key => {@config.table_key => {:s => sid}}
+      }
+    end
+
+    # Attributes to update via client.
+    def attr_updts(env, session, add_attrs = {})
+      data = data_unchanged?(env, session) ? {} : data_attr(session)
+      {
+        :attribute_updates => merge_all(updated_attr, data, add_attrs),
+        :return_values => "UPDATED_NEW"
+      }
+    end
+
+    # Update client with current time attribute.
+    def updated_at
+      { :value => {:n => "#{(Time.now).to_f}"}, :action  => "PUT" }
+    end
+
+    # Attribute for creation of session.
+    def created_attr
+      { "created_at" => updated_at }
+    end
+
+    # Attribute for updating session.
+    def updated_attr
+      {
+        "updated_at" => updated_at
+      }
+    end
+
+    def data_attr(session)
+       { "data" => {:value => {:s => 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 => {:s => sid}, :exists => true}} }
+    end
+
+    # Attributes to be retrieved via client
+    def attr_opts
+      {: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)}
+      new_hash
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+
+module AWS::SessionStore::DynamoDB::Locking
+  # This class gets and sets sessions
+  # without a locking strategy.
+  class Null < AWS::SessionStore::DynamoDB::Locking::Base
+    # Retrieve session if it exists from the database by id.
+    # Unpack the data once retrieved from the database.
+    def get_session_data(env, sid)
+      handle_error(env) do
+        result = @config.dynamo_db_client.get_item(get_session_opts(sid))
+        extract_data(env, result)
+      end
+    end
+
+    # @return [Hash] Options for getting session.
+    def get_session_opts(sid)
+      merge_all(table_opts(sid), attr_opts)
+    end
+
+    # @return [String] Session data.
+    def extract_data(env, result = nil)
+      env['rack.initial_data'] = result[:item]["data"][:s] if result[:item]
+      unpack_data(result[:item]["data"][:s]) if result[:item]
+    end
+
+  end
+end