automan 2.1.2

data/lib/automan/beanstalk/deployer.rb

@@ -0,0 +1,193 @@
+require 'automan'
+require 'pathname'
+require 'logger'
+require 'json'
+
+module Automan::Beanstalk
+  class Deployer < Automan::Base
+    add_option :name,
+               :version_label,
+               :package,
+               :environment,
+               :manifest,
+               :configuration_template,
+               :configuration_options,
+               :solution_stack_name,
+               :number_to_keep,
+               :beanstalk_name
+
+    include Automan::Mixins::Utils
+
+    def initialize(options=nil)
+      @number_to_keep = 0
+      super
+    end
+
+    def manifest_exists?
+      s3_object_exists? manifest
+    end
+
+    def read_manifest
+
+      if !manifest_exists?
+        raise MissingManifestError, "Manifest #{manifest} does not exist"
+      end
+
+      # read manifest from s3 location
+      json = s3_read(manifest)
+
+      # parse it from json
+      data = JSON.parse json
+
+      # set version_label and package
+      self.version_label = data['version_label']
+      self.package       = data['package']
+    end
+
+    def package_exists?
+      s3_object_exists? package
+    end
+
+    def eb_environment_name
+      # Constraint: Must be from 4 to 23 characters in length.
+      # The name can contain only letters, numbers, and hyphens.
+      # It cannot start or end with a hyphen.
+      env_name = "#{name}-#{environment}"
+      unless beanstalk_name.nil?
+        env_name = beanstalk_name.dup
+      end
+
+      if env_name.length > 23
+        env_name = env_name[0,23]
+      end
+
+      env_name.gsub!(/[^A-Za-z0-9\-]/, '-')
+
+      env_name.gsub!(/(^\-+)|(\-+$)/, '')
+
+      if env_name.length < 4
+        env_name += "-Env"
+      end
+
+      env_name
+    end
+
+    # Possible status states:
+    # Launching
+    # Updating
+    # Ready
+    # Terminating
+    # Terminated
+    def environment_status
+      opts = {
+        environment_names: [eb_environment_name]
+      }
+
+      response = eb.describe_environments opts
+
+      unless response.successful?
+        logger.error "describe_environments failed: #{response.error}"
+        exit 1
+      end
+
+      status = nil
+      response.data[:environments].each do |env|
+        if env[:environment_name] == eb_environment_name
+          status = env[:status]
+          break
+        end
+      end
+      status
+    end
+
+    def update_environment
+      logger.info "updating environment #{eb_environment_name} with version #{version_label}"
+
+      opts = {
+        environment_name: eb_environment_name,
+        version_label:    version_label
+      }
+
+      response = eb.update_environment opts
+
+      unless response.successful?
+        logger.error "update_environment failed: #{response.error}"
+        exit 1
+      end
+
+    end
+
+    def create_environment
+      logger.info "creating environment #{eb_environment_name} for #{name} with version #{version_label}"
+
+      opts = {
+        application_name: name,
+        environment_name: eb_environment_name,
+        version_label:    version_label,
+        template_name:    configuration_template,
+        cname_prefix:     eb_environment_name
+      }
+
+      response = eb.create_environment opts
+
+      unless response.successful?
+        logger.error "create_environment failed: #{response.error}"
+        exit 1
+      end
+
+    end
+
+    def get_version
+      v = Automan::Beanstalk::Version.new
+      v.application = name
+      v.label = version_label
+      v
+    end
+
+    def ensure_version_exists
+      version = get_version()
+
+      if version.exists?
+        logger.warn "version #{version_label} for #{name} already exists. Not creating."
+      else
+        version.create(package)
+
+        if number_to_keep > 0
+          version.cull_versions(number_to_keep)
+        end
+      end
+    end
+
+    def create_or_update_environment
+      case environment_status
+      when nil, "Terminated"
+        create_environment
+      when "Ready"
+        update_environment
+      else
+        raise InvalidEnvironmentStatusError, "Could not update environment as it's status is #{environment_status}"
+      end
+    end
+
+    def deploy
+      logger.info "Deploying service."
+
+      if !manifest.nil?
+        read_manifest
+      end
+
+      log_options
+
+      unless package_exists?
+        raise MissingPackageFileError, "package #{package} does not exist."
+      end
+
+      ensure_version_exists
+
+      create_or_update_environment
+
+      logger.info "Finished deploying service."
+    end
+
+  end
+end

data/lib/automan/beanstalk/errors.rb

@@ -0,0 +1,22 @@
+module Automan::Beanstalk
+  class RequestFailedError < StandardError
+  end
+
+  class ELBNameNotFoundError < StandardError
+  end
+
+  class MissingManifestError < StandardError
+  end
+
+  class MissingPackageFileError < StandardError
+  end
+
+  class InvalidEnvironmentStatusError < StandardError
+  end
+
+  class NoConfigurationTemplatesError < StandardError
+  end
+
+  class InvalidConfigurationTemplateError < StandardError
+  end
+end

data/lib/automan/beanstalk/package.rb

@@ -0,0 +1,39 @@
+require 'automan'
+require 'pathname'
+require 'json'
+
+module Automan::Beanstalk
+  class Package < Automan::Base
+    add_option :destination, :source, :manifest, :version_label
+
+    include Automan::Mixins::Utils
+
+    def upload_package
+      log_options
+
+      # verify local package exists
+      unless File.exists? source
+        raise MissingPackageFile, "package file #{source} does not exist"
+      end
+
+      logger.info "Uploading #{source} to #{destination}"
+
+      # upload package file
+      bucket, key = parse_s3_path destination
+      s3.buckets[bucket].objects[key].write(Pathname.new(source))
+
+      # upload manifest file
+      if !manifest.nil?
+        logger.info "Uploading manifest file for #{version_label} to #{manifest}"
+        contents = {
+          "version_label" => version_label,
+          "package" => destination
+        }.to_json
+
+        bucket, key = parse_s3_path manifest
+        s3.buckets[bucket].objects[key].write(contents)
+      end
+
+    end
+  end
+end

data/lib/automan/beanstalk/router.rb

@@ -0,0 +1,102 @@
+require 'automan'
+require 'wait'
+
+module Automan::Beanstalk
+  class Router < Automan::Base
+
+    add_option :environment_name,
+               :hosted_zone_name,
+               :hostname
+
+    attr_accessor :attempts_made
+
+    def initialize(options=nil)
+      super
+      @wait = Wait.new({
+        attempts: 10,
+        delay:    60,   # 10 x 60s == 10m
+        debug:    true,
+        logger:   @logger,
+
+        # rescue from InvalidChangeBatch
+        # just because we've found the elb cname doesn't
+        # mean it is immediately available as a route53 alias
+        rescuer:  WaitRescuer.new(AWS::Route53::Errors::InvalidChangeBatch)
+      })
+    end
+
+    def elb_cname_from_beanstalk_environment(env_name)
+      opts = {
+        environment_name: env_name
+      }
+      response = eb.describe_environment_resources opts
+
+      unless response.successful?
+        raise RequestFailedError, "describe_environment_resources failed: #{response.error}"
+      end
+
+      balancers = response.data[:environment_resources][:load_balancers]
+      if balancers.empty?
+        return nil
+      end
+
+      balancers.first[:name]
+    end
+
+    # be sure alias_name ends in period
+    def update_dns_alias(zone_name, alias_name, elb_data)
+      zone = r53.hosted_zones.select {|z| z.name == zone_name}.first
+      rrset = zone.rrsets[alias_name, 'A']
+
+      target = elb_data.dns_name.downcase
+
+      if rrset.exists?
+        if rrset.alias_target[:dns_name] == target + '.'
+          logger.info "record exists: #{alias_name} -> #{rrset.alias_target[:dns_name]}"
+          return
+        else
+          logger.info "removing old record #{alias_name} -> #{rrset.alias_target[:dns_name]}"
+          rrset.delete
+        end
+      end
+
+      logger.info "creating record #{alias_name} -> #{target}"
+      zone.rrsets.create(
+        alias_name,
+        'A',
+        alias_target: {
+          hosted_zone_id: elb_data.canonical_hosted_zone_name_id,
+          dns_name:       target,
+          evaluate_target_health: false
+        }
+      )
+    end
+
+    def run
+      log_options
+
+      wait.until do |attempt|
+
+        self.attempts_made = attempt
+
+        logger.info "waiting for elb cname..."
+        elb_name = elb_cname_from_beanstalk_environment environment_name
+
+        if elb_name.nil?
+          false
+        else
+
+          elb_data = elb.load_balancers[elb_name]
+
+          update_dns_alias(
+            hosted_zone_name,
+            hostname,
+            elb_data
+          )
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/automan/beanstalk/terminator.rb

@@ -0,0 +1,60 @@
+require 'automan'
+
+module Automan::Beanstalk
+  class Terminator < Automan::Base
+    add_option :name
+
+    def environment_exists?(environment_name)
+      opts = {
+        environment_names: [ environment_name ]
+      }
+
+      response = eb.describe_environments opts
+
+      unless response.successful?
+        raise RequestFailedError "describe_environments failed: #{response.error}"
+      end
+
+      response.data[:environments].each do |e|
+        if e[:environment_name] == environment_name
+          logger.debug "#{environment_name} has status: #{e[:status]}"
+
+          case e[:status]
+          when 'Terminated', 'Terminating'
+            return false
+          else
+            return true
+          end
+
+        end
+      end
+
+      false
+    end
+
+    def terminate_environment
+      logger.info "terminating environment #{name}"
+
+      opts = {
+        environment_name: name
+      }
+
+      response = eb.terminate_environment opts
+
+      unless response.successful?
+        raise RequestFailedError "terminate_environment failed: #{response.error}"
+      end
+    end
+
+    def terminate
+      log_options
+
+      if !environment_exists?(name)
+        logger.warn "Environment #{name} does not exist. Doing nothing."
+        return
+      end
+
+      terminate_environment
+    end
+  end
+end

data/lib/automan/beanstalk/uploader.rb

@@ -0,0 +1,58 @@
+require 'automan'
+require 'json'
+
+module Automan::Beanstalk
+  class Uploader < Automan::Base
+    add_option :template_files, :s3_path
+
+    def config_templates
+      Dir.glob template_files
+    end
+
+    def read_config_template(file)
+      File.read file
+    end
+
+    def config_templates_valid?
+      valid = true
+      templates = config_templates
+
+      if templates.empty?
+        raise NoConfigurationTemplatesError, "No configuration template files found for #{template_files}"
+      end
+
+      templates.each do |template|
+        raw = read_config_template template
+        begin
+          JSON.parse(raw)
+        rescue Exception => e
+          logger.warn "#{template} is invalid json: #{e.message}"
+          valid = false
+          next
+        end
+        logger.debug "#{template} is valid json"
+      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_config_templates
+      unless config_templates_valid?
+        raise InvalidConfigurationTemplateError, "There are invalid configuration templates. Halting upload."
+      end
+
+      config_templates.each do |template|
+        upload_file(template)
+      end
+    end
+  end
+end