aws_auditor 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab46106d378fae4b5bdeb24caad77cf619c9b5d8
-  data.tar.gz: 5b793c1b55f6720f199c3fd3ff9a520caee361e9
+  metadata.gz: d0f543e05c774a62f7dcc400a2cbdb00f3fec473
+  data.tar.gz: 79ae672c65fa1e14cae28394f2dcc042c5dc3211
 SHA512:
-  metadata.gz: a1d1dfaf2d515d74a6ec34a03cf5953720f73985277eeacb37e413a0fc9ba10cf5b72f7eb0350ad9c94f58ff6e7dc62404e09ed8aff863b37a1b81d3d9b431bd
-  data.tar.gz: dcd6f19f8607f7e4c731b1ac89dbc0744fa3ac6a2482f9bd0c875c537def9d5848d4fec0eb3fc544775368db036982465f91d39bef4a07f2b37b281c02bffc32
+  metadata.gz: c07e87a2609f71d2d5c7a6d35b825c7a657133190a847c2a676dc587c4dfb5ac9240643a0a0b03e75b3488993830263fec942da11257717a95cbff3cff9e1ff8
+  data.tar.gz: cc2b3d0bf48be20e31d01d6d3a636e86318124f92a8daaf7cbed8100e9fd594ea26420227fe5ea03e0acbb47a15f7847abf1e1b84c00f748505245fef424747a

data/.gitignore

@@ -13,6 +13,7 @@
 *.a
 mkmf.log
 
+.DS_Store
 .aws.yml
 .google.yml
 *.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0-p481

data/README.md

@@ -21,7 +21,7 @@ Or install it yourself as:
 ## How-to
 
 ### AWS Setup
-Create a `.aws.yml` file in the root directory with the following structure.
+Create a `.aws.yml` file in your home directory with the following structure.
 
 ```yaml
 ---
@@ -34,33 +34,35 @@ account2:
 ```
 
 ### Google Setup (optional)
-You can export audit information to a Google Spreadsheet, but you must first create a `.google.yml` in the root directory with the following structure.
+You can export audit information to a Google Spreadsheet, but you must first follow “Create a client ID and client secret” on [this page](https://developers.google.com/drive/web/auth/web-server) to get a client ID and client secret for OAuth. Then create a `.google.yml` in your home directory with the following structure.
 
 ```yaml
 ---
-login:
-  email: 'GOOGLE_EMAIL_ADDRESS'
-  password: 'GOOGLE_EMAIL_PASSWORD'
+credentials:
+  client_id: 'GOOGLE_CLIENT_ID'
+  client_secret: 'GOOGLE_CLIENT_ID'
 file:
   path: 'DESIRED_PATH_TO_FILE' #optional, creates in root directory otherwise
   name: 'NAME_OF_FILE'
 ```
  
+## Usage
+
 To find discrepancies between number of running instances and purchased instances, run:
 
     $ aws_auditor audit account1
 
-To list running instances for all stacks in your account, run:
+To list information about all running instances in your account, run:
 
     $ aws_auditor inspect account1
 
 To export audit information to a Google Spreadsheet, make sure you added a `.google.yml` and run:
 
-    $ aws_auditor export account1
+    $ aws_auditor export -d account1
     
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/aws_auditor/fork )
+1. Fork it ( https://github.com/elliothursh/aws_auditor/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/aws_auditor.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'hashie', '~> 3.3'
   spec.add_dependency 'gli', '~> 2.10'
   spec.add_dependency 'highline', '~> 1.6'
-  spec.add_dependency 'google_drive', '~> 0.3'
+  spec.add_dependency 'google_drive', '~> 1.0.0.pre2'
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/aws_auditor/aws.rb

@@ -23,7 +23,11 @@ module AwsAuditor
     def self.load_config
       return @config if @config
       @config = AwsConfig[YAML.load_file(config_path)]
-      @config = @config[@environment] if @environment
+      if @config.has_key? @environment
+        @config = @config[@environment]
+      else
+        puts "Could not find AWS credentials for #{@environment} environment"; exit
+      end
       @config[:region] ||= 'us-east-1'
       @config
     end
@@ -37,8 +41,7 @@ module AwsAuditor
         if old_dir != Dir.pwd
           config_path
         else
-          puts "Could not find #{FILE_NAMES.join(' or ')}"
-          exit
+          puts "Could not find #{FILE_NAMES.join(' or ')}"; exit
         end
       end
     end

data/lib/aws_auditor/cache_instance.rb

@@ -5,6 +5,10 @@ module AwsAuditor
     extend InstanceHelper
     extend CacheWrapper
 
+    class <<self
+      attr_accessor :instances, :reserved_instances
+    end
+
     attr_accessor :id, :name, :instance_type, :engine, :count
     def initialize(cache_instance)
       @id = cache_instance[:cache_cluster_id] || cache_instance[:reserved_cache_node_id]
@@ -19,19 +23,19 @@ module AwsAuditor
     end
 
     def self.get_instances
-      instances = cache.describe_cache_clusters[:cache_clusters]
-      instances.map do |instance|
+      return @instances if @instances
+      @instances = cache.describe_cache_clusters[:cache_clusters].map do |instance|
         next unless instance[:cache_cluster_status].to_s == 'available'
         new(instance)
-      end if instances
+      end.compact
     end
 
     def self.get_reserved_instances
-      instances = cache.describe_reserved_cache_nodes[:reserved_cache_nodes]
-      instances.map do |instance|
+      return @reserved_instances if @reserved_instances
+      @reserved_instances = cache.describe_reserved_cache_nodes[:reserved_cache_nodes].map do |instance|
         next unless instance[:state].to_s == 'active'
         new(instance)
-      end if instances
+      end.compact
     end
 
   end

data/lib/aws_auditor/commands/audit.rb

@@ -1,11 +1,11 @@
 arg :aws_account
 desc 'Audits Reserved Instance Counts'
 command 'audit' do |c|
-	c.switch [:e, :ec2], :desc => "Only audit EC2 instances"
-	c.switch [:d, :rds], :desc => "Only audit RDS instances"
-	c.switch [:c, :cache], :desc => "Only audit ElastiCache instances"
-	c.switch [:r, :reserved], :desc => "Shows reserved instance counts"
-	c.switch [:i, :instances], :desc => "Shows current instance counts"
+  c.switch [:e, :ec2], :desc => "Only audit EC2 instances"
+  c.switch [:d, :rds], :desc => "Only audit RDS instances"
+  c.switch [:c, :cache], :desc => "Only audit ElastiCache instances"
+  c.switch [:r, :reserved], :desc => "Shows reserved instance counts"
+  c.switch [:i, :instances], :desc => "Shows current instance counts"
   c.action do |global_options, options, args|
     require_relative '../scripts/audit'
     raise ArgumentError, 'You must specify an AWS account' unless args.first

data/lib/aws_auditor/commands/export.rb

@@ -1,6 +1,8 @@
 arg :aws_account
 desc 'Export an Audit to Google SpreadSheets'
 command 'export' do |c|
+  c.switch [:c, :csv], :desc => "Exports to CSV"
+  c.switch [:d, :drive], :desc => "Exports to Google Drive"
   c.action do |global_options, options, args|
     require_relative '../scripts/export'
     raise ArgumentError, 'You must specify an AWS account' unless args.first

data/lib/aws_auditor/commands/inspect.rb

@@ -1,9 +1,9 @@
 arg :aws_account
 desc 'Reviews Stack Instances'
 command 'inspect' do |c|
-	c.switch [:e, :ec2], :desc => "Only audit EC2 instances"
-	c.switch [:d, :rds], :desc => "Only audit RDS instances"
-	c.switch [:c, :cache], :desc => "Only audit ElastiCache instances"
+  c.switch [:e, :ec2], :desc => "Only inspect EC2 instances"
+  c.switch [:d, :rds], :desc => "Only inspect RDS instances"
+  c.switch [:c, :cache], :desc => "Only inspect ElastiCache instances"
   c.action do |global_options, options, args|
     require_relative '../scripts/inspect'
     raise ArgumentError, 'You must specify an AWS account' unless args.first

data/lib/aws_auditor/ec2_instance.rb

@@ -5,19 +5,42 @@ module AwsAuditor
     extend InstanceHelper
     extend EC2Wrapper
 
-    attr_accessor :id, :platform, :availability_zone, :instance_type, :count
+    class <<self
+      attr_accessor :instances, :reserved_instances
+    end
+
+    attr_accessor :id, :name, :platform, :availability_zone, :instance_type, :count, :stack_name
     def initialize(ec2_instance, count=1)
       @id = ec2_instance.id
+      @name = nil
       @platform = platform_helper(ec2_instance)
       @availability_zone = ec2_instance.availability_zone
       @instance_type = ec2_instance.instance_type
       @count = count
+      @stack_name = nil
     end
 
     def to_s
       "#{@platform} #{@availability_zone} #{@instance_type}"
     end
 
+    def self.get_instances
+      return @instances if @instances
+      @instances = ec2.instances.map do |instance|
+        next unless instance.status.to_s == 'running'
+        new(instance)
+      end.compact
+      get_more_info
+    end
+
+    def self.get_reserved_instances
+      return @reserved_instances if @reserved_instances
+      @reserved_instances = ec2.reserved_instances.map do |ri|
+        next unless ri.state == 'active'
+        new(ri, ri.instance_count)
+      end.compact
+    end
+
     def platform_helper(ec2_instance)
       if ec2_instance.class.to_s == 'AWS::EC2::Instance'
         if ec2_instance.vpc? 
@@ -41,21 +64,30 @@ module AwsAuditor
         end
       end
     end
+    private :platform_helper
 
-    def self.get_instances
-      instances = ec2.instances
-      instances.map do |instance|
-        next unless instance.status.to_s == 'running'
-        new(instance)
-      end if instances
+    def self.get_more_info
+      get_instances.each do |instance|
+        tags = ec2.client.describe_tags(:filters => [{:name => "resource-id", :values => [instance.id]}])[:tag_set]
+        tags = Hash[tags.map { |tag| [tag[:key], tag[:value]]}.compact]
+        instance.name = tags["Name"]
+        instance.stack_name = tags["opsworks:stack"]
+      end
     end
+    private_class_method :get_more_info
 
-    def self.get_reserved_instances
-      reserved_instances = ec2.reserved_instances
-      reserved_instances.map do |ri|
-        next unless ri.state == 'active'
-        new(ri, ri.instance_count)
-      end if reserved_instances
+    def self.bucketize
+      buckets = {}
+      get_instances.map do |instance|
+        name = instance.stack_name || instance.name
+        if name
+          buckets[name] = [] unless buckets.has_key? name
+          buckets[name] << instance
+        else
+          puts "Could not sort #{instance.id}, as it has no stack_name or name"
+        end
+      end
+      buckets.sort_by{|k,v| k }
     end
 
   end

data/lib/aws_auditor/google.rb

@@ -1,14 +1,36 @@
+require "google/api_client"
+require "google_drive"
+
 module AwsAuditor
 	class GoogleConfig < Hash
     include Hashie::Extensions::IndifferentAccess
   end
 
   class Google
-  FILE_NAMES = %w[.google.yml]
+    FILE_NAMES = %w[.google.yml]
 
     def self.configuration
-      credentials = load_config[:login]
-      GoogleDrive.login(credentials[:email],credentials[:password])
+      GoogleDrive.login_with_oauth(get_authorization)
+    end
+
+    def self.get_authorization
+      creds = load_config[:credentials]
+      client = ::Google::APIClient.new
+      auth = client.authorization
+      auth.client_id = creds[:client_id]
+      auth.client_secret = creds[:client_secret]
+      auth.scope =
+          "https://www.googleapis.com/auth/drive " +
+          "https://docs.google.com/feeds/ " +
+          "https://docs.googleusercontent.com/ " +
+          "https://spreadsheets.google.com/feeds/"
+      auth.redirect_uri = "urn:ietf:wg:oauth:2.0:oob"
+      print("1. If it doesn't automatically open, open this page:\n%s\n\n" % auth.authorization_uri)
+      `open "#{auth.authorization_uri}"`
+      print("2. Enter the authorization code shown in the page: ")
+      auth.code = $stdin.gets.chomp
+      auth.fetch_access_token!
+      access_token = auth.access_token
     end
 
     def self.file

data/lib/aws_auditor/google_sheet.rb

@@ -1,80 +1,80 @@
 require 'google_drive'
 
 module AwsAuditor
-	class GoogleSheet
-		extend GoogleWrapper
+  class GoogleSheet
+    extend GoogleWrapper
 
-		attr_accessor :sheet, :worksheet, :path
-		def initialize(title, path, environment)
-			@sheet = self.class.create_sheet(title, path)
-			@worksheet = self.class.worksheet(sheet, environment)
-		end
+    attr_accessor :sheet, :worksheet, :path
+    def initialize(title, path, environment)
+      @sheet = self.class.create_sheet(title, path)
+      @worksheet = self.class.worksheet(sheet, environment)
+    end
 
-		def write_header(header)
-			worksheet.list.keys = header.unshift('name')
-			worksheet.save
-		end
+    def write_header(header)
+      worksheet.list.keys = header.unshift('name')
+      worksheet.save
+    end
 
-		def write_row(value_hash)
-			worksheet.list.push(value_hash)
-			worksheet.save
-		end
+    def write_row(value_hash)
+      worksheet.list.push(value_hash)
+      worksheet.save
+    end
 
-		def self.first_or_create(title)
-			spreadsheet = google.root_collection.files("title" => title, "title-exact" => true)[0]
-			spreadsheet ? spreadsheet : google.create_spreadsheet(title)
-		end
+    def self.first_or_create(title)
+      spreadsheet = google.root_collection.files("title" => title, "title-exact" => true).first
+      spreadsheet ? spreadsheet : google.create_spreadsheet(title)
+    end
 
-		#returns a spreadsheet object
-		def self.create_sheet(title, path)
-			folder = go_to_collection(path) if path
-			if folder 
-				spreadsheet = folder.files("title" => title, "title-exact" => true)[0]
-				if spreadsheet 
-					return spreadsheet
-				else
-					file = first_or_create(title)
-					folder.add(file)
-					google.root_collection.remove(file)
-					return folder.files("title" => title, "title-exact" => true)[0]
-				end
-			else
-				first_or_create(title)
-			end
-		end
+    #returns a spreadsheet object
+    def self.create_sheet(title, path)
+      folder = go_to_collection(path) if path
+      if folder
+        spreadsheet = folder.files("title" => title, "title-exact" => true).first
+        if spreadsheet
+          return spreadsheet
+        else
+          file = first_or_create(title)
+          folder.add(file)
+          google.root_collection.remove(file)
+          return folder.files("title" => title, "title-exact" => true).first
+        end
+      else
+        first_or_create(title)
+      end
+    end
 
-		#returns a worksheet object
-		def self.worksheet(spreadsheet, title)
-			worksheet = spreadsheet.worksheet_by_title(title)
-			worksheet ? delete_all_rows(worksheet) : spreadsheet.add_worksheet(title)
-		end
+    #returns a worksheet object
+    def self.worksheet(spreadsheet, title)
+      worksheet = spreadsheet.worksheet_by_title(title)
+      worksheet ? delete_all_rows(worksheet) : spreadsheet.add_worksheet(title)
+    end
 
-		#returns a collection object
-		def self.go_to_collection(directory)
-			if directory
-				path = directory.split('/')
-				go_to_subcollection(google.collection_by_title(path[0]),path[1..-1])
-			end
-		end
+    #returns a collection object
+    def self.go_to_collection(directory)
+      if directory
+        path = directory.split('/')
+        go_to_subcollection(google.collection_by_title(path.first),path[1..-1])
+      end
+    end
 
-		#returns a collection object
-		def self.go_to_subcollection(base, subs)
-			puts "Folder doesn't exist in specified path" and exit if base.nil?
-			if subs.empty?
-				return base
-			else
-				base = base.subcollection_by_title(subs[0])
-				go_to_subcollection(base,subs[1..-1])
-			end
-		end
+    #returns a collection object
+    def self.go_to_subcollection(base, subs)
+      puts "Folder doesn't exist in specified path" and exit if base.nil?
+      if subs.empty?
+        return base
+      else
+        base = base.subcollection_by_title(subs.first)
+        go_to_subcollection(base,subs[1..-1])
+      end
+    end
 
-		def self.delete_all_rows(worksheet)
-			worksheet.list.each do |row|
-				row.clear
-			end
-			worksheet.save
-			worksheet
-		end
+    def self.delete_all_rows(worksheet)
+      worksheet.list.each do |row|
+        row.clear
+      end
+      worksheet.save
+      worksheet
+    end
 
-	end
+  end
 end

data/lib/aws_auditor/instance_helper.rb

@@ -1,9 +1,14 @@
 module AwsAuditor
 	module InstanceHelper
+
 		def instance_hash
       Hash[get_instances.map { |instance| instance.nil? ? next : [instance.id, instance]}.compact]
     end
 
+    def reserved_instance_hash
+      Hash[get_reserved_instances.map { |instance| instance.nil? ? next : [instance.id, instance]}.compact]
+    end
+
     def instance_count_hash(instances)
       instance_hash = Hash.new()
       instances.each do |instance|
@@ -25,4 +30,4 @@ module AwsAuditor
       differences
     end
 	end
-end
+end

data/lib/aws_auditor/rds_instance.rb

@@ -5,47 +5,48 @@ module AwsAuditor
     extend InstanceHelper
     extend RDSWrapper
 
+    class <<self
+      attr_accessor :instances, :reserved_instances
+    end
+
     attr_accessor :id, :name, :multi_az, :instance_type, :engine, :count
     def initialize(rds_instance)
       @id = rds_instance[:db_instance_identifier] || rds_instance[:reserved_db_instances_offering_id]
       @name = rds_instance[:db_instance_identifier] || rds_instance[:db_name]
-      @multi_az = rds_instance[:multi_az]
+      @multi_az = rds_instance[:multi_az] ? "Multi-AZ" : "Single-AZ"
       @instance_type = rds_instance[:db_instance_class]
       @engine = rds_instance[:engine] || rds_instance[:product_description]
       @count = rds_instance[:db_instance_count] || 1
     end
 
     def to_s
-      "#{engine_helper} #{multi_az?} #{instance_type}"
-    end
-
-    def multi_az?
-      multi_az ? "Multi-AZ" : "Single-AZ"
-    end
-
-    def engine_helper
-      if engine.downcase.include? "post"
-        return "PostgreSQL"
-      elsif engine.downcase.include? "mysql"
-        return "MySQL"
-      end
+      "#{engine_helper} #{multi_az} #{instance_type}"
     end
 
     def self.get_instances
-      instances = rds.describe_db_instances[:db_instances]
-      instances.map do |instance|
+      return @instances if @instances
+      @instances = rds.describe_db_instances[:db_instances].map do |instance|
         next unless instance[:db_instance_status].to_s == 'available'
         new(instance)
-      end
+      end.compact
     end
 
     def self.get_reserved_instances
-      instances = rds.describe_reserved_db_instances[:reserved_db_instances]
-      instances.map do |instance|
+      return @reserved_instances if @reserved_instances
+      @reserved_instances = rds.describe_reserved_db_instances[:reserved_db_instances].map do |instance|
         next unless instance[:state].to_s == 'active'
         new(instance)
+      end.compact
+    end
+
+    def engine_helper
+      if engine.downcase.include? "post"
+        return "PostgreSQL"
+      elsif engine.downcase.include? "mysql"
+        return "MySQL"
       end
     end
+    private :engine_helper
 
   end
 end

data/lib/aws_auditor/scripts/audit.rb

@@ -5,70 +5,34 @@ module AwsAuditor
     class Audit
       extend AWSWrapper
 
-      def self.execute(environment, options=nil)
-        aws(environment)
-        if options[:ec2]
-          audit_ec2(options)
-        elsif options[:rds]
-          audit_rds(options)
-        elsif options[:cache]
-          audit_cache(options)
-        else
-          audit_ec2(options)
-          audit_rds(options)
-          audit_cache(options)
-        end
-
+      class <<self
+        attr_accessor :options
       end
 
-      def self.audit_rds(options)
-        puts "=============== RDS ==============="
-        if options[:instances]
-          RDSInstance.instance_count_hash(RDSInstance.get_instances).each do |key,value|
-            say "<%= color('#{key}: #{value}', :white) %>"
-          end
-        elsif options[:reserved]
-          RDSInstance.instance_count_hash(RDSInstance.get_reserved_instances).each do |key,value|
-            say "<%= color('#{key}: #{value}', :white) %>"
-          end
-        else
-          RDSInstance.compare.each do |key, value|
-            colorize(key,value)
-          end
-        end
-      end
-
-      def self.audit_ec2(options)
-        puts "=============== EC2 ==============="
-        if options[:instances]
-          EC2Instance.instance_count_hash(EC2Instance.get_instances).each do |key,value|
-            say "<%= color('#{key}: #{value}', :white) %>"
-          end
-        elsif options[:reserved]
-          EC2Instance.instance_count_hash(EC2Instance.get_reserved_instances).each do |key,value|
-            say "<%= color('#{key}: #{value}', :white) %>"
-          end
-        else
-          EC2Instance.compare.each do |key,value|
-            colorize(key,value)
-          end
-        end
+      def self.execute(environment, options=nil)
+        aws(environment)
+        @options = options
+        no_selection = options.values.uniq == [false]
+        output("EC2Instance") if options[:ec2] || no_selection
+        output("RDSInstance") if options[:rds] || no_selection 
+        output("CacheInstance") if options[:cache] || no_selection
       end
 
-      def self.audit_cache(options)
-        puts "============== CACHE =============="
+      def self.output(class_type)
+        klass = AwsAuditor.const_get(class_type)
+        print "Gathering info, please wait..."; print "\r"
         if options[:instances]
-          CacheInstance.instance_count_hash(CacheInstance.get_instances).each do |key,value|
-            say "<%= color('#{key}: #{value}', :white) %>"
-          end
+          instances = klass.instance_count_hash(klass.get_instances)
+          puts header(class_type)
+          instances.each{ |key,value| say "<%= color('#{key}: #{value}', :white) %>" }
         elsif options[:reserved]
-          CacheInstance.instance_count_hash(CacheInstance.get_reserved_instances).each do |key,value|
-            say "<%= color('#{key}: #{value}', :white) %>"
-          end
+          reserved = klass.instance_count_hash(klass.get_reserved_instances)
+          puts header(class_type)
+          reserved.each{ |key,value| say "<%= color('#{key}: #{value}', :white) %>" }
         else
-          CacheInstance.compare.each do |key,value|
-            colorize(key,value)
-          end
+          compared = klass.compare
+          puts header(class_type)
+          compared.each{ |key,value| colorize(key,value) }
         end
       end
 
@@ -82,6 +46,16 @@ module AwsAuditor
         end
       end
 
+      def self.header(type, length = 50)
+        type.upcase!.slice! "INSTANCE"
+        half_length = (length - type.length)/2.0 - 1
+        [
+          "*" * length,
+          "*" * half_length.floor + " #{type} " + "*" * half_length.ceil,
+          "*" * length
+        ].join("\n")
+      end
+
     end
   end
 end

data/lib/aws_auditor/scripts/export.rb

@@ -1,98 +1,146 @@
+require 'csv'
 require_relative "../google"
 
 module AwsAuditor
-	module Scripts
-		class Export
-			extend GoogleWrapper
-			extend AWSWrapper
-
-			def self.execute(environment, options = nil)
-				aws(environment)
-				file = GoogleSheet.new(Google.file[:name], Google.file[:path], environment)
-				file.write_header(get_all_keys)
-				write_opsworks_stacks(file)
-				write_rds(file)
-				write_cache(file)
-				write_totals(file)
-				`open #{file.sheet.human_url}`
-			end
-
-			def self.write_opsworks_stacks(file)
-				file.write_row({name: "EC2"})
-				opsworks_stacks.each do |stack|
-					next if stack.instances.empty?
-					value_hash = EC2Instance.instance_count_hash(stack.instances)
-					value_hash[:name] = stack.name
-					file.write_row(value_hash)
-				end
-			end
-
-			def self.write_rds(file)
-				file.write_row({name: "RDS"})
-				rds_instances.each do |db|
-					value_hash = Hash({:name => db.name, :"#{db.to_s}" => "#{db.count}"})
-					file.write_row(value_hash)
-				end
-			end
-
-			def self.write_cache(file)
-				file.write_row({name: "CACHE"})
-				cache_instances.each do |cache|
-					value_hash = Hash({:name => cache.name, :"#{cache.to_s}" => "#{cache.count}"})
-				 	file.write_row(value_hash)
-				end
-			end
-
-			def self.write_totals(file)
-				file.write_row({name: "TOTALS"})
-				instance_counts = get_all_instance_counts.merge({name: "Running Instances"})
-				file.write_row(instance_counts)
-				reserved_counts = get_all_reserved_counts.merge({name: "Reserved Instances"})
-				file.write_row(reserved_counts)
-				differences = get_difference_counts.merge({name: "Differences"})
-				file.write_row(differences)
-			end
-
-			def self.get_all_keys
-				ec2 = EC2Instance.instance_hash.values.map{ |x| x.to_s }.uniq.sort! { |a,b| a.downcase <=> b.downcase }
-				rds = RDSInstance.instance_hash.values.map{ |x| x.to_s }.uniq.sort! { |a,b| a.downcase <=> b.downcase }
-				cache = CacheInstance.instance_hash.values.map{ |x| x.to_s }.uniq.sort! { |a,b| a.downcase <=> b.downcase }
-				ec2.concat(rds).concat(cache).compact
-			end
-
-			def self.get_all_instance_counts
-				ec2 = EC2Instance.instance_count_hash(EC2Instance.get_instances)
-				rds = RDSInstance.instance_count_hash(RDSInstance.get_instances)
-				cache = CacheInstance.instance_count_hash(CacheInstance.get_instances)
-				ec2.merge(rds).merge(cache)
-			end
-
-			def self.get_all_reserved_counts
-				ec2 = EC2Instance.instance_count_hash(EC2Instance.get_reserved_instances)
-				rds = RDSInstance.instance_count_hash(RDSInstance.get_reserved_instances)
-				cache = CacheInstance.instance_count_hash(CacheInstance.get_reserved_instances)
-				ec2.merge(rds).merge(cache)
-			end
-
-			def self.get_difference_counts
-				ec2 = EC2Instance.compare
-				rds = RDSInstance.compare
-				cache = CacheInstance.compare
-				ec2.merge(rds).merge(cache)
-			end
-
-			def self.opsworks_stacks
-				@opsworks_stacks ||= Stack.all
-			end
-
-			def self.rds_instances
-				@rds_instances ||= RDSInstance.get_instances
-			end
-
-			def self.cache_instances
-				@cache_instances ||= CacheInstance.get_instances
-			end
-
-		end
-	end
-end
+  module Scripts
+    class Export
+      extend GoogleWrapper
+      extend AWSWrapper
+
+      class <<self
+        attr_accessor :ec2_instances, :rds_instances, :cache_instances, :options, :file, :keys_hash, :environment
+      end
+
+      CLASS_TYPES = %w[EC2Instance RDSInstance CacheInstance]
+
+      def self.execute(environment, options = nil)
+        @environment = environment
+        (puts "Must specify either --drive or --csv"; exit) unless options[:csv] || options[:drive]
+        aws(environment)
+        print "Gathering info, please wait..."
+        all_keys = get_all_keys
+        all_info = prepare
+        print "\r" + " " * 50 + "\r"
+
+        create_csv(all_keys,all_info) if options[:csv]
+        upload_to_drive(all_keys,all_info) if options[:drive]
+      end
+
+      def self.create_csv(keys, info)
+        CSV.open("#{environment}.csv", "wb") do |csv|
+          csv << ["name",keys].flatten
+          info.each do |hash|
+            csv << all_keys_hash.merge(hash).values
+          end
+        end
+
+        `open "#{environment}.csv"`
+      end
+
+      def self.upload_to_drive(keys, info)
+        @file = GoogleSheet.new(Google.file[:name], Google.file[:path], environment)
+        print "Exporting to Google Drive, please wait..."
+        file.write_header(keys)
+        info.each do |value_hash|
+          response = file.worksheet.list.push(value_hash)
+          puts response unless response.is_a? GoogleDrive::ListRow
+        end
+        file.worksheet.save
+        print "\r" + " " * 50 + "\r"
+        puts "Exporting Complete."
+        `open #{file.sheet.human_url}`
+      end
+
+      def self.prepare
+        [get_all_arrays,get_all_counts].flatten
+      end
+
+      def self.get_all_keys
+        return @keys if @keys
+        @keys = [
+          [ec2_reserved_instances.values,ec2_instances.values].flatten.map{ |x| x.to_s }.uniq.sort! { |a,b| a.downcase <=> b.downcase },
+          [rds_reserved_instances.values,rds_instances.values].flatten.map{ |x| x.to_s }.uniq.sort! { |a,b| a.downcase <=> b.downcase },
+          [cache_reserved_instances.values,cache_instances.values].flatten.map{ |x| x.to_s }.uniq.sort! { |a,b| a.downcase <=> b.downcase }
+        ].flatten
+      end
+
+      def self.all_keys_hash(name = nil, value = nil)
+        return @keys_hash if @keys_hash && @keys_hash[:name] == name
+        @keys_hash = {:name => name}
+        get_all_keys.each{ |key| @keys_hash[key] = value }
+        @keys_hash
+      end
+
+      def self.get_all_arrays
+        return @all_array if @all_array
+        @all_array = [ec2_array,rds_array,cache_array].flatten
+      end
+
+      def self.ec2_array
+        instance_array = [{name: "OPSWORKS"}]
+        EC2Instance.bucketize.map do |stack_name, stack_instances|
+          instance_array << {:name => stack_name}.merge(EC2Instance.instance_count_hash(stack_instances))
+        end
+        instance_array
+      end
+
+      def self.rds_array
+        instance_array = [{name: "RDS"}]
+        rds_instances.each do |db_name, db|
+          instance_array << Hash({:name => db_name, "#{db.to_s}" => "#{db.count}"})
+        end
+        instance_array
+      end
+
+      def self.cache_array
+        instance_array = [{name: "CACHE"}]
+        cache_instances.each do |cache_name, cache|
+          instance_array << Hash({:name => cache_name, "#{cache.to_s}" => "#{cache.count}"})
+        end
+        instance_array
+      end
+
+      def self.get_all_counts
+        total_array = [{:name => "TOTALS"}]
+        total_array << all_keys_hash("Running Instances").merge(counts(:instance => true))
+        total_array << all_keys_hash("Reserved Instances", 0).merge(counts(:reserved => true))
+        total_array << all_keys_hash("Differences").merge(counts(:compare => true))
+      end
+
+      def self.counts(options = {:instance => false, :reserved => false, :compare => false })
+        CLASS_TYPES.map do |class_type|
+          klass = AwsAuditor.const_get(class_type)
+          instances = klass.instance_count_hash(klass.get_instances) if options[:instance]
+          instances = klass.instance_count_hash(klass.get_reserved_instances) if options[:reserved]
+          instances = klass.compare if options[:compare]
+          instances
+        end.inject(:merge)
+      end
+
+      def self.ec2_instances
+        @ec2_instances ||= EC2Instance.instance_hash
+      end
+
+      def self.ec2_reserved_instances
+        @ec2_reserved_instances ||= EC2Instance.reserved_instance_hash
+      end
+
+      def self.rds_instances
+        @rds_instances ||= RDSInstance.instance_hash
+      end
+
+      def self.rds_reserved_instances
+        @rds_reserved_instances ||= RDSInstance.reserved_instance_hash
+      end
+      
+      def self.cache_instances
+        @cache_instances ||= CacheInstance.instance_hash
+      end
+
+      def self.cache_reserved_instances
+        @cache_reserved_instances ||= CacheInstance.reserved_instance_hash
+      end
+
+    end
+  end
+end

data/lib/aws_auditor/scripts/inspect.rb

@@ -6,43 +6,39 @@ module AwsAuditor
 
       def self.execute(environment, options=nil)
         aws(environment)
-        if options[:ec2]
-          inspect_stacks
-        elsif options[:rds]
-          inspect_dbs
-        elsif options[:cache]
-          inspect_caches
-        else
-          puts "You must use a switch. See `aws-auditor inspect --help` for more info."
-        end
+        no_selection = options.values.uniq == [false]
+        output("EC2Instance") if options[:ec2] || no_selection
+        output("RDSInstance") if options[:rds] || no_selection 
+        output("CacheInstance") if options[:cache] || no_selection
       end
 
-      def self.inspect_stacks
-        Stack.all.each do |stack|
-          stack.pretty_print
+      def self.output(class_type)
+        klass = AwsAuditor.const_get(class_type)
+        print "Gathering info, please wait..."; print "\r"
+        instances = class_type == "EC2Instance" ? klass.bucketize : klass.instance_hash
+        say "<%= color('#{header(class_type)}', :white) %>"
+        instances.each do |key, value|
+          pretty_print(key, klass.instance_count_hash(Array(value)))
         end
       end
 
-      def self.inspect_dbs
-        RDSInstance.get_instances.each do |db|
-          puts "========================"
-          puts "#{db.name}"
-          puts "========================"
-          puts db.to_s
-          puts "\n"
-        end
+      def self.header(type, length = 50)
+        type.upcase!.slice! "INSTANCE"
+        half_length = (length - type.length)/2.0 - 1
+        [
+          "*" * length,
+          "*" * half_length.floor + " #{type} " + "*" * half_length.ceil,
+          "*" * length
+        ].join("\n")
       end
 
-      def self.inspect_caches
-        CacheInstance.get_instances.each do |cache|
-          puts "========================"
-          puts "#{cache.name}"
-          puts "========================"
-          puts cache.to_s
-          puts "\n"
-        end
+      def self.pretty_print(title, body)
+        puts "======================================="
+        puts "#{title}"
+        puts "======================================="
+        body.each{ |key, value| say "<%= color('#{key}: #{value}', :white) %>" }
+        puts "\n"
       end
-
     end
   end
 end

data/lib/aws_auditor/stack.rb

@@ -5,6 +5,10 @@ module AwsAuditor
     extend OpsWorksWrapper
     extend EC2Wrapper
 
+    class <<self
+      attr_accessor :instances, :stacks
+    end
+
     attr_accessor :id, :name, :instances
     def initialize(aws_stack)
       @id = aws_stack[:stack_id]
@@ -13,9 +17,10 @@ module AwsAuditor
     end
 
     def get_instances
-      instances = self.class.opsworks.describe_instances({stack_id: id})[:instances]
-      instances.map do |instance|
+      return @instances if @instances
+      @instances = self.class.opsworks.describe_instances({stack_id: id})[:instances].map do |instance|
         next unless instance[:status].to_s == 'online'
+        self.class.all_instances[instance[:ec2_instance_id]].stack_id = id
         self.class.all_instances[instance[:ec2_instance_id]]
       end
     end
@@ -35,16 +40,24 @@ module AwsAuditor
     end
     
     def self.all
-      stacks = opsworks.describe_stacks
-      stacks.data[:stacks].map do |stack|
+      return @stacks if @stacks 
+      @stacks = opsworks.describe_stacks.data[:stacks].map do |stack|
         new(stack)
-      end.sort! { |a,b| a.name.downcase <=> b.name.downcase } if stacks
+      end.sort! { |a,b| a.name.downcase <=> b.name.downcase }
     end
 
     def self.all_instances
       @all_instances ||= EC2Instance.instance_hash
     end
 
+    def self.instances_without_stack 
+      all #simply getting all stacks to make sure instance stack_ids is set
+      all_instances.map do |id, instance|
+        next if instance.stack_id 
+        instance
+      end.compact
+    end
+
   end
 end
 

data/lib/aws_auditor/version.rb

@@ -1,3 +1,3 @@
 module AwsAuditor
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws_auditor
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Elliot Hursh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2015-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 1.0.0.pre2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.3'
+        version: 1.0.0.pre2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +118,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -162,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: AWS configuration as code