builderator 0.3.10

data/lib/builderator/model/images.rb

@@ -0,0 +1,89 @@
+require 'aws-sdk'
+require_relative '../util'
+
+module Builderator
+  module Model
+
+    def self.images
+      @images ||= Images.new
+    end
+
+    ##
+    # EC2 AMI Resources
+    ##
+    class Images < Model::Base
+      LIMIT = 24
+      PROPERTIES = %w(image_location state owner_id public architecture image_type
+                      name description root_device_type virtualization_type
+                      hypervisor)
+
+      def fetch
+        @resources = {}.tap do |i|
+          Util.ec2.describe_images(:filters => [
+            {
+              :name => 'state',
+              :values => %w(available)
+            }
+          ], :owners => %w(self)).each do |page|
+            page.images.each do |image|
+              properties = Util.from_tags(image.tags)
+              properties['creation_date'] = DateTime.iso8601(image.creation_date)
+              PROPERTIES.each { |pp| properties[pp] = image[pp.to_sym] }
+
+              i[image.image_id] = {
+                :id => image.image_id,
+                :properties => properties,
+                :snapshots => image.block_device_mappings.map { |b| b.ebs.snapshot_id rescue nil }.reject(&:nil?),
+                :parent => properties.fetch('parent_ami', '(undefined)')
+              }
+            end
+          end
+        end
+      end
+
+      def snapshots
+        resources.values.map { |i| i[:snapshots] }.flatten
+      end
+
+      def latest(options = {})
+        {}.tap do |latest|
+          ## Group images
+          group_by = options.fetch('group-by', [])
+          groups = {}.tap do |g|
+            break { 'all' => resources.values } if group_by.empty?
+
+            resources.each do |_, image|
+              (g[group_by.map do |gg|
+                image[:properties].fetch(gg.to_s, '(unknown)')
+              end.join(':')] ||= []) << image
+            end
+          end
+
+          ## Sort each grouping
+          sort_by = options.fetch('sort-by', 'creation_date')
+          groups.each do |_, group|
+            group.sort! { |a, b| b[:properties][sort_by] <=> a[:properties][sort_by] }
+          end
+
+          ## Slice to `keep` length
+          keep = options.fetch('keep', 5)
+          groups.each do |_, group|
+            group.slice!(keep..-1)
+          end
+
+          ## Reduce
+          groups.values.flatten.each { |i| latest[i[:id]] = i }
+        end
+      end
+
+      def in_use(options = {})
+        {}.tap do |used|
+          used.merge!(select(Model.instances.images))
+          used.merge!(select(Model.launch_configs.images))
+          used.merge!(latest(options))
+          used.merge!(select(used.values.map { |i| i[:parent] }))
+        end
+      end
+    end
+  end
+end

data/lib/builderator/model/instances.rb

@@ -0,0 +1,55 @@
+require 'aws-sdk'
+require_relative '../util'
+
+module Builderator
+  module Model
+
+    def self.instances
+      @instances ||= Instances.new
+    end
+    ##
+    # EC2 Instance resources
+    ##
+    class Instances < Model::Base
+      PROPERTIES = %w(private_dns_name public_dns_name instance_type
+                      subnet_id vpc_id private_ip_address public_ip_address
+                      architecture root_device_type virtualization_type
+                      hypervisor)
+
+      def fetch
+        @resources = {}.tap do |i|
+          Util.ec2.describe_instances(:filters => [
+            {
+              :name => 'instance-state-name',
+              :values => %w(pending running shutting-down stopping stopped)
+            }
+          ]).each do |page|
+            page.reservations.each do |r|
+              r.instances.each do |instance|
+                properties = Util.from_tags(instance.tags)
+                properties['availability_zone'] = instance.placement.availability_zone
+                properties['creation_date'] = instance.launch_time.to_datetime
+                PROPERTIES.each { |pp| properties[pp] = instance[pp.to_sym] }
+
+                i[instance.instance_id] = {
+                  :id => instance.instance_id,
+                  :image => instance.image_id,
+                  :volumes => instance.block_device_mappings.map { |b| b.ebs.volume_id },
+                  :properties => properties
+                }
+              end
+            end
+          end
+        end
+      end
+
+      def images
+        resources.values.map { |i| i[:image] }
+      end
+
+      def volumes
+        resources.values.map { |i| i[:volumes] }.flatten
+      end
+    end
+  end
+end

data/lib/builderator/model/launch_configs.rb

@@ -0,0 +1,46 @@
+require 'aws-sdk'
+require_relative '../util'
+
+module Builderator
+  module Model
+
+    def self.launch_configs
+      @launch_configs ||= LaunchConfigs.new
+    end
+
+    ##
+    # ASG LaunchConfiguration Resources
+    ##
+    class LaunchConfigs < Model::Base
+      LIMIT = 24
+      PROPERTIES = %w(launch_configuration_arn key_name security_groups
+                      user_data instance_type spot_price iam_instance_profile
+                      ebs_optimized associate_public_ip_address placement_tenancy)
+
+      def fetch
+        @resources = {}.tap do |i|
+          Util.asg.describe_launch_configurations.each do |page|
+            page.launch_configurations.each do |l|
+              properties = { 'creation_date' => l.created_time.to_datetime }
+              PROPERTIES.each { |pp| properties[pp] = l[pp.to_sym] }
+
+              i[l.launch_configuration_name] = {
+                :id => l.launch_configuration_name,
+                :properties => properties,
+                :image => l.image_id
+              }
+            end
+          end
+        end
+      end
+
+      def images
+        resources.values.map { |l| l[:image] }
+      end
+
+      def in_use(_)
+        select(Model.scaling_groups.launch_configs)
+      end
+    end
+  end
+end

data/lib/builderator/model/scaling_groups.rb

@@ -0,0 +1,43 @@
+require 'aws-sdk'
+require_relative '../util'
+
+module Builderator
+  module Model
+
+    def self.scaling_groups
+      @scaling_groups ||= ScalingGroups.new
+    end
+
+    ##
+    # AutoScaling Group Resoruces
+    ##
+    class ScalingGroups < Model::Base
+      attr_reader :resources
+      PROPERTIES = %w(auto_scaling_group_arn min_size max_size desired_capacity
+                      default_cooldown availability_zones load_balancer_names
+                      vpc_zone_identifier status termination_policies)
+
+      def fetch
+        @resources = {}.tap do |i|
+          Util.asg.describe_auto_scaling_groups.each do |page|
+            page.auto_scaling_groups.each do |a|
+              properties = Util.from_tags(a.tags)
+              properties['creation_date'] = a.created_time.to_datetime
+              PROPERTIES.each { |pp| properties[pp] = a[pp.to_sym] }
+
+              i[a.launch_configuration_name] = {
+                :id => a.auto_scaling_group_name,
+                :properties => properties,
+                :config => a.launch_configuration_name
+              }
+            end
+          end
+        end
+      end
+
+      def launch_configs
+        resources.values.map { |g| g[:config] }
+      end
+    end
+  end
+end

data/lib/builderator/model/snapshots.rb

@@ -0,0 +1,49 @@
+require 'aws-sdk'
+require_relative '../util'
+
+module Builderator
+  module Model
+
+    def self.snapshots
+      @snapshots ||= Snapshots.new
+    end
+
+    ##
+    # EC2 Snapshot Resources
+    ##
+    class Snapshots < Model::Base
+      LIMIT = 24
+      PROPERTIES = %w(state owner_id description volume_size)
+
+      def fetch
+        @resources = {}.tap do |s|
+          Util.ec2.describe_snapshots(:filters => [
+            {
+              :name => 'status',
+              :values => %w(completed)
+            }
+          ], :owner_ids => ['self']).each do |page|
+            page.snapshots.each do |snap|
+              properties = Util.from_tags(snap.tags)
+              properties['creation_date'] = snap.start_time.to_datetime
+              PROPERTIES.each { |pp| properties[pp] = snap[pp.to_sym] }
+
+              s[snap.snapshot_id] = {
+                :id => snap.snapshot_id,
+                :properties => properties,
+                :volume => snap.volume_id
+              }
+            end
+          end
+        end
+      end
+
+      def in_use(_)
+        {}.tap do |used|
+          used.merge!(select(Model.volumes.snapshots))
+          used.merge!(select(Model.images.snapshots))
+        end
+      end
+    end
+  end
+end

data/lib/builderator/model/volumes.rb

@@ -0,0 +1,48 @@
+require 'aws-sdk'
+require_relative '../util'
+
+module Builderator
+  module Model
+
+    def self.volumes
+      @volumes ||= Volumes.new
+    end
+
+    ##
+    # EC2 Volume Resources
+    ##
+    class Volumes < Model::Base
+      LIMIT = 8
+      PROPERTIES = %w(size availability_zone state volume_type iops)
+
+      def fetch
+        @resources = {}.tap do |v|
+          Util.ec2.describe_volumes.each do |page|
+            page.volumes.each do |vol|
+              properties = Util.from_tags(vol.tags)
+              properties['creation_date'] = vol.create_time.to_datetime
+              PROPERTIES.each { |pp| properties[pp] = vol[pp.to_sym] }
+
+
+              v[vol.volume_id] = {
+                :id => vol.volume_id,
+                :properties => properties,
+                :snapshot => vol.snapshot_id
+              }
+            end
+          end
+        end
+      end
+
+      def snapshots
+        resources.values.map { |v| v[:snapshot] }
+      end
+
+      def in_use(_)
+        {}.tap do |used|
+          used.merge!(select(Model.instances.volumes))
+        end
+      end
+    end
+  end
+end

data/lib/builderator/tasks.rb

@@ -0,0 +1,37 @@
+require 'thor'
+require_relative './tasks/ami'
+require_relative './tasks/berks'
+require_relative './tasks/clean'
+require_relative './tasks/cookbook'
+require_relative './tasks/packer'
+require_relative './tasks/vagrant'
+
+module Builderator
+  module Tasks
+    class CLI < Thor
+      desc 'ami SUBCOMMAND', 'Search for AMI IDs'
+      subcommand 'ami', Builderator::Tasks::AMI
+
+      desc 'berks SUBCOMMAND', 'Berkshelf helpers'
+      subcommand 'berks', Builderator::Tasks::Berks
+
+      desc 'clean SUBCOMMAND', 'Clean up things'
+      subcommand 'clean', Builderator::Tasks::Clean
+
+      desc 'cookbook SUBCOMMAND', 'Cookbook tasks'
+      subcommand 'cookbook', Builderator::Tasks::Cookbook
+
+
+      desc 'packer SUBCOMMAND', 'Run Packer tasks'
+      subcommand 'packer', Builderator::Tasks::Packer
+
+      desc 'vagrant SUBCOMMAND', 'Run Vagrant tasks'
+      subcommand 'vagrant', Builderator::Tasks::Vagrant
+
+      desc 'version', 'Print gem version'
+      def version
+        puts Builderator::VERSION
+      end
+    end
+  end
+end

data/lib/builderator/tasks/ami.rb

@@ -0,0 +1,37 @@
+require 'thor'
+require_relative '../control/ami'
+
+module Builderator
+  module Tasks
+    class AMI < Thor
+      namespace :ami
+
+      class_option :root_device_type,
+                   :default => 'ebs',
+                   :desc => 'The type of the root device volume (ebs | instance-store)'
+      class_option :virtualization_type,
+                   :default => 'hvm',
+                   :desc => 'The virtualization type (paravirtual | hvm)'
+      class_option :architecture,
+                   :default => 'x86_64',
+                   :desc => 'The image architecture (i386 | x86_64)'
+
+      desc 'ubuntu SEARCH', 'Print the latest AMI ID for an Ubuntu image matching the SEARCH string'
+      def ubuntu(search = '*/hvm-ssd/ubuntu-trusty-daily-amd64-server-20*')
+        puts Control::AMI.latest(:owner => Builderator::Control::AMI::Owners::UBUNTU,
+                                 'root-device-type' => options['root_device_type'],
+                                 'virtualization-type' => options['virtualization_type'],
+                                 'architecture' => options['architecture'],
+                                 'name' => search).image_id
+      end
+
+      desc 'private [KEY VALUE ...]', 'Find the latest AMI ID with tags KEY=VALUE'
+      def private(*args)
+        puts Control::AMI.latest({ :owner => Builderator::Control::AMI::Owners::SELF,
+                                   'root-device-type' => options['root_device_type'],
+                                   'virtualization-type' => options['virtualization_type'],
+                                   'architecture' => options['architecture'] }.merge(Hash[*args])).image_id
+      end
+    end
+  end
+end

data/lib/builderator/tasks/berks.rb

@@ -0,0 +1,68 @@
+require 'thor'
+require 'thor/actions'
+require_relative './cookbook'
+require_relative '../util/cookbook'
+
+module Builderator
+  module Tasks
+    class Berks < Thor
+      include Thor::Actions
+      class_option :config, :aliases => :c, :desc => "Path to Berkshelf's config.json"
+      class_option :cookbook, :aliases => :b, :desc => 'Path to the cookbook to use'
+      class_option :version, :type => :boolean,
+                             :default => true,
+                             :desc => 'Write current verison to file'
+
+      desc "local [PATH = #{ Util::Cookbook::DEFAULT_VENDOR }]", 'Vendor the local cookbook source and its dependencies'
+      def local(path = Util::Cookbook::DEFAULT_VENDOR)
+        Util::Cookbook.path(options['cookbook'])
+
+        command = 'BERKS_INSTALL_FROM=source'
+        command << " berks vendor #{ path }"
+        command << " -c #{ options['config'] }" if options.include?('config')
+        command << " -b #{ Util::Cookbook.berksfile }"
+
+        remove_file File.expand_path('Berksfile.lock', Util::Cookbook.path)
+        invoke Tasks::Cookbook, 'metadata', [], options
+        run command
+      end
+
+      desc "vendor [PATH = #{ Util::Cookbook::DEFAULT_VENDOR }]", 'Vendor a cookbook release and its dependencies'
+      def vendor(path = Util::Cookbook::DEFAULT_VENDOR)
+        Util::Cookbook.path(options['cookbook'])
+
+        command = 'BERKS_INSTALL_FROM=release'
+        command << " berks vendor #{ path }"
+        command << " -c #{ options['config'] }" if options.include?('config')
+        command << " -b #{ Util::Cookbook.berksfile }"
+
+        remove_file File.expand_path('Berksfile.lock', Util::Cookbook.path)
+        run command
+      end
+
+      desc 'upload', 'Upload the local cookbook source and its dependencies to the Chef server'
+      option 'dry-run', :type => :boolean, :default => false
+      def upload(path = Util::Cookbook::DEFAULT_VENDOR)
+        command = 'BERKS_INSTALL_FROM=source'
+        command << " berks upload"
+        command << " -c #{ options['config'] }" if options.include?('config')
+        command << " -b #{ Util::Cookbook.berksfile }"
+
+        invoke Tasks::Berks, :local, [path], options
+
+        return say_status :dryrun, command if options['dry-run']
+        run command
+      end
+
+      desc 'uncache', 'Delete the Berkshelf cache'
+      def uncache
+        remove_dir File.join(ENV['HOME'], '.berkshelf/cookbooks')
+      end
+
+      desc "clean [PATH = #{ Util::Cookbook::DEFAULT_VENDOR }]", 'Remove a local vendor directory'
+      def clean(path = Util::Cookbook::DEFAULT_VENDOR)
+        remove_dir path
+      end
+    end
+  end
+end