awscli 0.1.2 → 0.1.3

data/lib/awscli/cli/iam/user.rb

@@ -18,22 +18,29 @@ module AwsCli
 
         desc 'create', 'create a user'
         long_desc <<-DESC
-        Creates a new user in your AWS account. Optionally adds the user to one or more groups, and creates an access key for the user.
+        Creates a new user in your AWS account. Optionally adds the user to a group, creates an access key for the user and puts default policy in place.
         DESC
         method_option :user_name, :aliases => '-u', :required => true, :desc => 'name of the user to create (do not include path)'
-        method_option :path, :aliases => '-p', :defualt => '/', :desc => 'optional path to group, defaults to "/"'
+        method_option :path, :aliases => '-p', :default => '/', :desc => 'optional path to group, defaults to "/"'
         method_option :group, :aliases => '-g', :desc => 'name of a group you want to add the user to'
-        method_option :access_key, :alises => '-k', :desc => 'creates an access key for the user'
+        method_option :access_key, :aliases => '-k', :type => :boolean, :default => false, :desc => 'if passed, optionally creates an access key for the user'
+        method_option :policy, :aliases => '-l', :type => :boolean, :default => false, :desc => 'if set will not create basic set of access rules for the user, should pass --policy-doc if set'
+        method_option :policy_doc, :aliases => '-d', :desc => 'path to the json policy document'
+        method_option :password, :aliases => '-a', :type => :boolean, :default => false, :desc => 'assign a generated password for the user'
         def create
+          if options[:policy]
+            abort 'Required --policy-doc, if --policy is passed' unless options[:policy_doc]
+          end
           create_iam_object
-          @iam.create options[:user_name], options[:path]
+          @iam.create options
         end
 
         desc 'delete', 'delete existing user'
         method_option :user_name, :aliases => '-u', :required => true, :desc => 'name of the user to delete (dont include path)'
+        method_option :force, :aliases => '-f', :type => :boolean, :default => false, :decs => 'force deletes users login_profile, access_keys, policies if any'
         def delete
           create_iam_object
-          @iam.delete options[:user_name]
+          @iam.delete options
         end
 
         desc 'cak', 'create access key for user'
@@ -100,14 +107,18 @@ module AwsCli
         desc 'passwd [OPTIONS]', 'add/change user password'
         method_option :user_name, :aliases => '-u', :required => true, :desc => 'name of the user to change password for'
         method_option :password, :alases => '-p', :desc => 'password for the user'
-        method_option :genereate, :aliases => '-g', :type => :boolean, :default => false, :desc => 'generates the password'
+        method_option :generate, :aliases => '-g', :type => :boolean, :default => false, :desc => 'generates the password'
         method_option :remove, :aliases => '-r', :type => :boolean, :default => false, :desc => 'remove password for the user'
         def passwd
           create_iam_object
           if options[:remove]
             @iam.remove_password options[:user_name]
           else
-            @iam.assign_password options[:user_name], options[:password], options[:genereate]
+            if options[:generate]
+              @iam.assign_password options[:user_name], options[:password]
+            else
+              @iam.generate_password options[:user_name]
+            end
           end
         end
 

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

@@ -4,76 +4,82 @@ module AwsCli
       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"
+        desc 'list', 'list objects(files) in a bucket'
+        method_option :bucket_name, :aliases => '-b', :required => true, :desc => 'bucket name to print the contents from'
+        method_option :prefix, :aliases => '-p', :desc => 'Optionally specify a dir_name to narrow down results'
         def list
           create_s3_object
-          @s3.list options[:bucket_name]
+          @s3.list options[:bucket_name], options[:prefix]
         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"
+        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'
+        method_option :dest_path, :aliases => '-d', :desc => 'optionally specify destination directory path to create'
         def put
           create_s3_object
-          @s3.upload_file options[:bucket_name], options[:file_path]
+          if options[:dest_path]
+            @s3.upload_file options[:bucket_name], options[:file_path], options[:dest_path]
+          else
+            @s3.upload_file options[:bucket_name], options[:file_path]
+          end
         end
 
-        desc "put_rec", "put a directory recusively into a specified bucket using multiple threads"
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "name of the bucket to upload the dir to"
-        method_option :dir_path, :aliases => "-p", :required => true, :desc => "path of the dir to upload"
-        method_option :dest_path, :aliases => "-d", :desc => "optionally specify destination directory path to create"
-        method_option :thread_count, :aliases => "-t", :type => :numeric, :default => 5, :desc => "number of threads to use to upload files"
-        method_option :public, :type => :boolean, :default => false, :desc => "set ACL of files to public"
+        desc 'put_rec', 'put a directory recursively into a specified bucket using multiple threads'
+        method_option :bucket_name, :aliases => '-b', :required => true, :desc => 'name of the bucket to upload the dir to'
+        method_option :dir_path, :aliases => '-p', :required => true, :desc => 'path of the dir to upload'
+        method_option :dest_path, :aliases => '-d', :desc => 'optionally specify destination directory path to create'
+        method_option :thread_count, :aliases => '-t', :type => :numeric, :default => 5, :desc => 'number of threads to use to upload files'
+        method_option :public, :type => :boolean, :default => false, :desc => 'set ACL of files to public'
         def put_rec
           create_s3_object
           @s3.upload_file_rec options
         end
 
-        desc "put_big", "uploads a larger file (> 100 MB) using multipart uploads"
+        desc 'put_big', 'uploads a file using multipart uploads'
         long_desc <<-DESC
-        Takes in a larger file, split the file into chunks and uploads the parts using amazon multipart uploads and the parts are aggregated at the amazons end.
+        Takes in a larger file (> 100MB), split the file into chunks and uploads the parts using amazon multipart uploads and the parts are aggregated at the amazons end.
         DESC
-        method_option :bucket_name, :aliases => "-b", :required => true, :desc => "name of the bucket to upload the parts to"
-        method_option :file_path, :aliases => "-p", :required => true, :desc => "path of the file to upload"
-        method_option :tmp_dir, :aliases => "-t", :default => "/tmp", :desc => "path to a temperory location where file will be split into chunks"
-        method_option :acl, :aliases => "-a", :default => "private", :desc => "ACL to apply, to the object that is created after completing multipart upload, valid options in private | public-read | public-read-write | authenticated-read | bucket-owner-read | bucket-owner-full-control"
-        method_option :dest_path, :aliases => "-d", :desc => "optionally specify destination directory path to create"
+        method_option :bucket_name, :aliases => '-b', :required => true, :banner => 'NAME', :desc => 'name of the bucket to upload the parts to'
+        method_option :file_path, :aliases => '-p', :required => true, :banner => 'PATH', :desc => 'path of the file to upload'
+        method_option :tmp_dir, :aliases => '-t', :default => '/tmp', :desc => 'path to a temporary location where file will be split into chunks'
+        method_option :acl, :aliases => '-a', :default => 'private', :desc => 'ACL to apply, to the object that is created after completing multipart upload, valid options in private | public-read | public-read-write | authenticated-read | bucket-owner-read | bucket-owner-full-control'
+        method_option :dest_path, :aliases => '-d', :desc => 'optionally specify destination directory path to create'
         def put_big
           create_s3_object
           @s3.multipart_upload options
         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"
+        desc 'get', 'get a file from a bucket'
+        method_option :bucket_name, :aliases => '-b', :required => true, :banner => 'NAME', :desc => 'name of the bucket to download the file from'
+        method_option :file_name, :aliases => '-f', :required => true, :banner => 'NAME', :desc => 'name of file to download'
+        method_option :local_path, :aliases => '-p', :required => true, :banner => 'PATH', :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"
+        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
 
-        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"
+        desc 'copy', 'copy object from one bucket to another'
+        method_option :source_bucket, :aliases => '-s', :required => true, :banner => 'NAME', :desc => 'source bucket name from where to copy the file'
+        method_option :source_file, :aliases => '-f', :required => true, :banner => 'PATH', :desc => 'source file name to copy'
+        method_option :dest_bucket, :aliases => '-d', :required => true, :banner => 'NAME', :desc => 'destination bucket name to copy the file to'
+        method_option :dest_file, :aliases => '-r', :required => true, :banner => 'PATH', :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"
+        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]
@@ -83,13 +89,13 @@ module AwsCli
         private
 
         def create_s3_object
-          puts "S3 Establishing Connetion..."
+          puts 'S3 Establishing Connection...'
           $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"
+          puts 'S3 Establishing Connection... OK'
           @s3 = Awscli::S3::Files.new($s3_conn)
         end
 

data/lib/awscli/connection.rb

@@ -5,67 +5,70 @@ module Awscli
 
     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"
+      @aws_config_file = ENV['AWSCLI_CONFIG_FILE']
+      if @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}"
+      @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"
+      @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 region=nil
+    def request_ec2(region=nil)
       # => returns AWS Compute connection object
-      @@config.merge!(:provider => 'AWS')
+      @config.merge!(:provider => 'AWS')
       if region
         #if user passes a region optionally
         Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(region)
-        @@config.reject!{ |k| k == 'region' } if @@config['region']
-        @@config.merge!(:region => region)
+        @config.reject!{ |key| key == 'region' } if @config['region']
+        @config.merge!(:region => region)
       else
-        if @@config['region']
-          Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(@@config['region'])
-        end
+        Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(@config['region']) if @config['region']
       end
-      Fog::Compute.new(@@config)
+      Fog::Compute.new(@config)
     end
 
-    def request_s3 region=nil
+    def request_s3(region=nil)
       # => returns S3 connection object
-      @@config.merge!(:provider => 'AWS')
-      if @@config['region']
-        #remove region
-        @@config.reject!{ |k| k == "region" }
-      end
+      @config.merge!(:provider => 'AWS')
+      @config.reject!{ |key| key == 'region' } if @config['region']
       #parse optionally passing region
       if region
         Awscli::Errors.invalid_region unless Awscli::Instances::REGIONS.include?(region)
-        @@config.merge!(:region => region)
+        @config.merge!(:region => region)
       end
-      Fog::Storage.new(@@config)
+      Fog::Storage.new(@config)
     end
 
     def request_as
       # => returns AWS Auto Scaling connection object
-      #remove region if passed from config
-      Fog::AWS::AutoScaling.new(@@config)
+      Fog::AWS::AutoScaling.new(@config)
     end
 
     def request_iam
       # => returns AWS IAM object
-      if @@config['region']
-        #remove region
-        @@config.reject!{ |k| k == "region" }
+      @config.reject!{ |key| key == 'region' } if @config['region']
+      Fog::AWS::IAM.new(@config)
+    end
+
+    def request_emr(region=nil)
+      # => returns AWS EMR 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::IAM.new(@@config)
+      Fog::AWS::EMR.new(@config)
     end
 
   end

data/lib/awscli/ec2.rb

@@ -7,26 +7,26 @@ module Awscli
       # params:
       #   connection: Awscli::Connection.new.request_ec2
       #   extra options hash
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @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,
+        @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
+        @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,
+      #   Available attributes to request: instanceType, kernel, ramdisk, userData, disableApiTermination, instanceInitiatedShutdownBehavior,
       #     rootDeviceName, blockDeviceMapping, sourceDestCheck, groupSet
-      def describe_instance_attribute instance_id, request
+      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
@@ -34,14 +34,14 @@ module Awscli
           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)
+        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
+        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
+      def modify_instance_attribute(instance_id, attributename, attributevalue)
         attrs_lookup = {
           'isize' => 'InstanceType',
           'kernel' => 'Kernel',
@@ -53,36 +53,36 @@ module Awscli
           '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
+        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)
+          @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)
+          @conn.modify_instance_attribute(instance_id, "#{attrs_lookup[attributename]}.Value" => attributevalue)
         end
       end
 
       # reset instance attribute
-      def reset_instance_attribute instance_id, attribute
-      end
+      #def reset_instance_attribute(instance_id, attribute)
+      #end
 
       #create a single instance with options passed
-      def create_instance options
+      def create_instance(options)
         #validate required options
-        puts "Validating Options ..."
-        abort "Invalid Key: #{options[:key_name]}" unless @@conn.key_pairs.get(options[:key_name])
+        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)
+          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])
+        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'] }
+          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))
@@ -109,7 +109,7 @@ module Awscli
               mapping['Ebs.VolumeSize'] = volume_size if !volume_size.nil? && !volume_size.empty?
               mapping['Ebs.DeleteOnTermination'] = delete_on_termination if !delete_on_termination.nil? && !delete_on_termination.empty?
             else
-              abort "Cannot validate block_device"
+              abort 'Cannot validate block_device'
             end
             block_device_mapping << mapping
           end
@@ -118,110 +118,110 @@ module Awscli
           opts.merge!(:block_device_mapping => block_device_mapping)
         end
         wait_for_server = options[:wait_for] && opts.reject! { |k| k == 'wait_for' }
-        puts "Validating Options ... OK"
-        puts "Creating Server"
-        server = @@conn.servers.create(opts)
+        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 "
+          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
+      ## create a new instance(s)
+      #def run_instances options
+      #end
 
-      # describe instnace status
-      def describe_instance_status instnace_id
-        response = @@conn.servers.get(instance_id)
+      # describe instance 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
+      ## import instance as vm
+      #def import_instance
+      #end
 
-      #@@conn.server.get(instanceid).(:reboot, :save, :setup, :start, :stop)
+      #@conn.server.get(instanceid).(:reboot, :save, :setup, :start, :stop)
       # reboot an instance
-      def reboot_instance instance_id
-        response = @@conn.servers.get(instance_id)
+      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)
+      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'
+        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)
+      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'
+        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)
+      def terminate_instance(instance_id)
+        response = @conn.servers.get(instance_id)
         abort "InstanceId Not found :#{instance_id}" unless response
         unless response.state == 'terminated'
           response.destroy
           puts "Terminated Instance: #{instance_id}"
         else
-          puts "Instance is already in terminated state"
+          puts 'Instance is already in terminated state'
         end
       end
 
-      def get_console_output instance_id
-        response = @@conn.get_console_output(instance_id)
+      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
+      def initialize(connection)
+        @conn = connection
       end
 
       def list_keypairs
-        @@conn.key_pairs.table
+        @conn.key_pairs.table
       end
 
-      def create_keypair options
+      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)
+        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
+      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)
+      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
+      def import_keypair(options)
         #validate if the file exists
         private_key_path = if options[:private_key_path]
                             File.expand_path(options[:private_key_path])
@@ -237,7 +237,7 @@ module Awscli
         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?
+        @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
@@ -247,36 +247,36 @@ module Awscli
       #Limitations: Ec2-Classic: user can have upto 500 groups
                   # Ec2-VPC: user can have 50 group per VPC
 
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
-      def list_secgroups options
+      def list_secgroups(options)
         if options[:show_ip_permissions]
-          # @@conn.security_groups.table([:name, :group_id, :ip_permissions])
-          @@conn.security_groups.each do |sg|
+          # @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 "================="
+            puts '================='
           end
         else
-          @@conn.security_groups.table([:name, :group_id, :description])
+          @conn.security_groups.table([:name, :group_id, :description])
         end
       end
 
-      def authorize_securitygroup options
+      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])
+        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(
+          @conn.authorize_security_group_ingress(
             "GroupId" => options[:group_id],
             "IpProtocol" => options[:protocol_type],
             "FromPort" => options[:start_port],
@@ -290,12 +290,12 @@ module Awscli
         end
       end
 
-      def revoke_securitygroup options
+      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])
+        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(
+          response = @conn.revoke_security_group_ingress(
             "GroupId" => options[:group_id],
             "IpProtocol" => options[:protocol_type],
             "FromPort" => options[:start_port],
@@ -308,14 +308,14 @@ module Awscli
         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)
+      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])
+      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
@@ -328,32 +328,32 @@ module Awscli
     end # => SG
 
     class Eip
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.addresses.table
+        @conn.addresses.table
       end
 
       def create
-        eip = @@conn.addresses.create
+        eip = @conn.addresses.create
         puts "Created EIP: #{eip.public_ip}"
       end
 
-      def delete options
+      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])
+        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
+      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])
+        eip = @conn.addresses.get(options[:eip])
         abort "Cannot find eip: #{options[:eip]}" unless eip
-        server = @@conn.servers.get(options[:instance_id])
+        server = @conn.servers.get(options[:instance_id])
         abort "Cannot find server with id: #{options[:instance_id]}" unless server
         begin
           eip.server = server
@@ -363,25 +363,25 @@ module Awscli
         end
       end
 
-      def disassociate options
+      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])
+        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
+      def initialize(connection)
+        @conn = connection
       end
 
-      def list filter
+      def list(filter)
         puts filter
         if filter.nil?
-          @@conn.images.all.table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
+          @conn.images.all.table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
         else
-          data = @@conn.images.all(filter)
+          data = @conn.images.all(filter)
           data.empty? ? puts("No AMI's found for provided filters") : data.table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
         end
       end
@@ -420,17 +420,17 @@ module Awscli
       end
 
       def list_amazon
-        @@conn.images.all('owner-alias' => 'amazon').table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
+        @conn.images.all('owner-alias' => 'amazon').table([:architecture, :id, :is_public, :platform, :root_device_type, :state])
       end
 
       def list_self
-        response = @@conn.describe_images({'Owner' => 'self'}).body['imagesSet']
+        response = @conn.describe_images({'Owner' => 'self'}).body['imagesSet']
         Formatador.display_table(response, ['architecture', 'imageId', 'isPublic', 'name', 'imageState', 'rootDeviceType', 'imageType'])
       end
 
-      def create_image_from_instance options
-        abort "Invalid Instace: #{options[:instance_id]}" unless @@conn.servers.get(options[:instance_id])
-        @@conn.create_image(
+      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],
@@ -439,67 +439,67 @@ module Awscli
         puts "Created image from instance: #{options[:instance_id]}"
       end
 
-      def deregister image_id
-        image = @@conn.images.get(image_id)
+      def deregister(image_id)
+        image = @conn.images.get(image_id)
         abort "Cannot find image with id: #{image_id}" unless image
-        @@conn.deregister_image(image_id)
+        @conn.deregister_image(image_id)
         say "De-registerd image: <%= color('#{image_id}', :green) %>"
       end
 
     end # => AMI
 
     class Ebs
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
-      def list options
+      def list(options)
         unless options[:snapshots]
-          @@conn.volumes.table([:availability_zone, :delete_on_termination, :device, :id, :server_id, :size, :snapshot_id, :state, :tags, :type])
+          @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])
+          @conn.snapshots.table([:id, :owner_id, :volume_id, :state, :progress, :tags, :description])
         end
       end
 
-      def create options
-        @@conn.volumes.create(options)
+      def create(options)
+        @conn.volumes.create(options)
       end
 
-      def attach_volume options
+      def attach_volume(options)
         #The volume and instance must be in the same Availability Zone.
-        volume = @@conn.volumes.get(options[:volume_id])
+        volume = @conn.volumes.get(options[:volume_id])
         volume.merge_attributes(:device => options[:device])
-        server = @@conn.servers.get(options[:instance_id])
+        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
+      def detach_volume(options)
         #Check if the volume is mounted and show warning regarding data loss
-        volume = @@conn.volumes.get(options[:volume_id])
+        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])
+          @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])
+      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 delete_detached
-        vols  = @@conn.volumes.all('status' => 'available')
+        vols  = @conn.volumes.all('status' => 'available')
         unless vols.empty?
-          if agree("Are you sure want to delete all the all volumes that are not in use ?  ")
-            puts "Deleting all volumes which are not in use ..."
+          if agree('Are you sure want to delete all the all volumes that are not in use ?  ')
+            puts 'Deleting all volumes which are not in use ...'
             vols.each do |vol|
               vol.destroy
             end
@@ -509,20 +509,20 @@ module Awscli
         end
       end
 
-      def create_snapshot options
-        abort "Cannot find volume: #{options[:volume_id]}" unless @@conn.volumes.get(options[:volume_id])
-        @@conn.snapshots.create(options)
+      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])
+      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])
+      def delete_snapshot(options)
+        snap = @conn.snapshots.get(options[:snapshot_id])
         abort "Cannot find snapshot: #{options[:snapshot_id]}" unless snap
         snap.destroy
         puts "Deleted snapshot"
@@ -530,87 +530,87 @@ module Awscli
     end # => EBS
 
     class Monitor
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
-      def monitor options
+      def monitor(options)
         options[:instance_ids].each do |instance|
-          abort "Invalid InstanceId: #{instance}" unless @@conn.servers.get(instance)
+          abort "Invalid InstanceId: #{instance}" unless @conn.servers.get(instance)
         end
-        @@conn.monitor_instances(options[:instance_ids])
+        @conn.monitor_instances(options[:instance_ids])
         puts "Enabled monitoring for instnaces: #{options[:instance_ids].join(",")}"
       end
 
-      def unmonitor options
+      def unmonitor(options)
         options[:instance_ids].each do |instance|
-          abort "Invalid InstanceId: #{instance}" unless @@conn.servers.get(instance)
+          abort "Invalid InstanceId: #{instance}" unless @conn.servers.get(instance)
         end
-        @@conn.unmonitor_instances(options[:instance_ids])
+        @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
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.tags.table
+        @conn.tags.table
       end
 
-      def create options
-        @@conn.tags.create(options)
-        puts "Created Tag"
+      def create(options)
+        @conn.tags.create(options)
+        puts 'Created Tag'
       end
 
-      def delete options
-        @@conn.tags.destroy(options)
-        puts "Deleted Tag"
+      def delete(options)
+        @conn.tags.destroy(options)
+        puts 'Deleted Tag'
       end
     end # => Tags
 
     class Placement
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.describe_placement_groups
+        @conn.describe_placement_groups
       end
 
-      def create options
-        @@conn.create_placement_group(options[:name], options[:strategy])
+      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])
+      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
+      def initialize(connection)
+        @conn = connection
       end
 
-      def list filters
+      def list(filters)
         puts filters
         if filters.nil?
-          @@conn.describe_reserved_instances.body['reservedInstancesSet']
+          @conn.describe_reserved_instances.body['reservedInstancesSet']
         else
-          @@conn.describe_reserved_instances(filters).body['reservedInstancesSet']
+          @conn.describe_reserved_instances(filters).body['reservedInstancesSet']
         end
       end
 
-      def list_offerings filters
+      def list_offerings(filters)
         puts filters
         response =  if filters.nil?
-                      @@conn.describe_reserved_instances_offerings.body['reservedInstancesOfferingsSet']
+                      @conn.describe_reserved_instances_offerings.body['reservedInstancesOfferingsSet']
                     else
-                      @@conn.describe_reserved_instances_offerings(filters).body['reservedInstancesOfferingsSet']
+                      @conn.describe_reserved_instances_offerings(filters).body['reservedInstancesOfferingsSet']
                     end
         Formatador.display_table(response)
       end
@@ -633,30 +633,30 @@ module Awscli
         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])
+      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
+      def initialize(connection)
+        @conn = connection
       end
 
       def describe_spot_requests
-        @@conn.spot_requests.table
+        @conn.spot_requests.table
       end
 
       def describe_spot_datafeed_subscription
-        @@conn.describe_spot_datafeed_subscription
+        @conn.describe_spot_datafeed_subscription
       end
 
-      def describe_spot_price_history filters
+      def describe_spot_price_history(filters)
         puts filters
         response =  if filters.nil?
-                      @@conn.describe_spot_price_history.body['spotPriceHistorySet']
+                      @conn.describe_spot_price_history.body['spotPriceHistorySet']
                     else
-                      @@conn.describe_spot_price_history(filters).body['spotPriceHistorySet']
+                      @conn.describe_spot_price_history(filters).body['spotPriceHistorySet']
                     end
         Formatador.display_table(response)
       end
@@ -671,21 +671,21 @@ module Awscli
         Formatador.display_table(filters, [:filter_name, :desc])
       end
 
-      def create_spot_datafeed_subsription bucket, prefix
-        @@conn.create_spot_datafeed_subscription(bucket, prefix)
+      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
+        @conn.delete_spot_datafeed_subscription
       end
 
-      def request_spot_instances options
-        sr = @@conn.spot_requests.create(options)
+      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)
+      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}"
@@ -693,21 +693,21 @@ module Awscli
     end # => Spot
 
     class Vpc
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.vpcs.table
+        @conn.vpcs.table
       end
 
-      def create options
-        vpc = @@conn.vpcs.create(options)
+      def create(options)
+        vpc = @conn.vpcs.create(options)
         puts "Created VPC: #{vpc.id}"
       end
 
-      def delete vpc_id
-        vpc = @@conn.vpcs.get(vpc_id)
+      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}"
@@ -715,21 +715,21 @@ module Awscli
     end # => Vpc
 
     class Subnet
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.subnets.table
+        @conn.subnets.table
       end
 
-      def create options
-        subnet = @@conn.subnets.create(options)
+      def create(options)
+        subnet = @conn.subnets.create(options)
         puts "Created Subnet: #{subnet.id}"
       end
 
-      def delete subnet_id
-        subnet = @@conn.subnets.get(subnet_id)
+      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}"
@@ -737,57 +737,57 @@ module Awscli
     end # => Subnet
 
     class NetworkAcl
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        puts "Listing Network Acls"
+        puts 'Listing Network Acls'
       end
 
     end # => NetworkAcl
 
     class NetworkInterfaces
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.network_interfaces.table
+        @conn.network_interfaces.table
       end
 
-      def create options
-        nic = @@conn.network_interfaces.create(options)
+      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)
+      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)
+      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}"
+      def deattach(attachement_id, force)
+        @conn.detach_network_interface attachement_id, force
+        puts "Detached Network Interface with attachement_id: #{attachement_id}"
       end
 
-      def modify_attribute options
+      def modify_attribute(options)
         case options[:attribute]
         when 'description'
-          @@conn.modify_network_interface_attribute(options[:network_interface_id], 'description', options[: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])
+          @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])
+          @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])
+          @conn.modify_network_interface_attribute(options[:network_interface_id], 'attachment', options[:attachment])
         else
           abort "Invalid attribute: #{options[:attribute]}"
         end
@@ -795,56 +795,56 @@ module Awscli
     end # => NetworkInterfaces
 
     class InternetGateways
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.internet_gateways.table
+        @conn.internet_gateways.table
       end
 
       def create
-        gw = @@conn.internet_gateways.create
+        gw = @conn.internet_gateways.create
         puts "Created Internet Gateway: #{gw.id}"
       end
 
-      def delete gwid
-        gw = @@conn.internet_gateways.get(gwid)
+      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)
+      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}"
+      def deattach(gwid, vpcid)
+        @conn.internet_gateways.deattach(gwid, vpcid)
+        puts "Detached InternetGateway: #{gwid} from VPC: #{vpcid}"
       end
     end # => InternetGateways
 
     class Dhcp
-      def initialize connection, options = {}
-        @@conn = connection
+      def initialize(connection)
+        @conn = connection
       end
 
       def list
-        @@conn.dhcp_options.table
+        @conn.dhcp_options.table
       end
 
-      def create options
-        @@conn.dhcp_options.create(options)
+      def create(options)
+        @conn.dhcp_options.create(options)
       end
 
-      def delete dhcp_id
-        dhcp = @@conn.dhcp_options(dhcp_id)
+      def delete(dhcp_id)
+        dhcp = @conn.dhcp_options(dhcp_id)
         dhcp.destroy
       end
 
-      def associate dhcp_id, vpc_id
-        @@conn.dhcp_options.attach(dhcp_id, vpc_id)
+      def associate(dhcp_id, vpc_id)
+        @conn.dhcp_options.attach(dhcp_id, vpc_id)
       end
     end # => Dhcp