awscli 0.0.3 → 0.0.4

data/lib/awscli/cli/s3.rb

@@ -1,12 +0,0 @@
-module AwsCli
-  module CLI
-    require 'awscli/cli'
-    require 'awscli/connection'
-    require 'awscli/s3'
-    class S3 < Thor
-      class_option :region, :type => :string, :desc => "region to connect to"
-
-      AwsCli::Cli.register AwsCli::CLI::S3, :s3, 's3 [COMMAND]', 'Simple Storage Service Interface'
-    end
-  end
-end

data/lib/awscli/cli/s3/directories.rb

@@ -1,82 +0,0 @@
-module AwsCli
-  module CLI
-    module Sss
-      require 'awscli/cli/s3'
-      class Directories < Thor
-
-        desc "list", "List S3 buckets"
-        def list
-          create_s3_object
-          @s3.list
-        end
-
-        desc "create", "Create an new S3 bucket"
-        method_option :key, :aliases => "-k", :type => :string, :required => true, :desc => "name of the bucket to create(name should be globally unique)"
-        method_option :public, :aliases => "-p", :type => :boolean, :default => false, :desc => "makes the bucket publicly availble"
-        # method_option :x_amz_acl, :aliases => "-x", :type => :string, :desc => "Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']"
-        def create
-          create_s3_object
-          @s3.create options
-        end
-
-        desc "delete", "Delete existing S3 bucket"
-        method_option :key, :aliases => "-k", :type => :string, :required => true, :desc => "name of the bucket to delete"
-        def delete
-          create_s3_object
-          @s3.delete options[:key]
-        end
-
-        desc "set_acl", "Change access control list for an S3 bucket"
-        method_option :key, :aliases => "-k", :type => :string, :required => true, :desc => "name of the bucket to change acl"
-        method_option :acl, :aliases => "-a", :type => :string, :required => true, :desc => "Permissions, must be in ['private', 'public-read', 'public-read-write', 'authenticated-read']"
-        def set_acl
-          create_s3_object
-          @s3.set_acl options[:key], options[:acl]
-        end
-
-        desc "get_acl", "Get access control list for an S3 bucket"
-        method_option :key, :aliases => "-k", :type => :string, :required => true, :desc => "name of the bucket to get acl"
-        def get_acl
-          create_s3_object
-          @s3.get_acl options[:key]
-        end
-
-        desc "get_logging_status", "Get logging status for an S3 bucket"
-        method_option :key, :aliases => "-k", :type => :string, :required => true, :desc => "name of the bucket"
-        def get_logging_status
-          create_s3_object
-          @s3.get_logging_status options[:key]
-        end
-
-        # desc "set_logging_status", "Change logging status for an S3 bucket"
-        # method_option :key, :aliases => "-k", :type => :string, :required => true, :desc => "name of the bucket"
-        # method_option :owner, :aliases => "-o", :type => :hash, :banner => "ID:NAME", :desc => "set id and displayname of the owner"
-        # method_option :grantee, :aliases => "-g", :type => :hash, :banner => "NAME:ID|EMAIL|URI", :desc => "Grantee hash containing, <Display name of the grantee>: <ID of the grantee (or) Email of the grantee (or) Uri of the group to grant access>"
-        # method_option :permission, :aliases => "-p", :type => :string, :desc => "Permission, in [FULL_CONTROL, WRITE, WRITE_ACP, READ, READ_ACP]"
-        # def set_logging_status
-        #   create_s3_object
-        #   (acl ||= []) << options[:grantee] if options[:grantee]
-        #   acl << options[:permission] if options[:permission]
-        #   logging_status = Hash.new
-        #   logging_status['Owner'] = options[:owner] if options[:owner]
-        #   logging_status['AccessControlList'] = acl if acl
-        #   puts "Empty logging_status will disable logging" if logging_status.nil?
-        #   puts "#{logging_status}"
-        #   @s3.set_logging_status options[:key], logging_status
-        # end
-
-        private
-
-        def create_s3_object
-          puts "S3 Establishing Connetion..."
-          $s3_conn = Awscli::Connection.new.request_s3
-          puts "S3 Establishing Connetion... OK"
-          @s3 = Awscli::S3::Directories.new($s3_conn)
-        end
-
-        AwsCli::CLI::S3.register AwsCli::CLI::Sss::Directories, :dirs, 'dirs [COMMAND]', 'S3 Directories Management'
-
-      end
-    end
-  end
-end

data/lib/awscli/cli/s3/files.rb

@@ -1,77 +0,0 @@
-module AwsCli
-  module CLI
-    module Sss
-      require 'awscli/cli/s3'
-      class Files < Thor
-
-        desc "list", "list objects(files) in a bucket"
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "bucket name to print the contents from"
-        def list
-          create_s3_object
-          @s3.list options[:bucket_name]
-        end
-
-        desc "put", "put a file into a bucket"
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "name of the bucket to upload the file to"
-        method_option :file_path, :aliases => "-p", :required => true, :desc => "local file path"
-        def put
-          create_s3_object
-          @s3.upload_file options[:bucket_name], options[:file_path]
-        end
-
-        desc "get", "get a file from a bucket"
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "name of the bucket to download the file from"
-        method_option :file_name, :aliases => "-f", :required => true, :desc => "name of file to download"
-        method_option :local_path, :aliases => "-p", :required => true, :desc => "local fs path, where to download the file to"
-        def get
-          create_s3_object
-          @s3.download_file options[:bucket_name], options[:file_name], options[:local_path]
-        end
-
-        desc "delete", "delete a file from a bucket"
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "name of the bucket to download the file from"
-        method_option :file_name, :aliases => "-f", :required => true, :desc => "name of file to download"
-        def delete
-          create_s3_object
-          @s3.delete_file options[:bucket_name], options[:file_name]
-        end
-
-        # s3.directories.get('arun123').files.get('block_9091299035346850259').copy('ashrithtst', 'testfile')
-        desc "copy", "copy object from one bucket to another"
-        method_option :source_bucket, :aliases => "-s", :required => true, :desc => "source bucket name from where to copy the file"
-        method_option :source_file, :aliases => "-f", :required => true, :desc => "source file name to copy"
-        method_option :dest_bucket, :aliases => "-d", :required => true, :desc => "destination bucket name to copy the file to"
-        method_option :dest_file, :alises => "-r", :required => true, :desc => "destination file name"
-        def copy
-          create_s3_object
-          @s3.copy_file options[:source_bucket], options[:source_file], options[:dest_bucket], options[:dest_file]
-        end
-
-        desc "public_url", "show the public url of a file"
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "name of the bucket to download the file from"
-        method_option :file_name, :aliases => "-f", :required => true, :desc => "name of file to download"
-        def public_url
-          create_s3_object
-          @s3.get_public_url options[:bucket_name], options[:file_name]
-        end
-
-
-        private
-
-        def create_s3_object
-          puts "S3 Establishing Connetion..."
-          $s3_conn = if parent_options[:region]
-                        Awscli::Connection.new.request_s3(parent_options[:region])
-                      else
-                        Awscli::Connection.new.request_s3
-                      end
-          puts "S3 Establishing Connetion... OK"
-          @s3 = Awscli::S3::Files.new($s3_conn)
-        end
-
-        AwsCli::CLI::S3.register AwsCli::CLI::Sss::Files, :files, 'files [COMMAND]', 'S3 Files Management'
-
-      end
-    end
-  end
-end

data/lib/awscli/connection.rb

@@ -1,55 +0,0 @@
-module Awscli
-  class Connection
-    require 'awscli/errors'
-    require 'awscli/helper'
-
-    def initialize
-      #load env variable AWSCLI_CONFIG_FILE
-      @@aws_config_file = ENV['AWSCLI_CONFIG_FILE']
-      unless !@@aws_config_file.nil?
-        puts "Cannot find config file environment variable"
-        Awscli::Errors.missing_environment_variable
-      end
-      @@aws_config_file_path = File.expand_path(@@aws_config_file)
-      unless File.exist?(@@aws_config_file_path)
-        puts "Cannot locate file #{@@aws_config_file}"
-        Awscli::Errors.missing_config_file
-      end
-      @@config = YAML.load(File.read(@@aws_config_file_path))
-      unless @@config.kind_of?(Hash)
-        puts "Parse Error"
-        Awscli::Errors.missing_credentials
-      end
-    end
-
-    def request_ec2
-      # => returns AWS Compute connection object
-      @@config.merge!(:provider => 'AWS')
-      if @@config['region']
-        Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(@@config['region'])
-      end
-      Fog::Compute.new(@@config)
-    end
-
-    def request_s3 region=nil
-      # => returns S3 connection object
-      @@config.merge!(:provider => 'AWS')
-      if @@config['region']
-        #remove region
-        @@config.reject!{ |k| k == "region" }
-      end
-      #parse optionally passing region
-      if region
-        Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(region)
-        @@config.merge!(:region => region)
-      end
-      Fog::Storage.new(@@config)
-    end
-
-    def request_as
-      # => returns AWS Auto Scaling connection object
-      Fog::AWS::AutoScaling.new(@@config)
-    end
-
-  end
-end

data/lib/awscli/ec2.rb

@@ -1,790 +0,0 @@
-module Awscli
-  module EC2
-
-    class EC2
-
-      # initialize ec2 class object
-      # params:
-      #   connection: Awscli::Connection.new.request_ec2
-      #   extra options hash
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      # list instances from a specified region in a tabular format
-      def list_instances
-        @@conn.servers.table([:id, :dns_name, :flavor_id, :groups, :image_id, :key_name, :private_ip_address,
-          :public_ip_address, :root_device_type, :security_group_ids, :state, :tags])
-      end
-
-      # list available instance types
-      def list_flavors
-        @@conn.flavors.table
-      end
-
-      # describe instance attributes - returns information about an attribute of an instance. You can get information
-      #   only one attribute per call.
-      #   Avaliable attributes to request: instanceType, kernel, ramdisk, userData, disableApiTermination, instanceInitiatedShutdownBehavior,
-      #     rootDeviceName, blockDeviceMapping, sourceDestCheck, groupSet
-      def describe_instance_attribute instance_id, request
-        valid_requests = %w(architecture ami_launch_index availability_zone block_device_mapping network_interfaces client_token
-          dns_name ebs_optimized groups flavor_id iam_instance_profile image_id instance_initiated_shutdown_behavior
-          kernel_id key_name created_at monitoring placement_group platform private_dns_name private_ip_address
-          public_ip_address ramdisk_id root_device_name root_device_type security_group_ids state state_reason subnet_id
-          tenancy tags user_data vpc_id volumes username)
-        #more options
-        #:monitor=, :username=, :private_key=, :private_key_path=, :public_key=, :public_key_path=, :username, :private_key_path, :private_key, :public_key_path, :public_key, :scp, :scp_upload, :scp_download, :ssh, :ssh_port, :sshable?
-        response = @@conn.servers.get(instance_id)
-        abort "Invalid Attribute, available attributes to request: #{valid_requests}" unless valid_requests.include?(request)
-        abort "InstanceId Not found :#{instance_id}, Available instnaces #{@@conn.servers.map { |x| x.id }}" unless response
-        puts "#{request}: #{response.send(request)}"
-      end
-
-      # modifies an attribute of an instance
-      def modify_instance_attribute instance_id, attributename, attributevalue
-        attrs_lookup = {
-          'isize' => 'InstanceType',
-          'kernel' => 'Kernel',
-          'ramdisk' => 'Ramdisk',
-          'userdata' => 'UserData',
-          'disable_api_term' => 'DisableApiTermination',
-          'inst_shutdown_beh' => 'InstanceInitiatedShutdownBehavior',
-          'source_dest_check' => 'SourceDestCheck',
-          'group_id' => 'GroupId'
-        }
-        valid_attributes = %w(InstanceType Kernel Ramdisk UserData DisableApiTermination InstanceInitiatedShutdownBehavior SourceDestCheck GroupId)
-        response = @@conn.servers.get(instance_id)
-        abort "InstanceId Not found :#{instance_id}, Available instnaces #{@@conn.servers.map { |x| x.id }}" unless response
-        abort "Instance should be in stopped state to modify its attributes" if response.state != 'stopped'
-        puts "#{instance_id}, #{attributename}, #{attributevalue}"
-        if attrs_lookup[attributename] == 'GroupId' #handle groupid which is array
-          puts "#{instance_id}, #{attrs_lookup[attributename]} => #{attributevalue}"
-          @@conn.modify_instance_attribute(instance_id, attrs_lookup[attributename] => attributevalue)
-        else
-          puts "#{instance_id}, #{attrs_lookup[attributename]}.Value => #{attributevalue}"
-          @@conn.modify_instance_attribute(instance_id, "#{attrs_lookup[attributename]}.Value" => attributevalue)
-        end
-      end
-
-      # reset instance attribute
-      def reset_instance_attribute instance_id, attribute
-      end
-
-      #create a single instance with options passed
-      def create_instance options
-        #validate required options
-        puts "Validating Options ..."
-        abort "Invalid Key: #{options[:key_name]}" unless @@conn.key_pairs.get(options[:key_name])
-        options[:groups].each do |sg|
-          abort "Invalid Group: #{sg}" unless @@conn.security_groups.get(sg)
-        end
-        abort "Invalid AMI: #{options[:image_id]}" unless @@conn.images.get(options[:image_id])
-        abort "Invalid Instance Flavor: #{options[:flavor_id]}" unless @@conn.flavors.get(options[:flavor_id])
-        #validate optional options
-        if options[:availability_zone]
-          available_zones = @@conn.describe_availability_zones.body['availabilityZoneInfo'].map { |az| az['zoneName'] }
-          abort "Invalid AvailabilityZone: #{options[:availability_zone]}" unless available_zones.include?(options[:availability_zone])
-        end
-        opts = Marshal.load(Marshal.dump(options))
-        wait_for_server = options[:wait_for] && opts.reject! { |k| k == 'wait_for' }
-        puts "Validating Options ... OK"
-        puts "Creating Server"
-        server = @@conn.servers.create(opts)
-        #wait for server to get created and return public_dns
-        if wait_for_server
-          print "Waiting for server to get created "
-          server.wait_for { print "."; ready? }
-          puts
-          puts "Server dns_name: #{server.dns_name}"
-        end
-      end
-
-      # create a new instnace(s)
-      def run_instances options
-      end
-
-      # describe instnace status
-      def describe_instance_status instnace_id
-        response = @@conn.servers.get(instance_id)
-        abort "InstanceId Not found :#{instance_id}" unless response
-        puts "Instance #{instance_id} State: #{response.state}"
-      end
-
-      # import instance as vm
-      def import_instance
-      end
-
-      #@@conn.server.get(instanceid).(:reboot, :save, :setup, :start, :stop)
-      # reboot an instance
-      def reboot_instance instance_id
-        response = @@conn.servers.get(instance_id)
-        abort "InstanceId Not found :#{instance_id}" unless response
-        response.reboot
-        puts "Rebooting Instance: #{instance_id}"
-      end
-
-      # start a stopped instance
-      def stop_instance instance_id
-        response = @@conn.servers.get(instance_id)
-        abort "InstanceId Not found :#{instance_id}" unless response
-        abort "Instance should be in running to stop it" if response.state != 'running'
-        response.stop
-        puts "Stopped Instance: #{instance_id}"
-      end
-
-      # stop a running isntance
-      def start_instance instance_id
-        response = @@conn.servers.get(instance_id)
-        abort "InstanceId Not found :#{instance_id}" unless response
-        abort "Instance should be stopped to start it" if response.state != 'stopped'
-        response.start
-        puts "Starting Instance: #{instance_id}"
-      end
-
-      # terminates an instance
-      def terminate_instance instance_id
-        response = @@conn.servers.get(instance_id)
-        abort "InstanceId Not found :#{instance_id}" unless response
-        response.destroy
-        puts "Terminsted Instance: #{instance_id}"
-      end
-
-      def get_console_output instance_id
-        response = @@conn.get_console_output(instance_id)
-        puts response
-      end
-
-    end # => EC2
-
-    class KeyPairs
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list_keypairs
-        @@conn.key_pairs.table
-      end
-
-      def create_keypair options
-        #validate keypair
-        Fog.credential = 'awscli'
-        abort "KeyPair '#{options[:name]}' already exists" if @@conn.key_pairs.get(options[:name])
-        kp = @@conn.key_pairs.create(options)
-        puts "Created keypair: #{options[:name]}"
-        p kp.write  #save the key to disk
-      end
-
-      def delete_keypair keypair
-        abort "KeyPair '#{keypair}' does not exist" unless @@conn.key_pairs.get(keypair)
-        @@conn.key_pairs.get(keypair).destroy
-        puts "Deleted Keypair: #{keypair}"
-      end
-
-      def fingerprint keypair
-        response = @@conn.key_pairs.get(keypair)
-        abort "Cannot find key pair: #{keypair}" unless response
-        puts "Fingerprint for the key (#{keypair}): #{response.fingerprint}"
-      end
-
-      def import_keypair options
-        #validate if the file exists
-        private_key_path = if options[:private_key_path]
-                            File.expand_path(options[:private_key_path])
-                           else
-                            File.expand_path("~/.ssh/#{options[:name]}")
-                           end
-        public_key_path  = if options[:public_key_path]
-                            File.expand_path(options[:public_key_path])
-                           else
-                            File.expand_path("~/.ssh/#{options[:name]}.pub")
-                           end
-        abort "Cannot find private_key_path: #{private_key_path}" unless File.exist?(private_key_path)
-        abort "Cannot find public_key_path: #{public_key_path}" unless File.exist?(public_key_path)
-        #validate if the key pair name exists
-        Fog.credentials = Fog.credentials.merge({ :private_key_path => private_key_path, :public_key_path => public_key_path })
-        @@conn.import_key_pair(options[:name], IO.read(public_key_path)) if @@conn.key_pairs.get(options[:name]).nil?
-        puts "Imported KeyPair with name: #{options[:name]} sucessfully, using public_key: #{public_key_path} and private_key: #{private_key_path}"
-      end
-    end # => KP
-
-    class SecGroups
-
-      #Limitations: Ec2-Classic: user can have upto 500 groups
-                  # Ec2-VPC: user can have 50 group per VPC
-
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list_secgroups options
-        if options[:show_ip_permissions]
-          # @@conn.security_groups.table([:name, :group_id, :ip_permissions])
-          @@conn.security_groups.each do |sg|
-            id = sg.group_id
-            ip_permissions = sg.ip_permissions.to_yaml
-            Formatador.display_line("[green]#{id}[/]")
-            puts "#{ip_permissions}"
-            puts "================="
-          end
-        else
-          @@conn.security_groups.table([:name, :group_id, :description])
-        end
-      end
-
-      def authorize_securitygroup options
-        # => Ingress regular traffic -> this action applies to both EC2 and VPC Security Groups
-            # Each rule consists of the protocol, plus cidr range or a source group,
-              #for TCP/UDP protocols you must also specify the dest port or port range
-              #for ICMP, you must specify the icmp type and code (-1 means all types/codes)
-        abort "Expecting Security group id(s) of the form: 'sg-xxxxxx'" unless options[:group_id] =~ /sg-\S{8}/
-        abort "Invalid CIDR format" unless options[:cidr] =~ /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])(\/(\d|[1-2]\d|3[0-2]))$/
-        sg = @@conn.security_groups.get_by_id(options[:group_id])
-        abort "Cannot find Security Group with Id: #{sg}" unless sg
-        begin
-          @@conn.authorize_security_group_ingress(
-            "GroupId" => options[:group_id],
-            "IpProtocol" => options[:protocol_type],
-            "FromPort" => options[:start_port],
-            "ToPort" => options[:end_port],
-            "CidrIp" => options[:cidr]
-            )
-          puts "Authorized rule"
-        rescue Fog::Compute::AWS::Error #=> e
-          abort "Error: #{$!}"
-          #puts $@ #backtrace
-        end
-      end
-
-      def revoke_securitygroup options
-        abort "Expecting Security group id(s) of the form: 'sg-xxxxxx'" unless options[:group_id] =~ /sg-\S{8}/
-        sg = @@conn.security_groups.get_by_id(options[:group_id])
-        abort "Cannot find Security Group with Id: #{sg}" unless sg
-        begin
-          response = @@conn.revoke_security_group_ingress(
-            "GroupId" => options[:group_id],
-            "IpProtocol" => options[:protocol_type],
-            "FromPort" => options[:start_port],
-            "ToPort" => options[:end_port],
-            "CidrIp" => options[:cidr]
-            )
-          puts "Revoked rule: #{response.body['return']}"
-        rescue Fog::Compute::AWS::Error #=> e
-          abort "Error: #{$!}"
-        end
-      end
-
-      def create_securitygroup options
-        abort "Error: Security Group => #{options[:name]} already exists" if @@conn.security_groups.get(options[:name])
-        @@conn.security_groups.create(options)
-        puts "Created Security Group: #{options[:name]}"
-      end
-
-      def delete_securitygroup options
-        sg = @@conn.security_groups.get_by_id(options[:group_id])
-        abort "Error: Cannot find Security Group with Id: #{sg}" unless sg
-        begin
-          sg.destroy
-          puts "Deleted Security Group with id: #{options[:group_id]}"
-        rescue Fog::Compute::AWS::Error #=> e
-          abort "Error: #{$!}"
-        end
-      end
-
-    end # => SG
-
-    class Eip
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.addresses.table
-      end
-
-      def create
-        eip = @@conn.addresses.create
-        puts "Created EIP: #{eip.public_ip}"
-      end
-
-      def delete options
-        abort "Invalid IP Format" unless options[:eip] =~ /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
-        eip = @@conn.addresses.get(options[:eip])
-        abort "Cannot find IP: #{options[:eip]}" unless eip
-        eip.destroy
-        puts "Deleted EIP: #{eip.public_ip}"
-      end
-
-      def associate options
-        abort "Invalid IP Format" unless options[:eip] =~ /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
-        eip = @@conn.addresses.get(options[:eip])
-        abort "Cannot find eip: #{options[:eip]}" unless eip
-        server = @@conn.servers.get(options[:instance_id])
-        abort "Cannot find server with id: #{options[:instance_id]}" unless server
-        begin
-          eip.server = server
-          puts "Associated EIP: #{options[:eip]} with Instance: #{options[:instance_id]}"
-        rescue Fog::Compute::AWS::Error
-          abort "Error: #{$!}"
-        end
-      end
-
-      def disassociate options
-        abort "Invalid IP Format" unless options[:eip] =~ /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/
-        abort "Cannot find EIP: #{options[:eip]}" unless @@conn.addresses.get(options[:eip])
-        @@conn.disassociate_address(options[:eip])
-        puts "Disassociated EIP: #{options[:eip]}"
-      end
-    end # => Eip
-
-    class Ami
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list filter
-        puts filter
-        if filter.nil?
-          @@conn.images.all.table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
-        else
-          @@conn.images.all(filter).table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
-        end
-      end
-
-      def show_filters
-        filters =
-          [
-            {:filter_name => "architecture", :desc => "Image Architecture"},
-            {:filter_name => "block-device-mapping.delete-on-termination", :desc => "Whether the Amazon EBS volume is deleted on instance termination"},
-            {:filter_name => "block-device-mapping.device-name", :desc => "Device name (e.g., /dev/sdh) for an Amazon EBS volume mapped to the image"},
-            {:filter_name => "block-device-mapping.snapshot-id", :desc => "Snapshot ID for an Amazon EBS volume mapped to the image"},
-            {:filter_name => "block-device-mapping.volume-size", :desc => "Volume size for an Amazon EBS volume mapped to the image"},
-            {:filter_name => "description", :desc => "Description of the AMI (provided during image creation)"},
-            {:filter_name => "image-id", :desc => "ID of the image" },
-            {:filter_name => "imgae-type", :desc => "Type of image" },
-            {:filter_name => "is-public", :desc => "Whether the image is public" },
-            {:filter_name => "kernel-id", :desc => "Kernel ID" },
-            {:filter_name => "manifest-location", :desc => "Location of the image manifest" },
-            {:filter_name => "name", :desc => "Name of the AMI (provided during image creation)" },
-            {:filter_name => "owner-alias", :desc => "AWS account alias (e.g., amazon or self) or AWS account ID that owns the AMI" },
-            {:filter_name => "owner-id", :desc => "AWS account ID of the image owner" },
-            {:filter_name => "platform", :desc => "Use windows if you have Windows based AMIs; otherwise leave blank" },
-            {:filter_name => "product-code", :desc => "Product code associated with the AMI" },
-            {:filter_name => "ramdisk-id", :desc => "RAM disk ID" },
-            {:filter_name => "root-device-name", :desc => "Root device name of the AMI (e.g., /dev/sda1)" },
-            {:filter_name => "root-device-type", :desc => "Root device type the AMI uses" },
-            {:filter_name => "state", :desc => "State of the image" },
-            {:filter_name => "state-reason-code", :desc => "Reason code for the state change" },
-            {:filter_name => "state-reason-message", :desc => "Message for the state change" },
-            {:filter_name => "tag-key", :desc => "Key of a tag assigned to the resource. This filter is independent of the tag-value filter" },
-            {:filter_name => "tag-value", :desc => "Value of a tag assigned to the resource. This filter is independent of the tag-key filter." },
-            {:filter_name => "virtualization-type", :desc => "Virtualization type of the image" },
-            {:filter_name => "hypervisor", :desc => "Hypervisor type of the image" }
-          ]
-        Formatador.display_table(filters, [:filter_name, :desc])
-      end
-
-      def list_amazon
-        @@conn.images.all('owner-alias' => 'amazon').table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
-      end
-
-      def create_image_from_instance options
-        abort "Invalid Instace: #{options[:instance_id]}" unless @@conn.servers.get(options[:instance_id])
-        @@conn.create_image(
-            options[:instance_id],
-            options[:name],
-            options[:desc],
-            options[:no_reboot]
-          )
-        puts "Created image from instance: #{options[:instance_id]}"
-      end
-
-    end # => AMI
-
-    class Ebs
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list options
-        unless options[:snapshots]
-          @@conn.volumes.table([:availability_zone, :delete_on_termination, :device, :id, :server_id, :size, :snapshot_id, :state, :tags, :type])
-        else
-          @@conn.snapshots.table([:id, :owner_id, :volume_id, :state, :progress, :tags, :description])
-        end
-      end
-
-      def create options
-        @@conn.volumes.create(options)
-      end
-
-      def attach_volume options
-        #The volume and instance must be in the same Availability Zone.
-        volume = @@conn.volumes.get(options[:volume_id])
-        volume.merge_attributes(:device => options[:device])
-        server = @@conn.servers.get(options[:instance_id])
-        abort "Cannot find volume: #{options[:volume_id]}" unless volume
-        abort "Cannot find instance: #{options[:instance_id]}" unless server
-        volume.server = server
-        puts "Attached volume: #{options[:volume_id]} to instance: #{options[:instance_id]}"
-      end
-
-      def detach_volume options
-        #Check if the volume is mounted and show warning regarding data loss
-        volume = @@conn.volumes.get(options[:volume_id])
-        abort "Cannot find volume: #{options[:volume_id]}" unless volume
-        if options[:force]
-          volume.force_detach
-        else
-          @@conn.detach_volume(options[:volume_id])
-        end
-        puts "Detached volume: #{options[:volume_id]}"
-      end
-
-      def delete_volume options
-        vol = @@conn.volumes.get(options[:volume_id])
-        abort "Cannot find volume #{options[:volume_id]}" unless vol
-        vol.destroy
-        puts "Deleted volume: #{options[:volume_id]}"
-      end
-
-      def create_snapshot options
-        abort "Cannot find volume: #{options[:volume_id]}" unless @@conn.volumes.get(options[:volume_id])
-        @@conn.snapshots.create(options)
-        puts "Created snapshot"
-      end
-
-      def copy_snapshot options
-        abort "Cannot find snapshot: #{options[:snapshot_id]}" unless @@conn.snapshots.get(options[:snapshot_id])
-        @@conn.copy_snapshot(options[:snapshot_id], options[:source_region])
-        puts "Copied snapshot"
-      end
-
-      def delete_snapshot options
-        snap = @@conn.snapshots.get(options[:snapshot_id])
-        abort "Cannot find snapshot: #{options[:snapshot_id]}" unless snap
-        snap.destroy
-        puts "Destroyed snapshot"
-      end
-    end # => EBS
-
-    class Monitor
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def monitor options
-        options[:instance_ids].each do |instance|
-          abort "Invalid InstanceId: #{instance}" unless @@conn.servers.get(instance)
-        end
-        @@conn.monitor_instances(options[:instance_ids])
-        puts "Enabled monitoring for instnaces: #{options[:instance_ids].join(",")}"
-      end
-
-      def unmonitor options
-        options[:instance_ids].each do |instance|
-          abort "Invalid InstanceId: #{instance}" unless @@conn.servers.get(instance)
-        end
-        @@conn.unmonitor_instances(options[:instance_ids])
-        puts "Disabled monitoring for instnaces: #{options[:instance_ids].join(",")}"
-      end
-    end # => Monitor
-
-    class Tags
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.tags.table
-      end
-
-      def create options
-        @@conn.tags.create(options)
-        puts "Created Tag"
-      end
-
-      def delete options
-        @@conn.tags.destroy(options)
-        puts "Deleted Tag"
-      end
-    end # => Tags
-
-    class Placement
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.describe_placement_groups
-      end
-
-      def create options
-        @@conn.create_placement_group(options[:name], options[:strategy])
-        puts "Created a new placement group: #{options[:name]}"
-      end
-
-      def delete options
-        @@conn.delete_placement_group(options[:name])
-        puts "Deleted placement group: #{options[:name]}"
-      end
-    end # => Placement
-
-    class ReservedInstances
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list filters
-        puts filters
-        if filters.nil?
-          @@conn.describe_reserved_instances.body['reservedInstancesSet']
-        else
-          @@conn.describe_reserved_instances(filters).body['reservedInstancesSet']
-        end
-      end
-
-      def list_offerings filters
-        puts filters
-        response =  if filters.nil?
-                      @@conn.describe_reserved_instances_offerings.body['reservedInstancesOfferingsSet']
-                    else
-                      @@conn.describe_reserved_instances_offerings(filters).body['reservedInstancesOfferingsSet']
-                    end
-        Formatador.display_table(response)
-      end
-
-      def list_filters
-        filters = [
-          {:filter_name => "availability-zone", :desc => "Availability Zone where the Reserved Instance can be used", :availability => "Both"},
-          {:filter_name => "duration", :desc => "Duration of the Reserved Instance (e.g., one year or three years), in seconds", :availability => "Both"},
-          {:filter_name => "fixed-price", :desc => "Purchase price of the Reserved Instance", :availability => "Both"},
-          {:filter_name => "instance-type", :desc => "Instance type on which the Reserved Instance can be used", :availability => "Both"},
-          {:filter_name => "product-description", :desc => "Reserved Instance description", :availability => "Both"},
-          {:filter_name => "reserved-instances-id", :desc => "Reserved Instance's ID", :availability => "Only ReservedInstances"},
-          {:filter_name => "reserved-instances-offering-id", :desc => "Reserved Instances offering ID", :availability => "Only reservedInstancesOfferingsSet"},
-          {:filter_name => "start", :desc => "Time the Reserved Instance purchase request was placed", :availability => "Only ReservedInstances"},
-          {:filter_name => "state", :desc => "State of the Reserved Instance", :availability => "Only ReservedInstances"},
-          {:filter_name => "tag-key", :desc => "Key of a tag assigned to the resource", :availability => "Only ReservedInstances"}, #This filter is independent of the tag-value filter. For example, if you use both the filter tag-key=Purpose and the filter tag-value=X, you get any resources assigned both the tag key Purpose and the tag value X
-          {:filter_name => "tag-value", :desc => "Value of a tag assigned to the resource", :availability => "Only ReservedInstances"}, #This filter is independent of the tag-key filter.
-          {:filter_name => "usage-price", :desc => "Usage price of the Reserved Instance, per hour", :availability => "Both"},
-        ]
-        Formatador.display_table(filters, [:filter_name, :desc, :availability])
-      end
-
-      def purchase options
-        @@conn.purchase_reserved_instances_offering(options[:reserved_instances_offering_id], options[:instance_count])
-      end
-    end # => ReservedInstances
-
-    class Spot
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def describe_spot_requests
-        @@conn.spot_requests.table
-      end
-
-      def describe_spot_datafeed_subscription
-        @@conn.describe_spot_datafeed_subscription
-      end
-
-      def describe_spot_price_history filters
-        puts filters
-        response =  if filters.nil?
-                      @@conn.describe_spot_price_history.body['spotPriceHistorySet']
-                    else
-                      @@conn.describe_spot_price_history(filters).body['spotPriceHistorySet']
-                    end
-        Formatador.display_table(response)
-      end
-
-      def list_filters
-        filters = [
-          {:filter_name => "instance-type", :desc => "Type of instance"},
-          {:filter_name => "product-description", :desc => "Product description for the Spot Price"},
-          {:filter_name => "spot-price", :desc => "Spot Price. The value must match exactly (or use wildcards; greater than or less than comparison is not supported)"},
-          {:filter_name => "timestamp", :desc => "Timestamp of the Spot Price history, e.g., 2010-08-16T05:06:11.000Z. You can use wildcards (* and ?)"},
-        ]
-        Formatador.display_table(filters, [:filter_name, :desc])
-      end
-
-      def create_spot_datafeed_subsription bucket, prefix
-        @@conn.create_spot_datafeed_subscription(bucket, prefix)
-      end
-
-      def delete_spot_datafeed_subsription
-        @@conn.delete_spot_datafeed_subscription
-      end
-
-      def request_spot_instances options
-        sr = @@conn.spot_requests.create(options)
-        puts "Created spot request: #{sr.id}"
-      end
-
-      def cancel_spot_instance_requests sid
-        sr = @@conn.spot_requests.get(sid)
-        abort "Cannot find spot request with id: #{sid}" unless sr
-        sr.destroy
-        puts "Deleted spot request: #{sid}"
-      end
-    end # => Spot
-
-    class Vpc
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.vpcs.table
-      end
-
-      def create options
-        vpc = @@conn.vpcs.create(options)
-        puts "Created VPC: #{vpc.id}"
-      end
-
-      def delete vpc_id
-        vpc = @@conn.vpcs.get(vpc_id)
-        abort "cannot find vpc: #{vpc_id}" unless vpc
-        vpc.destroy
-        puts "Deleted VPC : #{vpc_id}"
-      end
-    end # => Vpc
-
-    class Subnet
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.subnets.table
-      end
-
-      def create options
-        subnet = @@conn.subnets.create(options)
-        puts "Created Subnet: #{subnet.id}"
-      end
-
-      def delete subnet_id
-        subnet = @@conn.subnets.get(subnet_id)
-        abort "Cannot find subnet: #{subnet_id}" unless subnet
-        subnet.destroy
-        puts "Deleted subnet: #{subnet_id}"
-      end
-    end # => Subnet
-
-    class NetworkAcl
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        puts "Listing Network Acls"
-      end
-
-    end # => NetworkAcl
-
-    class NetworkInterfaces
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.network_interfaces.table
-      end
-
-      def create options
-        nic = @@conn.network_interfaces.create(options)
-        puts "Create network interface #{nic.network_interface_id}"
-      end
-
-      def delete nic_id
-        nic = @@conn.network_interfaces.get(nic_id)
-        abort "Cannot find nic with id: #{nic_id}" unless nic
-        nic.destroy
-        puts "Deleted network interface #{nic_id}"
-      end
-
-      def attach nic_id, instance_id, device_index
-        @@conn.attach_network_interface(nic_id, instance_id, device_index)
-        puts "Attached Network Interface: #{nic_id} to instance: #{instance_id}"
-      end
-
-      def deattach attachement_id, force
-        @@conn.detach_network_interface attachement_id, force
-        puts "Deattached Network Interface with attachement_id: #{attachement_id}"
-      end
-
-      def modify_attribute options
-        case options[:attribute]
-        when 'description'
-          @@conn.modify_network_interface_attribute(options[:network_interface_id], 'description', options[:description])
-        when 'groupSet'
-          @@conn.modify_network_interface_attribute(options[:network_interface_id], 'groupSet', options[:group_set])
-        when 'sourceDestCheck'
-          @@conn.modify_network_interface_attribute(options[:network_interface_id], 'sourceDestCheck', options[:source_dest_check])
-        when 'attachment'
-          @@conn.modify_network_interface_attribute(options[:network_interface_id], 'attachment', options[:attachment])
-        else
-          abort "Invalid attribute: #{options[:attribute]}"
-        end
-      end
-    end # => NetworkInterfaces
-
-    class InternetGateways
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.internet_gateways.table
-      end
-
-      def create
-        gw = @@conn.internet_gateways.create
-        puts "Created Internet Gateway: #{gw.id}"
-      end
-
-      def delete gwid
-        gw = @@conn.internet_gateways.get(gwid)
-        gw.destroy
-        puts "Deleted Internet Gateway: #{gwid}"
-      end
-
-      def attach gwid, vpcid
-        @@conn.internet_gateways.attach(gwid, vpcid)
-        puts "Attached InternetGateway: #{gwid} to VPC: #{vpcid}"
-      end
-
-      def deattach gwid, vpcid
-        @@conn.internet_gateways.deattach(gwid, vpcid)
-        puts "Deattached InternetGateway: #{gwid} from VPC: #{vpcid}"
-      end
-    end # => InternetGateways
-
-    class Dhcp
-      def initialize connection, options = {}
-        @@conn = connection
-      end
-
-      def list
-        @@conn.dhcp_options.table
-      end
-
-      def create options
-        @@conn.dhcp_options.create(options)
-      end
-
-      def delete dhcp_id
-        dhcp = @@conn.dhcp_options(dhcp_id)
-        dhcp.destroy
-      end
-
-      def associate dhcp_ic, vpc_id
-        @@conn.dhcp_options.attach(dhcp_id, vpc_id)
-      end
-    end # => Dhcp
-
-  end
-end