builderator 0.3.15 → 1.0.0.pre.rc.1

data/lib/builderator/config/rash.rb

@@ -0,0 +1,80 @@
+module Builderator
+  module Config
+    ##
+    # A self-populating sparse Hash by Rapid7 ([R]apid7 h[ASH]). Definetly
+    # not a Mash or Smash...
+    ##
+    class Rash < Hash
+      class << self
+        def coerce(somehting)
+          return somehting if somehting.is_a?(self)
+          return new(somehting) if somehting.is_a?(Hash)
+
+          ## `somehting` is not a valid input. Just give back an instance.
+          new
+        end
+      end
+
+      attr_accessor :sealed
+
+      def initialize(from = {}, seal = false)
+        @sealed = seal
+        super() do |_, k|
+          self[k] = self.class.new unless sealed
+        end
+
+        merge!(from) ## Clone a Rash or coerce a Hash to a new Rash
+      end
+
+      def seal(action = true)
+        @sealed = action
+        each_value { |v| v.seal(action) if v.is_a?(self.class) }
+      end
+
+      def unseal
+        seal(false)
+      end
+
+      alias_method :has?, :include?
+
+      ## Symbolize keys
+      [:include?, :[], :fetch, :[]=, :store].each do |m|
+        define_method(m) do |key, *args|
+          super(key.to_sym, *args)
+        end
+      end
+
+      def merge!(other)
+        fail TypeError, 'Argument other of  `Rash#merge!(other)` must be a Hash.'\
+                        " Recieved #{other.class}" unless other.is_a?(Hash)
+
+        other.each do |k, v|
+          ## Replace `-`s with `_`s in in String keys
+          k = k.gsub(/\-/, '_') if k.is_a?(String)
+
+          ## Merge Arrays
+          next self[k] |= v if fetch(k, nil).is_a?(Array) && v.is_a?(Array)
+
+          ## Overwrite non-Hash values
+          next self[k] = v unless v.is_a?(Hash)
+
+          ## Replace `self[k]` with a new Rash unless it already is one
+          self[k] = self.class.new unless fetch(k, nil).is_a?(self.class)
+
+          ## Merge recursivly coerces `v` to a Rash
+          self[k].merge!(v)
+        end
+      end
+
+      def to_hash
+        each_with_object({}) do |(k, v), hash|
+          ## Not a hash-value
+          next hash[k] = v unless v.is_a?(self.class)
+
+          ## Recursivly coerces `v` to a Hash
+          hash[k] = v.to_hash
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/cleaner.rb

@@ -0,0 +1,138 @@
+require_relative '../model/cleaner'
+require_relative '../util'
+
+module Builderator
+  module Control
+    ##
+    # Control logic for cleanup tasks
+    ##
+    module Cleaner
+      class << self
+        def configs!
+          resources = Model::Cleaner.launch_configs.unused
+
+          yield :launch_configs, "Found #{resources.length} Launch Configurations to remove"
+          verify!(:launch_configs, 'Cleanup Launch Configurations', resources, &Proc.new)
+          aborted!(&Proc.new)
+
+          resources.keys.sort.each do |id|
+            yield :remove, "Launch Configuration #{id}", :red
+            Model::Cleaner.launch_configs.resources.delete(id)
+
+            next unless commit?
+            Util.asg.delete_launch_configuration(:launch_configuration_name => id)
+          end
+        rescue Aws::AutoScaling::Errors::ServiceError => e
+          exceptions << Util::AwsException.new('Cleanerup Launch Configurations', e)
+          yield(*exceptions.last.status)
+        end
+
+        def images!
+          resources = Model::Cleaner.images.unused
+
+          yield :images, "Found #{resources.length} Images to remove"
+          yield :grouping, "Groupd images by #{Config.cleaner.group_by}" if Config.cleaner.group_by
+          yield :keep, "Keeping #{Config.cleaner.keep} images in each group"
+          verify!(:images, 'Cleanup Images', resources, &Proc.new)
+          aborted!(&Proc.new)
+
+          resources.values
+            .sort { |a, b| a[:properties]['name'] <=> b[:properties]['name'] }
+            .each do |image|
+              yield :remove, "Image #{image[:id]} (#{image[:properties]['name']})", :red
+              Model::Cleaner.images.resources.delete(image[:id])
+
+              next unless commit?
+              Util.ec2.deregister_image(:image_id => image[:id])
+            end
+
+        rescue Aws::EC2::Errors::ServiceError => e
+          exceptions << Util::AwsException.new('Cleanerup Images', e)
+          yield(*exceptions.last.status)
+        end
+
+        def snapshots!
+          resources = Model::Cleaner.snapshots.unused
+
+          yield :snapshots, "Found #{resources.length} Snapshots to remove"
+          verify!(:snapshots, 'Cleanup Snapshots', resources, &Proc.new)
+          aborted!(&Proc.new)
+
+          resources.keys.sort.each do |id|
+            yield :remove, "Snapshot #{id}", :red
+            Model::Cleaner.snapshots.resources.delete(id)
+
+            next unless commit?
+            Util.ec2.delete_snapshot(:snapshot_id => id)
+          end
+        rescue Aws::EC2::Errors::ServiceError => e
+          exceptions << Util::AwsException.new('Cleanerup Snapshots', e)
+          yield(*exceptions.last.status)
+        end
+
+        def volumes!
+          resources = Model::Cleaner.volumes.unused
+
+          yield :volumes, "Found #{resources.length} Volumes to remove"
+          verify!(:volumes, 'Cleanup Volumes', resources, &Proc.new)
+          aborted!(&Proc.new)
+
+          resources.keys.sort.each do |id|
+            yield :remove, "Volume #{id}", :red
+            Model::Cleaner.volumes.resources.delete(id)
+
+            next unless commit?
+            Util.ec2.delete_volume(:volume_id => id)
+          end
+        rescue Aws::EC2::Errors::ServiceError => e
+          exceptions << Util::AwsException.new('Cleanerup Volumes', e)
+          yield(*exceptions.last.status)
+        end
+
+        def commit?
+          @commit && !@abort
+        end
+
+        def aborted?
+          @commit && @abort
+        end
+
+        def exceptions
+          @exceptions ||= []
+        end
+
+        private
+
+        def aborted!
+          yield :aborted, 'The following resources will NOT be removed because'\
+            ' safty constraints have not been met!', :yellow if aborted?
+        end
+
+        def verify!(resource_name, task, resources)
+          if Config.cleaner.commit
+            yield :commit, 'This is not a dry-run. Press CTL-C to stop! '\
+                           '(continuing in 5 seconds)', :red
+
+            sleep(5) ## Give $USER a few seconds to stop
+          end
+
+          return unless resources.size >= Config.cleaner.limits[resource_name]
+
+          ex = Util::LimitException.new(resource_name, task, resources)
+          yield(*ex.status)
+
+          if Config.cleaner.force
+            yield :force, 'Limits will be ignored. Press CTL-C to stop! '\
+                          '(continuing in 5 seconds)', :red
+            sleep(5) ## Give $USER a few seconds to stop
+
+            return
+          end
+
+          exceptions << ex
+          @abort = true
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/cookbook.rb

@@ -0,0 +1,16 @@
+require 'pathname'
+
+module Builderator
+  module Control
+    ##
+    # Cookbook logic and helpers
+    ##
+    module Cookbook
+      class << self
+        def exist?
+          Pathname.new(Config.cookbook.path).join('metadata.rb').exist?
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/data.rb

@@ -0,0 +1,16 @@
+module Builderator
+  module Control
+    ##
+    # Wrapper module for lookup controllers
+    ##
+    module Data
+      def self.lookup(source, query)
+        fail "#{ source } is not a valid data type!" unless respond_to?(source)
+
+        send(source, query)
+      end
+    end
+  end
+end
+
+require_relative './data/image'

data/lib/builderator/control/data/image.rb

@@ -0,0 +1,98 @@
+require 'aws-sdk'
+require 'date'
+
+require_relative '../../util'
+
+module Builderator
+  module Control
+    # :nodoc:
+    module Data
+      def self.image(query = {})
+        Image.search(query)
+      end
+
+      ##
+      # Find AMI IDs to use for sources
+      ##
+      module Image
+        ## Account IDs of public image owners
+        OWNERS = {
+          :self =>  'self'.freeze,
+          :ubuntu => '099720109477'.freeze,
+          :amazon => 'amazon'.freeze,
+          :marketplace => 'aws-marketplace'.freeze
+        }
+
+        ## Pre-defined filters
+        FILTERS = {
+          'ubuntu-14.04-daily' => {
+            'owner' => OWNERS[:ubuntu],
+            'architecture' => 'x86_64',
+            'root-device-type' => 'ebs',
+            'virtualization-type' => 'hvm',
+            'block-device-mapping.volume-type' => 'gp2',
+            'name' => '*ubuntu-trusty-daily-amd64-server-201*'
+          },
+          'windows-server2012-r2' => {
+            'owner' => OWNERS[:amazon],
+            'architecture' => 'x86_64',
+            'root-device-type' => 'ebs',
+            'virtualization-type' => 'hvm',
+            'block-device-mapping.volume-type' => 'gp2',
+            'name' => 'Windows_Server-2012-R2_RTM-English-64Bit-Base*'
+          },
+          'windows-server2012-r2-core' => {
+            'owner' => OWNERS[:amazon],
+            'architecture' => 'x86_64',
+            'root-device-type' => 'ebs',
+            'virtualization-type' => 'hvm',
+            'block-device-mapping.volume-type' => 'gp2',
+            'name' => 'Windows_Server-2012-R2_RTM-English-64Bit-Core*'
+          }
+        }
+
+        ## Filter fields defined in http://docs.aws.amazon.com/sdkforruby/api/Aws/EC2/Builderator::Util.ec2.html#describe_images-instance_method
+        PROPERTIES = %w(architecture block-device-mapping.delete-on-termination
+                        block-device-mapping.device-name block-device-mapping.snapshot-id
+                        block-device-mapping.volume-size block-device-mapping.volume-type
+                        description hypervisor image-id image-type is-public kernel-id
+                        manifest-location name owner-alias owner-id platform product-code
+                        product-code.type ramdisk-id root-device-name root-device-type
+                        state state-reason-code state-reason-message virtualization-type).freeze
+
+        class << self
+          def search(query = {})
+            options = {}
+
+            ## Reverse-merge a pre-defined filter into the query
+            if query.include?('filter')
+              query = FILTERS[query['filter']].merge(query) if FILTERS.include?(query['filter'])
+
+              query.delete('filter')
+            end
+
+            options['image_ids'] = Util.to_array(query.delete('image_id')) if query.include?('image_id')
+            options['owners'] = Util.to_array(query.delete('owner') { 'self' })
+
+            options['filters'] = query.each_with_object([]) do |(k, v), memo|
+              next if v.nil?
+
+              ## Construct filter objects. Assume that non-enumerated keys are tags
+              memo << {
+                :name => PROPERTIES.include?(k.to_s) ? k.to_s : "tag:#{ k }",
+                :values => Util.to_array(v)
+              }
+            end
+
+            ## Don't send an empty filters array
+            options.delete('filters') if options['filters'].empty?
+
+            Util.ec2.describe_images(options)
+              .each_with_object([]) { |page, images| images.push(*page.images) }
+              .sort { |a, b| DateTime.iso8601(b.creation_date) <=> DateTime.iso8601(a.creation_date) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/builderator/control/version.rb

@@ -0,0 +1,128 @@
+require_relative './version/auto'
+require_relative './version/bump'
+require_relative './version/comparable'
+require_relative './version/scm'
+require_relative './version/git'
+
+module Builderator
+  module Control
+    ##
+    # Version management tools
+    #
+    # Initial version boosted shamelessly from
+    # https://github.com/RiotGamesMinions/thor-scmversion
+    ##
+    class Version
+      FORMAT = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?<prerelease>-(?<prerelease_name>[A-Za-z0-9]+)\.(?<prerelease_iteration>\d+))?(?:\+build\.(?<build>\d+))?$/
+      DEFAULT_PRERELEASE_NAME = 'alpha'.freeze
+
+      ## Order of precedence for release types
+      RELEASE_TYPES = {
+        'major' => 0,
+        'major-prerelease' => 5,
+        'minor' => 10,
+        'minor-prerelease' => 15,
+        'patch' => 20,
+        'patch-prerelease' => 25,
+        'release' => 30,
+        'prerelease' => 35,
+        'build' => 40
+      }
+
+      class << self
+        def current
+          @current ||= SCM.tags.last
+        end
+
+        def set_config_version
+          Config.defaults.version = current.to_s
+          Config.recompile
+        end
+
+        def write
+          current.write
+        end
+
+        ##
+        # Alias `bump` to the current version
+        ##
+        def bump(type = nil, prerelease_name = nil)
+          @current = current.clone
+
+          current.bump(type, prerelease_name)
+          SCM.tags << current
+
+          current
+        end
+
+        ## Parse a SemVer string into a Version
+        def from_string(arg, options = {})
+          matchdata = arg.match(FORMAT)
+          fail "Builderator::Control::Version.from_string: #{arg} is not a supported semver string" if matchdata.nil?
+
+          new(matchdata[:major], matchdata[:minor], matchdata[:patch], matchdata[:build], options).tap do |version|
+            version.is_prerelease = !matchdata[:prerelease].nil?
+            if version.is_prerelease
+              version.prerelease_name = matchdata[:prerelease_name]
+              version.prerelease_iteration = matchdata[:prerelease_iteration].to_i
+            end
+          end
+        end
+      end
+
+      def initialize(major, minor, patch, build = nil, **options)
+        @major = major.to_i
+        @minor = minor.to_i
+        @patch = patch.to_i
+        @build = build.to_i unless build.nil?
+
+        @ref = options[:ref]
+      end
+
+      include Auto
+      include Bump
+      include Comparable
+
+      attr_accessor :ref
+
+      attr_accessor :major
+      attr_accessor :minor
+      attr_accessor :patch
+
+      attr_accessor :is_prerelease
+      attr_accessor :prerelease_name
+      attr_accessor :prerelease_iteration
+
+      attr_accessor :build
+
+      ## Create or bump a new prerelease train
+      def prerelease(name = nil)
+        self.build = nil ## Reset the build counter
+
+        ## Increment current prerelease train
+        if is_prerelease && (name.nil? || name == prerelease_name)
+          self.prerelease_iteration += 1
+          return self
+        end
+
+        ## New prerelease train
+        self.is_prerelease = true
+        self.prerelease_name = name.nil? ? DEFAULT_PRERELEASE_NAME : name
+        self.prerelease_iteration = 0
+
+        self
+      end
+
+      def write
+        Util.relative_path('VERSION').write(to_s)
+      end
+
+      def to_s
+        string = [major, minor, patch].join('.')
+        string << "-#{prerelease_name}.#{prerelease_iteration}" if is_prerelease
+        string << "+build.#{build}" unless build.nil?
+        string
+      end
+    end
+  end
+end