awscli 0.1.3 → 0.1.4

data/README.md

@@ -1,13 +1,16 @@
 awscli
 ======
 
-Amazon Web Service Command Line Interface
+Amazon Web Service(s) Command Line Interface
 
-Provides support for following interface:
+Provides the following interface:
 
 - Elastic Cloud Compute (EC2)
 - Auto Scaling Group (AS)
 - Simple Storage Service (S3)
+- AWS Identity and Access Management Interface (IAM)
+- Elastic MapReduce (EMR)
+- DynamoDB
 
 More interfaces are in development.
 

data/lib/awscli/cli/as.rb

@@ -4,7 +4,7 @@ module AwsCli
     require 'awscli/connection'
     require 'awscli/as'
     class As < Thor
-      class_option :region, :type => :string, :desc => "region to connect to"
+      class_option :region, :type => :string, :desc => 'region to connect to'
 
       AwsCli::Cli.register AwsCli::CLI::As, :as, 'as [COMMAND]', 'Auto Scaling Interface'
     end

data/lib/awscli/cli/dynamo/item.rb

@@ -0,0 +1,265 @@
+module AwsCli
+  module CLI
+    module DYNAMO
+      require 'awscli/cli/dynamo'
+      class Item < Thor
+
+        conditional_item = <<-eos
+          Conditional Put/Delete/Update an Item:
+
+          Put/Delete/Update an element into a table using conditional put/delete/update: (The Expected parameter using
+          combination of -e and -x allows you to provide an attribute name, and whether or not Amazon DynamoDB
+          should check to see if the attribute value already exists; or if the attribute value exists and has a
+          particular value before changing it)
+
+          The following option combination replaces/deletes/updates the item if the "Color" attribute doesn't already
+          exist for that item:
+          `-e Color -x false`
+
+          The following option combination checks to see if the attribute with name "Color" has an existing value of
+          "Yellow" before replacing/deleting/updating the item
+          `-e Color:S:Yellow -x true`
+
+          By default, if you use the Expected parameter and provide a Value, Amazon DynamoDB assumes the attribute
+          exists and has a current value to be replaced. So you don't have to specify {-x true}, because it is implied.
+          You can shorten the request to:
+          `-e Color:S:Yellow`
+        eos
+
+        desc 'put [OPTIONS]', 'creates a new item, or replaces an old item with new item'
+        long_desc <<-DESC
+          Usage:
+
+          `awscli dynamo item put -t <table_name> -i <pk_col_name>:<type>:<value> <col_name>:<type>:<value> -a <expected_attr_name>:<type>:<value> -e <true|false> -r <return_values>`
+
+          Examples:
+
+          Put an element into a table:
+
+          `awscli dynamo item put -t test_table -i Id:N:1 UserName:S:test_user`
+
+           #{conditional_item}
+
+          `awscli dynamo item put -t test -i Id:N:1 UserName:S:test_user -a UserName:S:test -e true -r ALL_OLD`
+        DESC
+        method_option :table_name, :aliases => '-t', :desc => 'name of the table to contain the item'
+        method_option :item, :aliases => '-i', :type => :array, :desc => 'item to insert (must include primary key as well). Format => attribute_name:type(N|NS|S|SS|B|BS):value'
+        method_option :expected_attr, :aliases => '-e', :desc => 'data to check against for conditional put. Format => attribute_name:type:value'
+        method_option :expected_exists, :aliases => '-x', :desc => 'set as false to only allow update if attribute does not exist. Valid values: true|false'
+        method_option :return_values, :aliases => '-v', :default => 'NONE', :desc => 'data to return(use this parameter if you want to get the attribute name-value pairs before they were updated). Valid values in (ALL_NEW|ALL_OLD|NONE|UPDATED_NEW|UPDATED_OLD)'
+        def put
+          unless options[:table_name] and options[:item]
+            abort 'required options --table-name, --item'
+          end
+          if options[:expected_exists]
+            abort '--expected-exists only accepts true or false' unless %w(true false).include?(options[:expected_exists])
+          end
+          create_dynamo_object
+          @ddb.put options
+        end
+
+        desc 'get [OPTIONS]', 'returns a set of Attributes for an item that matches the primary key'
+        method_option :table_name, :aliases => '-t', :desc => ' name of the table containing the requested item'
+        method_option :hash_key, :aliases => '-k', :desc => 'primary key values that define the item. Format => attr_type:attr_value'
+        method_option :range_key, :aliases => '-r', :desc => 'optional info for range key. Format => attr_type:attr_value'
+        method_option :attrs_to_get, :aliases => '-g', :type => :array, :desc => 'Array of Attribute names. If attribute names are not specified then all attributes will be returned'
+        method_option :consistent_read, :aliases => '-c', :type => :boolean, :desc => 'If set then a consistent read is issued, otherwise eventually consistent is used'
+        def get
+          unless options[:table_name] and options[:hash_key]
+            abort 'required options --table-name, --hash-key'
+          end
+          create_dynamo_object
+          @ddb.get options
+        end
+
+        desc 'update [OPTIONS]', 'edits an existing items attributes'
+        long_desc <<-DESC
+          Update DynamoDB item, cannot update the primary key attributes using UpdateItem.
+          Instead, delete the item and use put to create a new item with new attributes
+        DESC
+        method_option :table_name, :aliases => '-t', :desc => 'name of the table containing the item to update'
+        method_option :hash_key, :aliases => '-k', :desc => 'primary key that defines the item. Format => attr_type:attr_value'
+        method_option :range_key, :aliases => '-r', :desc => 'optional info for range key. Format => attr_type:attr_value'
+        method_option :attr_updates, :aliases => '-u', :type =>:array, :desc => 'array of attribute name to the new value for the update. Format: attribute_name:type:value'
+        method_option :attr_updates_action, :aliases => '-a', :default => 'PUT', :desc => 'specifies how to perform the update. Possible values: (PUT|ADD|DELETE)'
+        method_option :expected_attr, :aliases => '-e', :desc => 'designates an attribute for a conditional update. Format => attribute_name:type:value'
+        method_option :expected_exists, :aliases => '-x', :desc => 'set as false to only allow update if attribute does not exist. Valid values: true|false'
+        method_option :return_values, :aliases => '-v', :default => 'NONE', :desc => 'data to return(use this parameter if you want to get the attribute name-value pairs before they were updated). Valid values in (ALL_NEW|ALL_OLD|NONE|UPDATED_NEW|UPDATED_OLD)'
+        def update
+          unless options[:table_name] and options[:hash_key] and options[:attr_updates]
+            abort 'required options --table-name, --hash-kye, --attr-updates'
+          end
+          if options[:expected_exists]
+            abort '--expected-exists only accepts true or false' unless %w(true false).include?(options[:expected_exists])
+          end
+          create_dynamo_object
+          @ddb.update options
+        end
+
+        desc 'delete [OPTIONS]', 'deletes a single item in a table by primary key'
+        long_desc <<-DESC
+          Deletes a single item in a table by primary key. You can perform a conditional delete operation that deletes
+          the item if it exists, or if it has an expected attribute value.
+
+          If you specify DeleteItem without attributes or values, all the attributes for the item are deleted
+        DESC
+        method_option :table_name, :aliases => '-t', :desc => 'name of the table containing the item to delete'
+        method_option :hash_key, :aliases => '-k', :desc => 'primary key that defines the item. Format => attr_type:attr_value'
+        method_option :range_key, :aliases => '-r', :desc => 'optional info for range key. Format => attr_type:attr_value'
+        method_option :expected_attr, :aliases => '-e', :desc => 'data to check against for conditional put. Format => attribute_name:type:value'
+        method_option :expected_exists, :aliases => '-x', :desc => 'set as false to only allow update if attribute does not exist. Valid values: true|false'
+        method_option :return_values, :aliases => '-v', :default => 'NONE', :desc => 'data to return(use this parameter if you want to get the attribute name-value pairs before they were updated). Valid values in (ALL_NEW|ALL_OLD|NONE|UPDATED_NEW|UPDATED_OLD)'
+        def delete
+          unless options[:table_name] and options[:hash_key]
+            abort 'required options --table-name, --hash-key'
+          end
+          if options[:expected_exists]
+            abort '--expected-exists only accepts true or false' unless %w(true false).include?(options[:expected_exists])
+          end
+          create_dynamo_object
+          @ddb.delete options
+        end
+
+        desc 'query [OPTIONS]', 'returns one or more items and their attributes by primary key (only available for hash-and-range primary key tables)'
+        method_option :table_name, :aliases => '-t', :desc => 'name of the table containing the requested items'
+        method_option :attrs_to_get, :aliases => '-g', :type => :array, :desc => 'array of attribute names, if attribute names are not specified then all attributes will be returned'
+        method_option :limit, :aliases => '-l', :type => :numeric, :desc => 'limit of total items to return'
+        method_option :count, :aliases => '-c', :type => :boolean, :default => false, :desc => 'if true, returns only a count of such items rather than items themselves'
+        method_option :hash_key_value, :aliases => '-v', :desc => 'attribute value of the hash component of the composite primary key. Format => HashKeyElementType,HashKeyElementValue'
+        method_option :range_key_filter, :aliases => '-f', :desc => 'A container for the attribute values and comparison operators to use for the query. Format => Operator(BETWEEN BEGINS_WITH EQ LE LT GE GT),Attr_Type(N|S|B|NS|SS|BS),Attr_Value'
+        method_option :scan_index_forward, :aliases => '-i', :default => 'true', :desc => 'Specifies ascending or descending traversal of the index, Possible Values: (true|false). Default: true'
+        method_option :start_key, :aliases => '-s', :desc => 'Primary key of the item from which to continue an earlier scan. Format => HashKeyElementType,HashKeyElementValue'
+        method_option :start_range_key, :aliases => '-k', :desc => 'Primary Range key of the item from which to continue an earlier scan. Format => RangeKeyElementType,RangeKeyElementValue'
+        def query
+          unless options[:table_name] and options[:hash_key_value]
+            abort 'options --table-name and --hash-key-value are required'
+          end
+          abort 'invalid --hash-key-value format' unless options[:hash_key_value] =~ /^(.*?),(.*?)$/
+          if options[:scan_index_forward]
+            abort 'invalid option --scan-index-forward value' unless options[:scan_index_forward] =~ /true|false/
+          end
+          if options[:range_key_filter]
+            abort 'invalid --range-key-filter format' unless options[:range_key_filter] =~ /^(BETWEEN|BEGINS_WITH|EQ|LE|LT|GE|GT),(N|S|B|NS|SS|BS),(.*?)$/
+          end
+          if options[:start_key]
+            abort 'Invalid --start-key format' unless options[:start_key] =~ /^(.*?),(.*?)$/
+          end
+          if options[:start_range_key]
+            abort 'Invalid --start-range-key format' unless options[:start_range_key] =~ /^(.*?),(.*?)$/
+          end
+          create_dynamo_object
+          @ddb.query options
+        end
+
+        desc 'scan [OPTIONS]', 'returns one or more items and its attributes by performing a full scan of a table'
+        long_desc <<-DESC
+
+        DESC
+        method_option :table_name, :aliases => '-t', :desc => 'name of the table containing the requested items'
+        method_option :attrs_to_get, :aliases => '-g', :type => :array, :desc => 'array of attribute names, if attribute names are not specified then all attributes will be returned'
+        method_option :limit, :aliases => '-l', :type => :numeric, :desc => 'limit of total items to return'
+        method_option :count, :aliases => '-c', :type => :boolean, :default => false, :desc => 'if true, returns only a count of such items rather than items themselves'
+        method_option :consistent_read, :type => :boolean, :default => false, :desc => 'whether to wait for consistency, defaults to false'
+        method_option :scan_filter, :aliases => '-f', :desc => 'Evaluates the scan results and returns only the desired values. Format=> Operator(BETWEEN BEGINS_WITH EQ LE LT GE GT),Attr_Name,Attr_Type(N|S|B|NS|SS|BS),Attr_Value'
+        method_option :start_key, :aliases => '-s', :desc => 'Primary key of the item from which to continue an earlier scan. Format => HashKeyElementType,HashKeyElementValue'
+        method_option :start_range_key, :aliases => '-k', :desc => 'Primary Range key of the item from which to continue an earlier scan. Format => RangeKeyElementType,RangeKeyElementValue'
+        def scan
+          unless options[:table_name]
+            abort 'option --table-name is required.'
+          end
+          if options[:scan_filter]
+            abort 'Invalid --scan-filter format' unless options[:scan_filter] =~ /^(BETWEEN|BEGINS_WITH|EQ|LE|LT|GE|GT),(.*?),(N|S|B|NS|SS|BS),(.*?)$/
+          end
+          if options[:start_key]
+            abort 'Invalid --start-key format' unless options[:start_key] =~ /^(.*?),(.*?)$/
+          end
+          if options[:start_range_key]
+            abort 'Invalid --start-range-key format' unless options[:start_range_key] =~ /^(.*?),(.*?)$/
+          end
+          create_dynamo_object
+          @ddb.scan options
+        end
+
+        desc 'batch_get [OPTIONS]', 'returns the attributes for multiple items from multiple tables using their primary keys'
+        long_desc <<-DESC
+        batch_get fetches items in parallel to minimize response latencies
+        This operation has following limitations:
+        The maximum number of items that can be retrieved for a single operation is 100. Also, the number of items.
+        Retrieved is constrained by a 1 MB size limit.
+
+        Usage Examples:
+
+        The following example will get the data from two different tables: comp2 & comp1. From table comp2 get username and friends
+        whose primary hash keys are Julie & Mingus and of type S(String). From table comp1 get username and status whose primary keys
+        are Casey & Dave of type S(String) and also match data based on range key 1319509152 & 1319509155 respectively for users.
+
+        `awscli dynamo item batch_get -r comp2,S=Julie,S=Mingus comp1,S=Casey:N=1319509152,S=Dave:N=1319509155 -g user:friends user:status`
+        DESC
+        method_option :requests, :aliases => '-r', :type => :array, :desc => 'A container of the table name and corresponding items to get by primary key. Format => tbl1_name*,KeySet1(hash_key_type*=hash_key_value*:range_key_type=range_key_value),KeySet2,KeySetN'
+        method_option :attrs_to_get, :aliases => '-g', :type => :array, :desc => 'Attributes to get from each respective table. Format => tbl1_attr1:tbl1_attr2:tbl1_attr3 tbl2_attr1:tbl2_attr2:tbl2_attr3 ..'
+        method_option :consistent_read, :aliases => '-c', :type => :boolean, :desc => 'If set then a consistent read is issued, otherwise eventually consistent is used'
+        def batch_get
+          unless options[:requests]
+            abort 'option --requests is required'
+          end
+          options[:requests].each do |request|
+            unless request =~ /^(.*?)(?:,((N|S|B|NS|SS|BS)=(.*?))(:(N|S|B|NS|SS|BS)=(.*?))*)+$/
+              abort 'Invalid --request format, see `awscli dynamo item help batch_get` for usage examples'
+            end
+          end
+          create_dynamo_object
+          @ddb.batch_get options
+        end
+
+        desc 'batch_write [OPTIONS]', 'performs put or delete several items across multiple tables'
+        long_desc <<-DESC
+        `batch_write` enables you to put or delete several items across multiple tables in a single API call
+        This operation has following limitations:
+        Maximum operations in a single request: You can specify a total of up to 25 put or delete operations.
+        Unlike the put and delete, batch_write does not allow you to specify conditions on individual write requests in the operation.
+
+        Usage Examples:
+
+        The following batch_write operation will put an item into User, Item tables and deletes item from User, Thread tables
+
+        `bundle exec bin/awscli dynamo item batch_write --put-requests User,Id:S:003,UserName:S:user123,Password:S:secret123 Item,Id:S:'Amazon Dynamo DB#Thread 5',ReplyDateTime:S:'2012-04-03T11:04:47.034Z' --delete-requests User,S=003 Thread,S='Amazon DynamoDB#Thread 4':S='oops - accidental row'`
+        DESC
+        method_option :put_requests, :aliases => '-p', :type => :array, :desc => 'Format=> table_name,col_name1:col_type1:col_value1,col_name2:col_type2:col_value2 ..'
+        method_option :delete_requests, :aliases => '-d', :type => :array, :desc => 'Format=> table_name,hash_key_type*=hash_key_value*:range_key_type=range_key_value ..'
+        def batch_write
+          unless options[:put_requests] or options[:delete_requests]
+            abort 'option --put-requests or --delete-requests is required to perform batch_write'
+          end
+          options[:put_requests] and options[:put_requests].each do |put_request|
+            unless put_request =~ /^(.*?)(?:,((.*?):(N|S|B|NS|SS|BS):(.*?))*)+$/
+              abort 'Invalid --put-requests format, see `awscli dynamo item help batch_write` for usage examples'
+            end
+          end
+          options[:delete_requests] and options[:delete_requests].each do |delete_request|
+            unless delete_request =~ /^(.*?)(?:,((N|S|B|NS|SS|BS)=(.*?))(:(N|S|B|NS|SS|BS)=(.*?))*)+$/
+              abort 'Invalid --delete-requests format, see `awscli dynamo item help batch_write` for usage examples'
+            end
+          end
+          create_dynamo_object
+          @ddb.batch_write options
+        end
+
+        private
+
+        def create_dynamo_object
+          puts 'Dynamo Establishing Connection...'
+          $dynamo_conn =  if parent_options[:region]
+                            Awscli::Connection.new.request_dynamo(parent_options[:region])
+                          else
+                            Awscli::Connection.new.request_dynamo
+                          end
+          puts 'Dynamo Establishing Connection... OK'
+          @ddb = Awscli::DynamoDB::Items.new($dynamo_conn)
+        end
+
+        AwsCli::CLI::Dynamo.register AwsCli::CLI::DYNAMO::Item, :item, 'item [COMMAND]', 'Dynamo DB Item(s) Management'
+
+      end
+    end
+  end
+end

data/lib/awscli/cli/dynamo/table.rb

@@ -0,0 +1,72 @@
+module AwsCli
+  module CLI
+    module DYNAMO
+      require 'awscli/cli/dynamo'
+      class Table < Thor
+
+        desc 'list', 'list available tables'
+        method_option :limit, :aliases => '-l', :type => :numeric, :desc => 'A number of maximum table names to return.'
+        #method_option :exclusive_start_table_name, :aliases => '-e', :banner => 'NAME', :desc => 'The name of the table that starts the list'
+        def list
+          create_dynamo_object
+          @ddb.list options
+        end
+
+        desc 'info', 'returns information about the table'
+        method_option :name, :aliases => '-n', :required => true, :desc => 'name of the table to list information for'
+        def info
+          create_dynamo_object
+          @ddb.describe options[:name]
+        end
+
+        desc 'create', 'create a new table'
+        method_option :name, :aliases => '-n', :required => true, :desc => 'name of the table to create, name should be unique among your account'
+        method_option :pk_name, :aliases => '-k', :required => true, :desc => 'primary key hash attribute name for the table'
+        method_option :pk_type, :aliases => '-t', :required => true, :desc => 'type of the hash attribute, valid values in [N, NS, S, SS]. N-Number, NS-NumberSet, S-String, SS-StringSet'
+        method_option :rk_name, :desc => 'range attribute name for the table (if specified will create a composite primary key)'
+        method_option :rk_type, :desc => 'type of the range attribute, valid values in [N, NS, S, SS]'
+        method_option :read_capacity, :aliases => '-r', :required => true, :type => :numeric, :desc => 'minimum number of consistent ReadCapacityUnits consumed per second for the specified table'
+        method_option :write_capacity, :aliases => '-w', :required => true, :type => :numeric, :desc => 'minimum number of WriteCapacityUnits consumed per second for the specified table'
+        def create
+          #name should be > 3 and can contain a-z, A-Z, 0-9, _, .
+          #type should be in N, NS, S, SS
+          #read and write capacity in between 5..10000
+          create_dynamo_object
+          @ddb.create options
+        end
+
+        desc 'delete', 'deletes a table and all its items'
+        method_option :name, :aliases => '-n', :required => true, :desc => 'name of the table to delete'
+        def delete
+          create_dynamo_object
+          @ddb.delete options[:name]
+        end
+
+        desc 'update', 'updates existing dynamo db table provisioned throughput'
+        method_option :name, :aliases => '-n', :required => true, :desc => 'name of the table to update'
+        method_option :read_capacity, :aliases => '-r', :required => true, :type => :numeric, :desc => 'minimum number of consistent ReadCapacityUnits consumed per second for the specified table'
+        method_option :write_capacity, :aliases => '-w', :required => true, :type => :numeric, :desc => 'minimum number of WriteCapacityUnits consumed per second for the specified table'
+        def update
+          create_dynamo_object
+          @ddb.update options
+        end
+
+        private
+
+        def create_dynamo_object
+          puts 'Dynamo Establishing Connection...'
+          $dynamo_conn =  if parent_options[:region]
+                            Awscli::Connection.new.request_dynamo(parent_options[:region])
+                          else
+                            Awscli::Connection.new.request_dynamo
+                          end
+          puts 'Dynamo Establishing Connection... OK'
+          @ddb = Awscli::DynamoDB::Table.new($dynamo_conn)
+        end
+
+        AwsCli::CLI::Dynamo.register AwsCli::CLI::DYNAMO::Table, :table, 'table [COMMAND]', 'Dynamo Table Management'
+
+      end
+    end
+  end
+end

data/lib/awscli/cli/dynamo.rb

@@ -0,0 +1,12 @@
+module AwsCli
+  module CLI
+    require 'awscli/cli'
+    require 'awscli/connection'
+    require 'awscli/dynamo'
+    class Dynamo < Thor
+      class_option :region, :type => :string, :desc => 'region to connect to', :default => 'us-west-1'
+
+      AwsCli::Cli.register AwsCli::CLI::Dynamo, :dynamo, 'dynamo [COMMAND]', 'Amazons NoSQL DynamoDB Interface'
+    end
+  end
+end

data/lib/awscli/cli/emr.rb

@@ -4,7 +4,7 @@ module AwsCli
     require 'awscli/connection'
     require 'awscli/emr'
     class Emr < Thor
-      class_option :region, :type => :string, :desc => "region to connect to", :default => 'us-west-1'
+      class_option :region, :type => :string, :desc => 'region to connect to', :default => 'us-west-1'
 
       desc 'usage', 'show the usage examples'
       def usage
@@ -75,7 +75,6 @@ module AwsCli
       end
 
       desc 'create [OPTIONS]', 'creates and starts running a new job flow'
-      #TODO: update Long Desc
       long_desc <<-DESC
         Creates and starts running a new job flow.
 
@@ -113,7 +112,7 @@ module AwsCli
       method_option :hbase_backup_schedule, :desc => 'Specify whether to schedule automatic incremental backups. Format=> frequency*,frequency_unit*(Days|Hours|Mins),path(s3)*,start_time*(now|date)'
       method_option :hbase_consistent_backup, :type => :boolean, :default => false, :desc => 'Perform a consistent backup'
       def create
-        if !options[:name]
+        unless options[:name]
           puts 'These options are required --name'
           exit
         end
@@ -126,7 +125,7 @@ module AwsCli
       method_option :instance_groups, :type => :array, :aliases => '-g', :desc => 'Add instance groups. Format => "instance_count,instance_role(MASTER | CORE | TASK),instance_type,name,bid_price"'
       def add_ig
         unless options[:job_flow_id] and options[:instance_groups]
-          abort "--job-flow-id and --instance-groups are required"
+          abort '--job-flow-id and --instance-groups are required'
         end
         create_emr_object
         @emr.add_instance_groups options[:job_flow_id], options[:instance_groups]
@@ -137,17 +136,18 @@ module AwsCli
       method_option :steps, :aliases => '-s', :type => :array, :desc => 'Add list of steps to be executed by job flow. Format=> jar_path(s3)*,name_of_step*,main_class,action_on_failure(TERMINATE_JOB_FLOW | CANCEL_AND_WAIT | CONTINUE),arg1=agr2=arg3,properties(k=v,k=v)'
       def add_steps
         unless options[:job_flow_id] and options[:steps]
-          abort "--job-flow-id and --steps are required"
+          abort '--job-flow-id and --steps are required'
         end
         create_emr_object
         @emr.add_steps options[:job_flow_id], options[:steps]
       end
+
       private
 
       def create_emr_object
-        puts 'EMR Establishing Connetion...'
+        puts 'EMR Establishing Connection...'
         $emr_conn =  Awscli::Connection.new.request_emr
-        puts 'EMR Establishing Connetion... OK'
+        puts 'EMR Establishing Connection... OK'
         @emr = Awscli::Emr::EMR.new($emr_conn)
       end
 

data/lib/awscli/connection.rb

@@ -71,5 +71,17 @@ module Awscli
       Fog::AWS::EMR.new(@config)
     end
 
+    def request_dynamo(region=nil)
+      # => returns AWS DynamoDB object
+      if region
+        Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(region)
+        @config.reject!{ |key| key == 'region' } if @config['region']
+        @config.merge!(:region => region)
+      else
+        Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(@config['region']) if @config['region']
+      end
+      Fog::AWS::DynamoDB.new(@config)
+    end
+
   end
 end

data/lib/awscli/dynamo.rb

@@ -0,0 +1,411 @@
+module Awscli
+  module DynamoDB
+    class Table
+      def initialize(connection)
+        @conn = connection
+      end
+
+      def list(options)
+        opts = {}
+        table_data = []
+        opts['Limit'] = options[:limit] if options[:limit]
+        @conn.list_tables(opts).body['TableNames'].each do |table|
+          table_data << { :table => table }
+        end
+        if table_data.empty?
+          puts 'No tables found'
+        else
+          Formatador.display_table(table_data)
+        end
+      end
+
+      def create(options)
+        key_schema, provisioned_throughput = {}, {}
+        abort 'Invalid key type' unless %w(N NS S SS).include?(options[:pk_type])
+        key_schema['HashKeyElement'] = {
+          'AttributeName' => options[:pk_name],
+          'AttributeType' => options[:pk_type]
+        }
+        if options[:rk_name]
+          abort '--rk_type is required if --rk-name is passed' unless options[:rk_name]
+          abort 'Invalid key type' unless %w(N NS S SS).include?(options[:rk_type])
+          key_schema['RangeKeyElement'] = {
+            'AttributeName' => options[:rk_name],
+            'AttributeType' => options[:rk_type]
+          }
+        end
+        provisioned_throughput['ReadCapacityUnits'] = options[:read_capacity]
+        provisioned_throughput['WriteCapacityUnits'] = options[:write_capacity]
+        @conn.create_table(options[:name], key_schema, provisioned_throughput)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to create table. #{parse_excon_error_response($!)}"
+      else
+        puts "Create table #{options[:name]} successfully."
+      end
+
+      def describe(table_name)
+        puts @conn.describe_table(table_name).body.to_yaml
+      rescue Excon::Errors::BadRequest
+        puts 'Table not found'
+      end
+
+      def delete(table_name)
+        @conn.delete_table(table_name)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to delete table. #{parse_excon_error_response($!)}"
+      else
+        puts "Delete table #{table_name} successfully."
+      end
+
+      def update(options)
+        provisioned_throughput = {}
+        provisioned_throughput['ReadCapacityUnits'] = options[:read_capacity]
+        provisioned_throughput['WriteCapacityUnits'] = options[:write_capacity]
+        @conn.update_table(options[:name], provisioned_throughput)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to update table. #{parse_excon_error_response($!)}"
+      else
+        puts "Table #{options[:name]} provisioned capacity updated successfully."
+      end
+
+      private
+
+      def parse_excon_error_response(response)
+        response.data[:body].match(/message.*/)[0].gsub(/[^A-Za-z0-9: ]/, '')
+      end
+    end
+
+    class Items
+      def initialize(connection)
+        @conn = connection
+      end
+
+      def query(options)
+        opts = {}
+        hash_key_type, hash_key_value = options[:hash_key_value].split(',')
+        hash_key = { hash_key_type => hash_key_value }
+        opts['AttributesToGet'] = options[:attrs_to_get] if options[:attrs_to_get]
+        opts['Limit'] = options[:limit] if options[:limit]
+        opts['Count'] = options[:count] if options[:count]
+        opts['ConsistentRead'] = options[:consistent_read] if options[:consistent_read]
+        if options[:range_key_filter]
+          operator, attr_type, attr_value = options[:range_key_filter].split(',')
+          opts['RangeKeyCondition'] = {
+              'AttributeValueList' => [{ attr_type => attr_value }],
+              'ComparisonOperator' => operator
+          }
+        end
+        opts['ScanIndexForward'] = options[:scan_index_forward]
+        if options[:start_key]
+          opts['ExclusiveStartKey'] = {}
+          hash_key_type, hash_key_value = options[:start_key].split(',')
+          opts['ExclusiveStartKey']['HashKeyElement'] = { hash_key_type => hash_key_value }
+          if options[:start_range_key]
+            range_key_type, range_key_value = options[:start_range_key].split(',')
+            opts['ExclusiveStartKey']['RangeKeyElement'] = { range_key_type => range_key_value }
+          end
+        end
+        p opts
+        data = @conn.query(options[:table_name], hash_key, opts)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to perform scan on table. #{parse_excon_error_response($!)}"
+      else
+        total_items = data.data[:body]['Count']
+        items = data.data[:body]['Items']
+        if not options[:count]
+          puts "Retrieved #{total_items} Items"
+          Formatador.display_table(items)
+        else
+          puts "Items Count: #{total_items}"
+        end
+        puts "LastEvaluatedKey: #{data.data[:body]['LastEvaluatedKey']}" if data.data[:body]['LastEvaluatedKey']
+      end
+
+      def scan(options)
+        opts = {}
+        opts['AttributesToGet'] = options[:attrs_to_get] if options[:attrs_to_get]
+        opts['Limit'] = options[:limit] if options[:limit]
+        opts['ConsistentRead'] = options[:consistent_read] if options[:consistent_read]
+        opts['Count'] = options[:count] if options[:count]
+        if options[:scan_filter]
+          #Operator(BETWEEN BEGINS_WITH EQ LE LT GE GT),Attr_Name,Attr_Type(N|S|B|NS|SS|BS),Attr_Value
+          operator, attr_name, attr_type, attr_value = options[:scan_filter].split(',')
+          #case operator
+          #  when 'EQ', 'NE', 'LE', 'LT', 'GE', 'GT', 'CONTAINS', 'NOT_CONTAINS', 'BEGINS_WITH'
+          #    #can contain only one AttributeValue element
+          #  when 'BETWEEN'
+          #    #contain two AttributeValue elements
+          #  else
+          #    #IN - can contain any number of AttributeValue elements
+          #end
+          opts['ScanFilter'] = {
+              attr_name => {
+                  'AttributeValueList' => [{ attr_type => attr_value }],
+                  'ComparisonOperator' => operator
+              }
+          }
+        end
+        if options[:start_key]
+          opts['ExclusiveStartKey'] = {}
+          hash_key_type, hash_key_value = options[:start_key].split(',')
+          opts['ExclusiveStartKey']['HashKeyElement'] = { hash_key_type => hash_key_value }
+          if options[:start_range_key]
+            range_key_type, range_key_value = options[:start_range_key].split(',')
+            opts['ExclusiveStartKey']['RangeKeyElement'] = { range_key_type => range_key_value }
+          end
+        end
+        data = @conn.scan(options[:table_name], opts)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to perform scan on table. #{parse_excon_error_response($!)}"
+      else
+        total_items = data.data[:body]['Count']
+        items = data.data[:body]['Items']
+        if not options[:count]
+          puts "Retrieved #{total_items} Items"
+          Formatador.display_table(items)
+        else
+          puts "Items Count: #{total_items}"
+        end
+        puts "LastEvaluatedKey: #{data.data[:body]['LastEvaluatedKey']}" if data.data[:body]['LastEvaluatedKey']
+      end
+
+      def put(options)
+        items = {}
+        opts = {}
+        options[:item].each do |item|
+          abort "invalid item format: #{item}" unless item =~ /(.*):(N|S|NS|SS|B|BS):(.*)/
+          attr_name, attr_type, attr_value = item.split(':')
+          items[attr_name] = { attr_type => attr_value }
+        end
+        if options[:expected_attr] #-a
+          expected_attr_name, expected_attr_type, expected_attr_value = options[:expected_attr].split(':')
+          if expected_attr_name and expected_attr_type and expected_attr_value
+            if options[:expected_exists] and options[:expected_exists] == 'true' #-a Id:S:001 -e true
+              opts['Expected'] = { expected_attr_name => { 'Value' => { expected_attr_type => expected_attr_value }, 'Exists' => options[:expected_exists] } }
+            else #-a Id:S:001
+              opts['Expected'] = { expected_attr_name => { 'Value' => { expected_attr_type => expected_attr_value } } }
+            end
+          elsif expected_attr_name and not expected_attr_type and not expected_attr_value
+            if options[:expected_exists] and options[:expected_exists] == 'false' #-a Id -e false
+              opts['Expected'] = { expected_attr_name => { 'Exists' => options[:expected_exists] } }
+            else
+              abort 'Invalid option combination, see help for usage examples'
+            end
+          else
+            abort 'Invalid option combination, see help for usage examples'
+          end
+        end
+        if options[:return_values]
+          abort 'Invalid return type' unless %w(ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD).include?(options[:return_values])
+          opts['ReturnValues'] = options[:return_values]
+        end
+        @conn.put_item(options[:table_name], items, opts)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to put item into table. #{parse_excon_error_response($!)}"
+      else
+        puts 'Item put succeeded.'
+      end
+
+      def get(options)
+        #get_item(table_name, key, options = {})
+        opts = {}
+        key = {}
+        abort 'Invalid --hash-key format' unless options[:hash_key] =~ /(N|S|NS|SS|B|BS):(.*)/
+        hash_key_type, hash_key_name = options[:hash_key].split(':')
+        key['HashKeyElement'] = { hash_key_type => hash_key_name }
+        if options[:range_key]
+          abort 'Invalid --range-key format' unless options[:hash_key] =~ /(N|S|NS|SS|B|BS):(.*)/
+          range_key_type, range_key_name = options[:range_key].split(':')
+          key['RangeKeyElement'] = { range_key_type => range_key_name }
+        end
+
+        opts['AttributesToGet'] = options[:attrs_to_get] if options[:attrs_to_get]
+
+        opts['ConsistentRead'] = true if options[:consistent_read]
+        data = @conn.get_item(options[:table_name], key, opts)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to get item from table. #{parse_excon_error_response($!)}"
+      else
+        #TODO: Pretty print this
+        if not data.body['Item'].nil?
+          puts 'Retrieved Items:'
+          puts "ColumnName \t Type \t Value"
+          data.body['Item'].each do |attr, pair|
+            print "#{attr} \t"
+            pair.map {|type,value|  print "#{type} \t #{value}"}
+            puts
+          end
+        else
+          puts 'No data retrieved'
+        end
+      end
+
+      def batch_get(options)
+        request_items = {}
+        map = options[:requests].zip(options[:attrs_to_get])
+        map.each do |request_attrs_mapping|
+          #tbl1_name*,KeySet1(hash_key_type*=hash_key_value*:range_key_type=range_key_value),KeySet2,KeySetN
+          table_name, *keys = request_attrs_mapping.first.split(',')
+          attrs = request_attrs_mapping.last.split(':') unless request_attrs_mapping.last.nil?
+          request_items[table_name] = {}
+          request_items[table_name]['Keys'] = []
+          keys.each do |key|
+            parsed_key = {}
+            hash_key, range_key = key.split(':')
+            hash_key_type, hash_key_value = hash_key.split('=')
+            parsed_key['HashKeyElement'] = { hash_key_type => hash_key_value }
+            unless range_key.nil?
+              range_key_type, range_key_value = range_key.split('=')
+              parsed_key['RangeKeyElement'] = { range_key_type => range_key_value }
+            end
+            request_items[table_name]['Keys'] << parsed_key
+          end
+          request_items[table_name]['AttributesToGet'] = attrs unless attrs.nil?
+        end
+        puts @conn.batch_get_item(request_items).data[:body]['Responses'].to_yaml
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to get item from table. #{parse_excon_error_response($!)}"
+      end
+
+      def batch_write(options)
+        request_items = {}
+        #request_items['RequestItems'] = {}
+        options[:put_requests] and options[:put_requests].each do |request|
+          #table_name,col_name1:col_type1:col_value1,col_name2:col_type2:col_value2 ..
+          table_name, *cols = request.split(',')
+          request_items[table_name] ||= []
+          put_request = {}
+          put_request['PutRequest'] = {}
+          put_request['PutRequest']['Item'] = {}
+          cols.each do |col|
+            col_name, col_type, col_value = col.split(':')
+            put_request['PutRequest']['Item'][col_name] = { col_type => col_value }
+          end
+          request_items[table_name] << put_request
+        end
+        options[:delete_requests] and options[:delete_requests].each do |request|
+          #table_name,KeySet1(hash_key_type*=hash_key_value*:range_key_type=range_key_value),KeySet2,KeySetN
+          table_name, *keys = request.split(',')
+          request_items[table_name] ||= []
+          delete_request = {}
+          delete_request['DeleteRequest'] = {}
+          delete_request['DeleteRequest']['Key'] = {}
+          keys.each do |key_set|
+            hash_key, range_key = key_set.split(':')
+            hash_key_type, hash_key_value = hash_key.split('=')
+            delete_request['DeleteRequest']['Key']['HashKeyElement'] = { hash_key_type => hash_key_value }
+            if range_key
+              range_key_type, range_key_value = range_key.split('=')
+              delete_request['DeleteRequest']['Key']['RangeKeyElement'] = { range_key_type => range_key_value }
+            end
+          end
+          request_items[table_name] << delete_request
+        end
+        @conn.batch_write_item(request_items)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to batch put/delete item to/from table. #{parse_excon_error_response($!)}"
+      else
+        puts 'Batch Put/Delete Succeeded'
+      end
+
+      def update(options)
+        opts = {}
+        key = {}
+        attribute_updates = {}
+        #Build and validate key
+        abort 'Invalid --hash-key format' unless options[:hash_key] =~ /(N|S|NS|SS|B|BS):(.*)/
+        hash_key_type, hash_key_name = options[:hash_key].split(':')
+        key['HashKeyElement'] = { hash_key_type => hash_key_name }
+        if options[:range_key]
+          abort 'Invalid --range-key format' unless options[:hash_key] =~ /(N|S|NS|SS|B|BS):(.*)/
+          range_key_type, range_key_name = options[:range_key].split(':')
+          key['RangeKeyElement'] = { range_key_type => range_key_name }
+        end
+        #Build and validate attribute_updates
+        options[:attr_updates].each do |attr_update|
+          abort "invalid item format: #{attr_update}" unless attr_update =~ /(.*):(N|S|NS|SS|B|BS):(.*)/
+          attr_name, attr_type, attr_value = attr_update.split(':')
+          attribute_updates[attr_name] = {
+              'Value' => {attr_type => attr_value},
+              'Action' => options[:attr_updates_action]
+          }
+        end
+        #Build and validate options if any
+        if options[:expected_attr] #-a
+          expected_attr_name, expected_attr_type, expected_attr_value = options[:expected_attr].split(':')
+          if expected_attr_name and expected_attr_type and expected_attr_value
+            if options[:expected_exists] and options[:expected_exists] == 'true' #-a Id:S:001 -e true
+              opts['Expected'] = { expected_attr_name => { 'Value' => { expected_attr_type => expected_attr_value }, 'Exists' => options[:expected_exists] } }
+            else #-a Id:S:001
+              opts['Expected'] = { expected_attr_name => { 'Value' => { expected_attr_type => expected_attr_value } } }
+            end
+          elsif expected_attr_name and not expected_attr_type and not expected_attr_value
+            if options[:expected_exists] and options[:expected_exists] == 'false' #-a Id -e false
+              opts['Expected'] = { expected_attr_name => { 'Exists' => options[:expected_exists] } }
+            else
+              abort 'Invalid option combination, see help for usage examples'
+            end
+          else
+            abort 'Invalid option combination, see help for usage examples'
+          end
+        end
+        if options[:return_values]
+          abort 'Invalid return type' unless %w(ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD).include?(options[:return_values])
+          opts['ReturnValues'] = options[:return_values]
+        end
+        @conn.update_item(options[:table_name], key, attribute_updates, opts)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to update item. #{parse_excon_error_response($!)}"
+      else
+        puts 'Item update succeeded.'
+      end
+
+      def delete(options)
+        key = {}
+        opts = {}
+        #Build and validate key
+        abort 'Invalid --hash-key format' unless options[:hash_key] =~ /(N|S|NS|SS|B|BS):(.*)/
+        hash_key_type, hash_key_name = options[:hash_key].split(':')
+        key['HashKeyElement'] = { hash_key_type => hash_key_name }
+        if options[:range_key]
+          abort 'Invalid --range-key format' unless options[:hash_key] =~ /(N|S|NS|SS|B|BS):(.*)/
+          range_key_type, range_key_name = options[:range_key].split(':')
+          key['RangeKeyElement'] = { range_key_type => range_key_name }
+        end
+        if options[:expected_attr] #-e
+          expected_attr_name, expected_attr_type, expected_attr_value = options[:expected_attr].split(':')
+          if expected_attr_name and expected_attr_type and expected_attr_value
+            if options[:expected_exists] and options[:expected_exists] == 'true' #-e Id:S:001 -x true
+              opts['Expected'] = { expected_attr_name => { 'Value' => { expected_attr_type => expected_attr_value }, 'Exists' => options[:expected_exists] } }
+            else #-e Id:S:001
+              opts['Expected'] = { expected_attr_name => { 'Value' => { expected_attr_type => expected_attr_value } } }
+            end
+          elsif expected_attr_name and not expected_attr_type and not expected_attr_value
+            if options[:expected_exists] and options[:expected_exists] == 'false' #-e Id -x false
+              opts['Expected'] = { expected_attr_name => { 'Exists' => options[:expected_exists] } }
+            else
+              abort 'Invalid option combination, see help for usage examples'
+            end
+          else
+            abort 'Invalid option combination, see help for usage examples'
+          end
+        end
+        if options[:return_values]
+          abort 'Invalid return type' unless %w(ALL_NEW ALL_OLD NONE UPDATED_NEW UPDATED_OLD).include?(options[:return_values])
+          opts['ReturnValues'] = options[:return_values]
+        end
+        @conn.delete_item(options[:table_name], key, opts)
+      rescue Excon::Errors::BadRequest
+        puts "[Error] Failed to delete item. #{parse_excon_error_response($!)}"
+      else
+        puts 'Item delete succeeded.'
+      end
+
+      private
+
+      def parse_excon_error_response(response)
+        response.response.data[:body].match(/message.*|Message.*/)[0].gsub(/[^A-Za-z0-9: ]/, '')
+      end
+    end
+  end
+end

data/lib/awscli/emr.rb

@@ -5,7 +5,7 @@ module Awscli
         @conn = connection
       end
 
-      def list options
+      def list(options)
         validate_job_ids options[:job_flow_ids] if options[:job_flow_ids]
         opts = Marshal.load(Marshal.dump(options))
         opts.reject! { |k| k == 'table' } if options[:table]
@@ -69,7 +69,7 @@ module Awscli
         if options[:pig_steps]
           steps << pig_install unless options[:pig_interactive]
           options[:pig_steps].each do |step|
-            steps << parse_pig_steps(step, options[:hadoop_version])
+            steps << parse_pig_steps(step)
           end
         end
         if options[:streaming_steps]
@@ -81,7 +81,7 @@ module Awscli
           boot_strap_actions << hbase_install_boot_strap
           steps << hbase_install_steps
           #validate hadoop version and instance size
-          abort "Invalid hadoop version #{options[:hadoop_version]}, supported Hadoop Versions for HBase are: #{Awscli::EMR::HBASE_SUPPORTED_HADOOP_VERSIONS.join(',')}" unless Awscli::EMR::HBASE_SUPPORTED_HADOOP_VERSIONS.include?(options[:hadoop_version])
+          abort "Invalid hadoop version #{options[:hadoop_version]}, supported Hadoop Versions for HBase are: #{Awscli::EMR::HBASE_SUPPORTED_HADOOP.join(',')}" unless Awscli::EMR::HBASE_SUPPORTED_HADOOP.include?(options[:hadoop_version])
           options[:instance_groups] && parse_instance_groups(options[:instance_groups]).each do |group|
             unless is_valid_instance_type?(group['InstanceType'])
               abort "Instance type #{group['InstanceType']} is not compatible with HBase, instance size should be equal or greater than m1.large"
@@ -235,7 +235,7 @@ module Awscli
         #parse instance_groups => instance_count,instance_role(MASTER | CORE | TASK),instance_type,name,bid_price
         instance_groups = []
         groups.each do |group|
-          instance_count, instance_role, instance_size, name, bid_price = ig.split(',')
+          instance_count, instance_role, instance_size, name, bid_price = group.split(',')
           if instance_count.empty? or instance_role.empty? or instance_size.empty?
             abort 'instance_count, instance_role and instance_size are required'
           end
@@ -276,7 +276,6 @@ module Awscli
             'Path' => path
           }
         }
-        boot_strap_actions
       end
 
       def parse_custom_jar(steps)
@@ -333,7 +332,7 @@ module Awscli
         hive_step
       end
 
-      def parse_pig_steps(step, hadoop_version)
+      def parse_pig_steps(step)
         #parse script_path(s3)*,input_path(s3),output_path(s3),'-p','args1','-p','args2','-p','arg3'
         path, input_path, output_path, *args = step.split(',')
         abort 'path to the hive script is required' if path.empty?

data/lib/awscli/helper.rb

@@ -5,6 +5,7 @@ module Awscli
     INSTANCE_TYPES = %w(on-demand spot)
     REGIONS = %w(eu-west-1 sa-east-1 us-east-1 ap-northeast-1 us-west-2 us-west-1 ap-southeast-1 ap-southeast-2)
   end
+
   module EMR
     VALID_JOB_FLOW_STATUS = %w(RUNNING WAITING SHUTTING_DOWN STARTING)
     HADOOP_HIVE_COMPATIBILITY = {
@@ -19,7 +20,7 @@ module Awscli
       '0.20' => '1.0',
       '0.18' => '1.0'
     }
-    HBASE_SUPPORTED_HADOOP_VERSIONS = %w(0.20.205 1.0.3)
+    HBASE_SUPPORTED_HADOOP = %w(0.20.205 1.0.3)
     HBASE_INVALID_INSTANCES = %w(m1.small c1.medium)
   end
 end

data/lib/awscli/version.rb

@@ -1,3 +1,3 @@
 module Awscli
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/awscli.rb

@@ -57,4 +57,8 @@ module AwsCli
   require 'awscli/cli/iam/profiles'
     #EMR
   require 'awscli/cli/emr'
+    #Dynamo
+  require 'awscli/cli/dynamo'
+  require 'awscli/cli/dynamo/table'
+  require 'awscli/cli/dynamo/item'
 end

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: awscli
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
+  prerelease: 
 platform: ruby
 authors:
 - Ashrith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-06 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -20,6 +22,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -27,6 +30,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -34,6 +38,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -41,6 +46,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: aruba
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -48,6 +54,7 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -55,6 +62,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -62,6 +70,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -69,6 +78,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -76,6 +86,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -83,6 +94,7 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -90,6 +102,7 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
+    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -111,6 +124,9 @@ files:
 - lib/awscli/cli/as/instances.rb
 - lib/awscli/cli/as/policies.rb
 - lib/awscli/cli/as.rb
+- lib/awscli/cli/dynamo/item.rb
+- lib/awscli/cli/dynamo/table.rb
+- lib/awscli/cli/dynamo.rb
 - lib/awscli/cli/ec2/ami.rb
 - lib/awscli/cli/ec2/ebs.rb
 - lib/awscli/cli/ec2/eip.rb
@@ -147,6 +163,7 @@ files:
 - lib/awscli/cli/UsageExamples/emr
 - lib/awscli/cli.rb
 - lib/awscli/connection.rb
+- lib/awscli/dynamo.rb
 - lib/awscli/ec2.rb
 - lib/awscli/emr.rb
 - lib/awscli/errors.rb
@@ -160,27 +177,28 @@ files:
 homepage: http://github.com/ashrithr/awscli
 licenses:
 - MIT
-metadata: {}
 post_install_message: Thanks for installing!, This gem is still in development.
 rdoc_options: []
 require_paths:
 - lib
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 1.8.25
 signing_key: 
-specification_version: 4
+specification_version: 3
 summary: Command Line Interface for Amazon Web Services built in Ruby, using Fog and
   Thor
 test_files: []

checksums.yaml

@@ -1,15 +0,0 @@
----
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZjE2MzQxYjhkMTc5NDc5NzIyMjc2NDNiNzMxYjdiMTI4OThhOWJmNw==
-  data.tar.gz: !binary |-
-    YjdlZjExYTBhMjAzNDE1ZjJiY2RlZWMyMjM1N2QyMzMyYjQxZGIyNQ==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    M2VjYWEyOTBkNmZjYThiZTdmOTdhODQxZjc1Zjc0NDM2NmU1MDMwMDMxNTYx
-    MGQ2NmZkZjJkODFiN2I4Y2JmNWZjZWI1ZTExYmIyMTQ0NjY0YjI3YzgyMmY1
-    MzA1OGRkOTdmN2FlZTAxOWNhY2NiYmJlNzhlN2ZiNTJlMGFkODM=
-  data.tar.gz: !binary |-
-    MmQ2OWM5MGUxNWU4MmJmZWI5NDliMmE3YzNiOWQ5M2M4Nzg3NDZlOTkxNzIw
-    N2I2NTY3MDM4N2RmYzRjYTAwNzgwMGJlMTY2YzBmYjUxNWNmNTEzNzhiMDZh
-    MGFmOTczMmQ0N2ZhYTlhZjIxMDU3MmM5NDhmMzBlMDZjOWI3ODY=