automan 2.1.2

data/lib/automan/cloudformation/replacer.rb

@@ -0,0 +1,102 @@
+require 'automan'
+require 'wait'
+
+module Automan::Cloudformation
+  class Replacer < Automan::Base
+    add_option :name
+
+    def initialize(options=nil)
+      super
+      @wait = Wait.new({
+        delay: 60,
+        attempts: 20, # 20 x 60s == 20m
+        debug: true,
+        rescuer:  WaitRescuer.new,
+        logger:   @logger
+      })
+    end
+
+    # potential states
+    # stack does not exist
+    # CREATE_IN_PROGRESS | CREATE_FAILED | CREATE_COMPLETE
+    # ROLLBACK_IN_PROGRESS | ROLLBACK_FAILED | ROLLBACK_COMPLETE
+    # DELETE_IN_PROGRESS | DELETE_FAILED | DELETE_COMPLETE
+    # UPDATE_IN_PROGRESS | UPDATE_COMPLETE_CLEANUP_IN_PROGRESS | UPDATE_COMPLETE
+    # UPDATE_ROLLBACK_IN_PROGRESS | UPDATE_ROLLBACK_FAILED | UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS | UPDATE_ROLLBACK_COMPLETE
+
+    # so we want:
+    # when CREATE_COMPLETE | UPDATE_COMPLETE then continue
+    # when CREATE_FAILED | .*ROLLBACK_.* | ^DELETE_.* then raise error
+    # else try again
+    #
+    def ok_to_replace_instances?(stack_status, last_mod_time)
+      case stack_status
+      when 'UPDATE_COMPLETE'
+        if (Time.now - last_mod_time) <= (5*60)
+          true
+        else
+          false
+        end
+      when 'CREATE_FAILED', /^.*ROLLBACK.*$/, /^DELETE.*/
+        raise StackBrokenError, "Stack is in broken state #{stack_status}"
+      else
+        false
+      end
+    end
+
+    def stack_exists?(stack_name)
+      cfn.stacks[stack_name].exists?
+    end
+
+    def stack_asg
+      resources = cfn.stacks[name].resources
+      asgs = resources.select {|i| i.resource_type == "AWS::AutoScaling::AutoScalingGroup"}
+      if asgs.nil? || asgs.empty?
+        return nil
+      end
+      asg_id = asgs.first.physical_resource_id
+      as.groups[asg_id]
+    end
+
+    def stack_was_just_updated?(stack)
+      stack.status == 'UPDATE_COMPLETE' && (Time.now - stack.last_updated_time) <= (5*60)
+    end
+
+    # terminate all running instances in the ASG so that new
+    # machines with the latest build will be started
+    def replace_instances
+      log_options
+
+      unless stack_exists?(name)
+        raise StackDoesNotExistError, "Stack #{name} does not exist."
+      end
+
+      stack = cfn.stacks[name]
+      unless stack_was_just_updated?(stack)
+        logger.info "stack was not updated recently, not replacing instances."
+        return
+      end
+
+      ex = WaitTimedOutError.new "Timed out waiting to replace instances."
+      wait_until(ex) do
+        ok_to_replace_instances?(stack.status, stack.last_updated_time)
+      end
+
+      logger.info "replacing all auto-scaling instances in #{name}"
+
+      if stack_asg.nil?
+        raise MissingAutoScalingGroupError, "No ASG found for stack #{name}"
+      end
+
+      stack_asg.ec2_instances.each do |i|
+        if i.status == :running
+          logger.info "terminating instance #{i.id}"
+          i.terminate
+        else
+          logger.info "Not terminating #{i.id} due to status: #{i.status}"
+        end
+      end
+    end
+
+  end
+end

data/lib/automan/cloudformation/terminator.rb

@@ -0,0 +1,61 @@
+require 'automan'
+
+module Automan::Cloudformation
+  class Terminator < Automan::Base
+    add_option :name, :wait_for_completion
+
+    def initialize(options=nil)
+      @wait_for_completion = false
+      super
+      @wait = Wait.new({
+        delay: 60,
+        attempts: 20, # 20 x 60s == 20m
+        debug: true,
+        rescuer:  WaitRescuer.new(),
+        logger:   @logger
+      })
+    end
+
+    def stack_exists?(stack_name)
+      cfn.stacks[stack_name].exists?
+    end
+
+    def delete_stack(stack_name)
+      cfn.stacks[stack_name].delete
+    end
+
+    def stack_status(stack_name)
+      cfn.stacks[stack_name].status
+    end
+
+    def stack_deleted?(stack_name)
+      return true if !stack_exists?(stack_name)
+
+      case stack_status(stack_name)
+      when 'DELETE_COMPLETE'
+        true
+      when 'DELETE_FAILED'
+        raise StackDeletionError, "#{stack_name} failed to delete"
+      else
+        false
+      end
+    end
+
+    def terminate
+      log_options
+
+      if !stack_exists? name
+        logger.warn "Stack #{name} does not exist. Doing nothing."
+        return
+      end
+
+      logger.info "terminating stack #{name}"
+      delete_stack name
+
+      if wait_for_completion
+        logger.info "waiting for stack #{name} to be deleted"
+        wait_until { stack_deleted? name }
+      end
+    end
+  end
+end

data/lib/automan/cloudformation/uploader.rb

@@ -0,0 +1,57 @@
+require 'automan'
+
+module Automan::Cloudformation
+  class Uploader < Automan::Base
+    add_option :template_files, :s3_path
+
+    def templates
+      Dir.glob(template_files)
+    end
+
+    def template_valid?(template)
+      contents = File.read template
+      response = cfn.validate_template(contents)
+      if response.has_key?(:code)
+        logger.warn "#{template} is invalid: #{response[:message]}"
+        return false
+      else
+        return true
+      end
+    end
+
+    def all_templates_valid?
+      if templates.empty?
+        raise NoTemplatesError, "No stack templates found for #{template_files}"
+      end
+
+      valid = true
+      templates.each do |template|
+        unless template_valid?(template)
+          valid = false
+        end
+      end
+      valid
+    end
+
+    def upload_file(file)
+      opts = {
+        localfile: file,
+        s3file:    "#{s3_path}/#{File.basename(file)}"
+      }
+      s = Automan::S3::Uploader.new opts
+      s.upload
+    end
+
+    def upload_templates
+      log_options
+
+      unless all_templates_valid?
+        raise InvalidTemplateError, "There are invalid templates. Halting upload."
+      end
+
+      templates.each do |template|
+        upload_file(template)
+      end
+    end
+  end
+end

data/lib/automan/ec2/errors.rb

@@ -0,0 +1,4 @@
+module Automan::Ec2
+  class RequestFailedError < StandardError
+  end
+end

data/lib/automan/ec2/image.rb

@@ -0,0 +1,137 @@
+require 'automan/base'
+require 'automan/ec2/errors'
+
+module Automan::Ec2
+  class Image < Automan::Base
+    add_option :instance, :name, :prune
+
+    include Automan::Mixins::Utils
+
+    def initialize(options=nil)
+      super
+      @wait = Wait.new({
+        delay: 5,
+        attempts: 24, # 24 x 5s == 2m
+        debug: true,
+        rescuer:  WaitRescuer.new,
+        logger:   @logger
+      })
+    end
+
+    def find_inst
+      inst = nil
+      if !instance.nil?
+        inst = ec2.instances[instance]
+      end
+      inst
+    end
+
+    def create
+      inst = find_inst
+      myname = default_image_name
+      logger.info "Creating image #{myname} for #{inst.id}"
+      newami = ec2.images.create(instance_id: instance, name: myname, no_reboot: true)
+      if prune == true
+        set_prunable(newami)
+      end
+    end
+
+    def is_more_than_month_old?(mytime)
+      if mytime.class == Time && mytime < Time.now.utc - (60*60*24*30)
+        true
+      else
+        false
+      end
+    end
+
+    def default_image_name
+      stime = Time.new.iso8601.gsub(/:/, '-')
+      return name + "-" + stime
+    end
+
+    def image_snapshot_exists?(image)
+      !image_snapshot(image).nil?
+    end
+
+    def image_snapshot(image)
+      image.block_devices.each do |device|
+        if !device.nil? &&
+           !device[:ebs].nil? &&
+           !device[:ebs][:snapshot_id].nil?
+
+          return device[:ebs][:snapshot_id]
+        end
+      end
+      nil
+    end
+
+    def set_prunable(newami)
+      logger.info "Setting prunable for AMI #{newami.image_id}"
+      newami.tags["CanPrune"] = "yes"
+
+      wait.until do
+        logger.info "Waiting for a valid snapshot so we can tag it."
+        image_snapshot_exists? newami
+      end
+
+      snapshot = image_snapshot(newami)
+      logger.info "Setting prunable for snapshot #{snapshot}"
+      ec2.snapshots[snapshot].tags["CanPrune"] = "yes"
+    end
+
+    def my_images
+      ec2.images.with_owner('self')
+    end
+
+    def deregister_images(snaplist)
+      my_images.each do |image|
+        my_snapshot = image_snapshot(image)
+
+        next unless snaplist.include?(my_snapshot)
+
+        if image.state != :available
+          logger.warn "AMI #{image.id} could not be deleted because its state is #{image.state}"
+          next
+        end
+
+        if image.tags["CanPrune"] == "yes"
+          logger.info "Deregistering AMI #{image.id}"
+          image.delete
+        end
+      end
+    end
+
+    def delete_snapshots(snaplist)
+      snaplist.each do |snap|
+        if snap.status != :completed
+          logger.warn "Snapshot #{snap.id} could not be deleted because its status is #{snap.status}"
+          next
+        end
+
+        logger.info "Deleting snapshot #{snap.id}"
+        snap.delete
+      end
+
+    end
+
+    def prune_amis
+      condemned_snaps = []
+      allsnapshots = ec2.snapshots.with_owner('self')
+      allsnapshots.each do |onesnapshot|
+        next unless onesnapshot.status == :completed
+
+        mycreatetime = onesnapshot.start_time
+        if is_more_than_month_old?(mycreatetime) and onesnapshot.tags["CanPrune"] == "yes"
+          logger.info "Adding snapshot #{onesnapshot.id} to condemed list"
+          condemned_snaps.push onesnapshot
+        end
+      end
+
+      unless condemned_snaps.empty?
+        deregister_images condemned_snaps.map {|s| s.id }
+        delete_snapshots  condemned_snaps
+      end
+    end
+
+  end
+end

data/lib/automan/ec2/instance.rb

@@ -0,0 +1,83 @@
+require 'automan'
+
+module Automan::Ec2
+  class Instance < Automan::Base
+    add_option :environment, :private_key_file
+
+    def password_data(instance_id)
+      opts = { instance_id: instance_id }
+      response = ec2.client.get_password_data opts
+
+      unless response.successful?
+        raise RequestFailedError, "get_password_data failed: #{response.error}"
+      end
+
+      response.data[:password_data]
+    end
+
+    def decrypt_password(encrypted, private_key)
+      pk = OpenSSL::PKey::RSA.new(private_key)
+      begin
+        decoded = Base64.decode64(encrypted)
+        password = pk.private_decrypt(decoded)
+      rescue OpenSSL::PKey::RSAError => e
+        logger.warn "Decrypt failed: #{e.message}"
+        return nil
+      end
+      password
+    end
+
+    def windows_password(instance_id, private_key)
+      begin
+        encrypted = password_data(instance_id)
+      rescue RequestFailedError => e
+        logger.warn e.message
+        return nil
+      end
+
+      if encrypted.nil?
+        return nil
+      end
+
+      decrypt_password(encrypted, private_key)
+    end
+
+    def windows_name(ip_address)
+      return nil if ip_address.nil?
+      return nil if ip_address.empty?
+
+      quads = ip_address.split('.')
+      quad_str = quads.map { |q| q.to_i.to_s(16).rjust(2,'0') }.join('')
+      "ip-#{quad_str}"
+    end
+
+    def show_env
+      data = []
+      ec2.instances.with_tag("Name", "*-#{environment}").each do |i|
+        next unless i.status == :running
+
+        tokens = []
+        tokens << i.tags.Name
+        tokens << i.private_ip_address
+        tokens << windows_name(i.private_ip_address)
+        if i.platform == "windows"
+          tokens << windows_password(i.id, File.read(private_key_file))
+        else
+          tokens << ""
+        end
+
+        data << tokens
+      end
+
+      return if data.empty?
+
+      # find longest name tag
+      max_name_size = data.max_by {|i| i[0].size }.first.size
+      data.map {|i| i[0] = i[0].ljust(max_name_size) }
+
+      data.each do |i|
+        puts i.join("\t")
+      end
+    end
+  end
+end