dynamodb_framework 0.1.4 → 1.0.0

data/lib/dynamodb_framework/dynamodb_store.rb

@@ -1,16 +1,16 @@
-class DynamoDbStore
-  attr_reader :client
+module DynamoDbFramework
+  class Store
+    attr_reader :client
+
+    def initialize(options = {})
+
+      if options.has_key?(:endpoint)
+        @client = Aws::DynamoDB::Client.new(region: options[:aws_region], endpoint: options[:endpoint])
+      else
+        @client = Aws::DynamoDB::Client.new
+      end
 
-  def initialize
-    region = ENV['DYNAMODB_REGION']
-    endpoint = ENV['DYNAMODB_ENDPOINT']
-    secret = ENV['DYNAMODB_SECRET']
-    key = ENV['DYNAMODB_ACCESS_KEY']
-    if endpoint != nil
-      @client = Aws::DynamoDB::Client.new(region: region, endpoint: endpoint, secret_access_key: secret, access_key_id: key)
-    else
-      @client = Aws::DynamoDB::Client.new(region: region, secret_access_key: secret, access_key_id: key)
     end
-  end
 
-end
+  end
+end

data/lib/dynamodb_framework/dynamodb_table_manager.rb

@@ -1,283 +1,352 @@
-class DynamoDbTableManager
+module DynamoDbFramework
+  class TableManager
 
-  attr_reader :dynamodb
+    attr_reader :dynamodb
 
-  def initialize
-    @dynamodb = DynamoDbStore.new
-  end
+    def initialize(store)
+      @dynamodb = store
+    end
 
-  def exists?(table_name)
+    def exists?(table_name)
 
-    exists = true
+      exists = true
 
-    begin
-      dynamodb.client.describe_table(:table_name => table_name)
-    rescue Aws::DynamoDB::Errors::ResourceNotFoundException
-      exists = false
-    end
+      begin
+        dynamodb.client.describe_table(:table_name => table_name)
+      rescue Aws::DynamoDB::Errors::ResourceNotFoundException
+        exists = false
+      end
 
-    return exists
+      return exists
 
-  end
+    end
 
-  def has_index?(table_name, index_name)
-    exists = true
+    def has_index?(table_name, index_name)
+      exists = true
 
-    begin
-      result = dynamodb.client.describe_table(:table_name => table_name)
+      begin
+        result = dynamodb.client.describe_table(:table_name => table_name)
 
-      if result.table[:global_secondary_indexes] == nil
-        return false
-      end
+        if result.table[:global_secondary_indexes] == nil
+          return false
+        end
 
-      if result.table[:global_secondary_indexes].select { |i| i[:index_name] == index_name }.length > 0
-        exists = true
-      else
+        if result.table[:global_secondary_indexes].select { |i| i[:index_name] == index_name }.length > 0
+          exists = true
+        else
+          exists = false
+        end
+      rescue Aws::DynamoDB::Errors::ResourceNotFoundException
         exists = false
       end
-    rescue Aws::DynamoDB::Errors::ResourceNotFoundException
-      exists = false
+
+      return exists
     end
 
-    return exists
-  end
+    def update_throughput(table_name, read_capacity, write_capacity)
 
-  def update_throughput(table_name, read_capacity, write_capacity)
+      if !exists?(table_name)
+        raise "table: #{table_name}, does not exist."
+      end
 
-    if !exists?(table_name)
-      raise "table: #{table_name}, does not exist."
-    end
+      table = {
+          :table_name => table_name,
+          :provisioned_throughput => {
+              :read_capacity_units => read_capacity,
+              :write_capacity_units => write_capacity
+          }
+      }
 
-    table = {
-        :table_name => table_name,
-        :provisioned_throughput => {
-            :read_capacity_units => read_capacity,
-            :write_capacity_units => write_capacity
-        }
-    }
+      dynamodb.client.update_table(table)
 
-    dynamodb.client.update_table(table)
+      # wait for table to be updated
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Waiting for table: [#{table_name}] to be updated."
+      wait_until_active(table_name)
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Table: [#{table_name}] updated."
 
-    # wait for table to be updated
-    puts "waiting for table: [#{table_name}] to be updated..."
-    wait_until_active(table_name)
-    puts "table: [#{table_name}] updated!"
+    end
 
-  end
+    def add_index(table_name, attributes, global_index)
+
+      attribute_definitions = []
+
+      attributes.each do |a|
+        attribute_definitions.push({ :attribute_name => a[:name], :attribute_type => a[:type] })
+      end
 
-  def add_index(table_name, attributes, global_index)
+      table = {
+          :table_name => table_name,
+          :attribute_definitions => attribute_definitions,
+          :global_secondary_index_updates => [
+              :create => global_index
+          ]
+      }
 
-    attribute_definitions = []
+      dynamodb.client.update_table(table)
 
-    attributes.each do |a|
-      attribute_definitions.push({ :attribute_name => a[:name], :attribute_type => a[:type] })
+      # wait for table to be updated
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Adding global index: #{global_index[:index_name]}."
+      wait_until_index_active(table_name, global_index[:index_name])
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Index added."
     end
 
-    table = {
-        :table_name => table_name,
-        :attribute_definitions => attribute_definitions,
-        :global_secondary_index_updates => [
-            :create => global_index
-        ]
-    }
+    def update_index_throughput(table_name, index_name, read_capacity, write_capacity)
+      table = {
+          :table_name => table_name,
+          :global_secondary_index_updates => [
+              :update => {
+                  :index_name => index_name,
+                  :provisioned_throughput => {
+                      :read_capacity_units => read_capacity,
+                      :write_capacity_units => write_capacity
+                  }
+              }
+          ]
+      }
+
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Updating throughput for global index: #{index_name}."
+
+      dynamodb.client.update_table(table)
+
+      # wait for table to be updated
+
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Waiting for table: [#{table_name}] to be updated."
+      wait_until_active(table_name)
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Table: [#{table_name}] updated."
+    end
 
-    dynamodb.client.update_table(table)
+    def drop_index(table_name, index_name)
+      table = {
+          :table_name => table_name,
+          :global_secondary_index_updates => [
+              :delete => {
+                  :index_name => index_name
+              }
+          ]
+      }
+
+      dynamodb.client.update_table(table)
+
+      # wait for table to be updated
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Deleting global index: #{index_name}."
+      wait_until_index_dropped(table_name, index_name)
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Index: [#{index_name}] dropped."
+    end
 
-    # wait for table to be updated
-    puts "Adding global index: #{global_index[:index_name]}..."
-    wait_until_index_active(table_name, global_index[:index_name])
-    puts "Index added!"
-  end
+    def get_status(table_name)
+      result = dynamodb.client.describe_table(:table_name => table_name)
+      return result.table[:table_status]
+    end
 
-  def update_index_throughput(table_name, index_name, read_capacity, write_capacity)
-    table = {
-        :table_name => table_name,
-        :global_secondary_index_updates => [
-            :update => {
-                :index_name => index_name,
-                :provisioned_throughput => {
-                    :read_capacity_units => read_capacity,
-                    :write_capacity_units => write_capacity
-                }
-            }
-        ]
-    }
-
-    dynamodb.client.update_table(table)
-
-    # wait for table to be updated
-    puts "Updating throughput for global index: #{index_name}..."
-    puts "waiting for table: [#{table_name}] to be updated..."
-    wait_until_active(table_name)
-    puts "table: [#{table_name}] updated!"
-  end
+    def get_index_status(table_name, index_name)
+      result = dynamodb.client.describe_table(:table_name => table_name)
 
-  def drop_index(table_name, index_name)
-    table = {
-        :table_name => table_name,
-        :global_secondary_index_updates => [
-            :delete => {
-                :index_name => index_name
-            }
-        ]
-    }
-
-    dynamodb.client.update_table(table)
-
-    # wait for table to be updated
-    puts "Deleting global index: #{index_name}..."
-    wait_until_index_dropped(table_name, index_name)
-    puts "Index: [#{index_name}] dropped!"
-  end
+      if result.table[:global_secondary_indexes] == nil
+        return nil
+      end
 
-  def get_status(table_name)
-    result = dynamodb.client.describe_table(:table_name => table_name)
-    return result.table[:table_status]
-  end
+      index = result.table[:global_secondary_indexes].select { |i| i[:index_name] == index_name }
 
-  def get_index_status(table_name, index_name)
-    result = dynamodb.client.describe_table(:table_name => table_name)
+      if index.length > 0
+        return index[0][:index_status]
+      end
 
-    if result.table[:global_secondary_indexes] == nil
       return nil
     end
 
-    index = result.table[:global_secondary_indexes].select { |i| i[:index_name] == index_name }
+    def wait_until_active(table_name)
+
+      end_time = Time.now + 300
+      while Time.now < end_time do
+
+        status = get_status(table_name)
+
+        if status == 'ACTIVE'
+          return
+        end
+
+        sleep(5)
+      end
+
+      raise "Timeout occured while waiting for table: #{table_name}, to become active."
 
-    if index.length > 0
-      return index[0][:index_status]
     end
 
-    return nil
-  end
+    def wait_until_index_active(table_name, index_name)
 
-  def wait_until_active(table_name)
+      end_time = Time.now + 300
+      while Time.now < end_time do
 
-    end_time = Time.now + 5.minutes
-    while Time.now < end_time do
+        status = get_index_status(table_name, index_name)
 
-      status = get_status(table_name)
+        if status == 'ACTIVE'
+          return
+        end
 
-      if status == 'ACTIVE'
-        return
+        sleep(5)
       end
 
-      sleep(5.seconds)
+      raise "Timeout occured while waiting for table: #{table_name}, index: #{index_name}, to become active."
+
     end
 
-    raise "Timeout occured while waiting for table: #{table_name}, to become active."
+    def wait_until_index_dropped(table_name, index_name)
 
-  end
+      end_time = Time.now + 300
+      while Time.now < end_time do
+
+        status = get_index_status(table_name, index_name)
+
+        if status == nil
+          return
+        end
 
-  def wait_until_index_active(table_name, index_name)
+        sleep(5)
+      end
+
+      raise "Timeout occured while waiting for table: #{table_name}, index: #{index_name}, to be dropped."
 
-    end_time = Time.now + 5.minutes
-    while Time.now < end_time do
+    end
 
-      status = get_index_status(table_name, index_name)
+    def create(table_name, attributes, partition_key, range_key = nil, read_capacity = 20, write_capacity = 10, global_indexes = nil)
 
-      if status == 'ACTIVE'
+      if exists?(table_name)
         return
       end
 
-      sleep(5.seconds)
-    end
+      attribute_definitions = []
 
-    raise "Timeout occured while waiting for table: #{table_name}, index: #{index_name}, to become active."
+      attributes.each do |a|
+        attribute_definitions.push({ :attribute_name => a[:name], :attribute_type => a[:type] })
+      end
 
-  end
+      key_schema = []
+      key_schema.push({ :attribute_name => partition_key, :key_type => :HASH })
+      if range_key != nil
+        key_schema.push({ :attribute_name => range_key, :key_type => :RANGE })
+      end
 
-  def wait_until_index_dropped(table_name, index_name)
+      table = {
+          :table_name => table_name,
+          :attribute_definitions => attribute_definitions,
+          :key_schema => key_schema,
+          :provisioned_throughput => {
+              :read_capacity_units => read_capacity,
+              :write_capacity_units => write_capacity
+          }
+      }
+
+      if global_indexes != nil
+        table[:global_secondary_indexes] = global_indexes
+      end
 
-    end_time = Time.now + 5.minutes
-    while Time.now < end_time do
+      dynamodb.client.create_table(table)
+
+      # wait for table to be created
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Waiting for table: [#{table_name}] to be created."
+      dynamodb.client.wait_until(:table_exists, table_name: table_name)
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Table: [#{table_name}] created."
+    end
 
-      status = get_index_status(table_name, index_name)
+    def create_table(options = {})
 
-      if status == nil
+      if options[:name] == nil
+        raise 'A valid table name must be specified.'
+      end
+
+      if exists?(options[:name])
         return
       end
 
-      sleep(5.seconds)
-    end
+      options[:read_capacity] ||= 20
+      options[:write_capacity] ||= 20
 
-    raise "Timeout occured while waiting for table: #{table_name}, index: #{index_name}, to be dropped."
+      if !options[:attributes].is_a?(Array)
+        raise 'A valid :attributes array must be specified.'
+      end
 
-  end
+      attribute_definitions = options[:attributes].map { |a| { :attribute_name => a[:name], :attribute_type => a[:type] } }
 
-  def create(table_name, attributes, partition_key, range_key = nil, read_capacity = 20, write_capacity = 10, global_indexes = nil)
+      hash_key = options[:attributes].detect { |a| a[:key] == :hash }
+      if hash_key == nil
+        raise 'No Hash Key attribute has been specified.'
+      end
 
-    if exists?(table_name)
-      return
-    end
+      range_key = options[:attributes].detect { |a| a[:key] == :range }
 
-    attribute_definitions = []
+      key_schema = []
+      key_schema.push({ :attribute_name => hash_key[:name], :key_type => :HASH })
+      if range_key != nil
+        key_schema.push({ :attribute_name => range_key[:name], :key_type => :RANGE })
+      end
 
-    attributes.each do |a|
-      attribute_definitions.push({ :attribute_name => a[:name], :attribute_type => a[:type] })
-    end
+      table = {
+          :table_name => options[:name],
+          :attribute_definitions => attribute_definitions,
+          :key_schema => key_schema,
+          :provisioned_throughput => {
+              :read_capacity_units => options[:read_capacity],
+              :write_capacity_units => options[:write_capacity]
+          }
+      }
+
+      if options[:global_indexes] != nil
+        table[:global_secondary_indexes] = options[:global_indexes]
+      end
 
-    key_schema = []
-    key_schema.push({ :attribute_name => partition_key, :key_type => :HASH })
-    if range_key != nil
-      key_schema.push({ :attribute_name => range_key, :key_type => :RANGE })
-    end
+      dynamodb.client.create_table(table)
 
-    table = {
-        :table_name => table_name,
-        :attribute_definitions => attribute_definitions,
-        :key_schema => key_schema,
-        :provisioned_throughput => {
-            :read_capacity_units => read_capacity,
-            :write_capacity_units => write_capacity
-        }
-    }
-
-    if global_indexes != nil
-      table[:global_secondary_indexes] = global_indexes
+      # wait for table to be created
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Waiting for table: [#{options[:name]}] to be created."
+      dynamodb.client.wait_until(:table_exists, table_name: options[:name])
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Table: [#{options[:name]}] created."
     end
 
-    dynamodb.client.create_table(table)
+    def create_global_index(name, partition_key, range_key = nil, read_capacity = 20, write_capacity = 10)
 
-    # wait for table to be created
-    puts "waiting for table: [#{table_name}] to be created..."
-    dynamodb.client.wait_until(:table_exists, table_name: table_name)
-    puts "table: [#{table_name}] created!"
-  end
+      key_schema = []
+
+      key_schema.push({ :attribute_name => partition_key, :key_type => :HASH })
+      if range_key != nil
+        key_schema.push({ :attribute_name => range_key, :key_type => :RANGE })
+      end
+
+      index = {
+          :index_name => name,
+          :key_schema => key_schema,
+          :projection => {
+              :projection_type => :ALL
+          },
+          :provisioned_throughput => {
+              :read_capacity_units => read_capacity,
+              :write_capacity_units => write_capacity,
+          }
+      }
+
+      return index
+    end
 
-  def create_global_index(name, partition_key, range_key = nil, read_capacity = 20, write_capacity = 10)
+    def drop(table_name)
 
-    key_schema = []
+      if !exists?(table_name)
+        return
+      end
 
-    key_schema.push({ :attribute_name => partition_key, :key_type => :HASH })
-    if range_key != nil
-      key_schema.push({ :attribute_name => range_key, :key_type => :RANGE })
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Dropping table: [#{table_name}]."
+      dynamodb.client.delete_table({ table_name: table_name })
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Table: [#{table_name}] dropped."
     end
 
-    index = {
-        :index_name => name,
-        :key_schema => key_schema,
-        :projection => {
-            :projection_type => :ALL
-        },
-        :provisioned_throughput => {
-            :read_capacity_units => read_capacity,
-            :write_capacity_units => write_capacity,
-        }
-    }
-
-    return index
-  end
+    def drop_table(table_name)
 
-  def drop(table_name)
+      if !exists?(table_name)
+        return
+      end
 
-    if !exists?(table_name)
-      return
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Dropping table: [#{table_name}]."
+      dynamodb.client.delete_table({ table_name: table_name })
+      DynamoDbFramework::LOGGER.info "[DynamoDbFramework] - Table: [#{table_name}] dropped."
     end
 
-    puts "dropping table: [#{table_name}] ..."
-    dynamodb.client.delete_table({ table_name: table_name })
-    puts "table: [#{table_name}] dropped!"
   end
-
-end
+end