elastic_beans 0.1.0

data/lib/elastic_beans/dns_entry.rb

@@ -0,0 +1,127 @@
+require "timeout"
+require "elastic_beans/error"
+
+module ElasticBeans
+  class DnsEntry
+    DNS_NAME_PATTERN = /\A[^.]+\.[^.]+\.[^.]+\z/
+
+    attr_reader :name
+
+    def initialize(name, route53:)
+      unless valid_name?(name)
+        raise InvalidDnsName.new(name: name)
+      end
+
+      @name = name
+      @route53 = route53
+    end
+
+    def update(value)
+      unless value
+        raise InvalidDnsValue.new(name: name, value: value)
+      end
+
+      response = route53.change_resource_record_sets(
+        hosted_zone_id: hosted_zone_id,
+        change_batch: {
+          changes: [
+            {
+              action: "UPSERT",
+              resource_record_set: {
+                name: name,
+                type: "CNAME",
+                ttl: 300,
+                resource_records: [{value: value}],
+              },
+            },
+          ],
+        },
+      )
+      begin
+        Timeout.timeout(300) do
+          status = 'PENDING'
+          while status == 'PENDING'
+            sleep 1
+            status = route53.get_change(id: response.change_info.id).change_info.status
+          end
+        end
+      rescue Timeout::Error
+        raise UnhealthyDnsError.new(name: name)
+      end
+    rescue ::Aws::Route53::Errors::InvalidChangeBatch => e
+      raise InvalidDnsValue.new(name: name, value: value, cause: e)
+    end
+
+    private
+
+    attr_reader :route53
+
+    def dns_tld
+      @dns_tld ||= name.sub(/\A[^.]+\./, '')
+    end
+
+    def hosted_zone_id
+      marker = nil
+      loop do
+        response = route53.list_hosted_zones(marker: marker)
+        hosted_zone = response.hosted_zones.find { |hz| hz.name == "#{dns_tld}." }
+        return hosted_zone.id if hosted_zone
+        break unless response.is_truncated
+        marker = response.next_marker
+      end
+      raise MissingHostedZoneError.new(name: name, tld: dns_tld)
+    end
+
+    def valid_name?(name)
+      name && name =~ DNS_NAME_PATTERN
+    end
+
+    class InvalidDnsName < ElasticBeans::Error
+      def initialize(name:)
+        @name = name
+      end
+
+      def message
+        "Invalid DNS name `#{@name}'. Only subdomains are accepted, e.g. 'myapp.example.com'"
+      end
+    end
+
+    class InvalidDnsValue < ElasticBeans::Error
+      include Nesty::NestedError
+
+      def initialize(name:, value:, cause: nil)
+        @name = name
+        @value = value
+        @nested = cause
+      end
+
+      def message
+        msg = "Attempted updating DNS entry `#{@name}' to value `#{@value}', which is not valid."
+        msg << "\nThe error from AWS was \"#{@nested.message}\"" if @nested
+        msg << "\nTry re-running this command:\n    #{command_as_string}"
+        msg
+      end
+    end
+
+    class MissingHostedZoneError < ElasticBeans::Error
+      def initialize(name:, tld:)
+        @name = name
+        @tld = tld
+      end
+
+      def message
+        "Could not find TLD `#{@tld}.' for DNS entry `#{@name}' in Route53"
+      end
+    end
+
+    class UnhealthyDnsError < ElasticBeans::Error
+      def initialize(name:)
+        @name = name
+      end
+
+      def message
+        "DNS entry `#{@name}' is still not updated"
+      end
+    end
+  end
+end

data/lib/elastic_beans/environment/exec.rb

@@ -0,0 +1,23 @@
+module ElasticBeans
+  class Environment
+    class Exec < ElasticBeans::Environment
+      protected
+
+      TEMPLATE_NAME = "exec"
+      TIER_NAME = "Worker"
+      TIER_TYPE = "SQS/HTTP"
+
+      def template_name
+        TEMPLATE_NAME
+      end
+
+      def tier_name
+        TIER_NAME
+      end
+
+      def tier_type
+        TIER_TYPE
+      end
+    end
+  end
+end

data/lib/elastic_beans/environment/scheduler.rb

@@ -0,0 +1,23 @@
+module ElasticBeans
+  class Environment
+    class Scheduler < ElasticBeans::Environment
+      protected
+
+      TEMPLATE_NAME = "scheduler"
+      TIER_NAME = "Worker"
+      TIER_TYPE = "SQS/HTTP"
+
+      def template_name
+        TEMPLATE_NAME
+      end
+
+      def tier_name
+        TIER_NAME
+      end
+
+      def tier_type
+        TIER_TYPE
+      end
+    end
+  end
+end

data/lib/elastic_beans/environment/webserver.rb

@@ -0,0 +1,23 @@
+module ElasticBeans
+  class Environment
+    class Webserver < ElasticBeans::Environment
+      protected
+
+      TEMPLATE_NAME = "webserver"
+      TIER_NAME = "Webserver"
+      TIER_TYPE = "Standard"
+
+      def template_name
+        TEMPLATE_NAME
+      end
+
+      def tier_name
+        TIER_NAME
+      end
+
+      def tier_type
+        TIER_TYPE
+      end
+    end
+  end
+end

data/lib/elastic_beans/environment/worker.rb

@@ -0,0 +1,29 @@
+module ElasticBeans
+  class Environment
+    class Worker < ElasticBeans::Environment
+      attr_reader :queue
+
+      def initialize(name, queue:, **_)
+        super
+        @queue = queue
+      end
+
+      protected
+
+      TIER_NAME = "Worker"
+      TIER_TYPE = "SQS/HTTP"
+
+      def template_name
+        @template_name ||= "worker-#{queue}"
+      end
+
+      def tier_name
+        TIER_NAME
+      end
+
+      def tier_type
+        TIER_TYPE
+      end
+    end
+  end
+end

data/lib/elastic_beans/environment.rb

@@ -0,0 +1,300 @@
+require "timeout"
+require "aws-sdk"
+require "nesty"
+require "elastic_beans/environment/exec"
+require "elastic_beans/environment/scheduler"
+require "elastic_beans/environment/webserver"
+require "elastic_beans/environment/worker"
+require "elastic_beans/error"
+
+module ElasticBeans
+  class Environment
+    TEMPLATE_NAME = "base"
+    TIER_NAME = "Webserver"
+    TIER_TYPE = "Standard"
+    WORKER_TEMPLATE_NAME_PATTERN = /worker-(?<queue>\w+)/
+
+    attr_reader :name
+
+    def self.new_by_type(type, suffix: nil, application:, **args)
+      name = "#{application.name}-#{suffix}"
+      case type
+      when "exec"
+        ElasticBeans::Environment::Exec.new(name, application: application, **args)
+      when "scheduler"
+        ElasticBeans::Environment::Scheduler.new(name, application: application, **args)
+      when "webserver"
+        ElasticBeans::Environment::Webserver.new(name, application: application, **args)
+      when "worker"
+        ElasticBeans::Environment::Worker.new(name, application: application, **args)
+      else
+        raise UnknownEnvironmentType.new(environment_type: type)
+      end
+    end
+
+    def self.new_from_existing(environment, application:, **args)
+      app_name_pattern = /#{Regexp.escape(application.name)}/
+      case environment.environment_name
+      when /\A#{app_name_pattern}-exec\z/
+        ElasticBeans::Environment::Exec.new(environment.environment_name, application: application, **args)
+      when /\A#{app_name_pattern}-scheduler\z/
+        ElasticBeans::Environment::Scheduler.new(environment.environment_name, application: application, **args)
+      when /\A#{app_name_pattern}-webserver\z/
+        ElasticBeans::Environment::Webserver.new(environment.environment_name, application: application, **args)
+      when /\A#{app_name_pattern}-#{WORKER_TEMPLATE_NAME_PATTERN}\z/
+        match = WORKER_TEMPLATE_NAME_PATTERN.match(environment.environment_name)
+        ElasticBeans::Environment::Worker.new(
+          environment.environment_name,
+          application: application,
+          queue: match[:queue],
+          **args,
+        )
+      else
+        case environment.tier.name
+        when "WebServer"
+          ElasticBeans::Environment::Webserver.new(environment.environment_name, application: application, **args)
+        when "Worker"
+          ElasticBeans::Environment::Worker.new(
+            environment.environment_name,
+            application: application,
+            queue: "default",
+            **args,
+          )
+        else
+          raise UnknownEnvironmentType.new(environment_type: environment.tier.name)
+        end
+      end
+    end
+
+    def initialize(name, application:, elastic_beanstalk:, **_)
+      @name = name
+      @application = application
+      @elastic_beanstalk = elastic_beanstalk
+    end
+
+    def create(version:, tags: {})
+      begin
+        elastic_beanstalk.describe_configuration_settings(
+          application_name: application.name,
+          template_name: template_name,
+        ).configuration_settings.empty?
+      rescue ::Aws::ElasticBeanstalk::Errors::InvalidParameterValue
+        raise MissingConfigurationError
+      end
+
+      tags_list = tags.map { |k, v| {key: k, value: v} }
+      elastic_beanstalk.create_environment(
+        application_name: application.name,
+        environment_name: name,
+        tier: {name: tier_name, type: tier_type},
+        template_name: template_name,
+        version_label: version,
+        tags: tags_list,
+      )
+
+      wait_environment(wait_status: "Launching", wait_health_status: ["Unknown", "Pending"])
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    rescue ::Aws::Errors::ServiceError => e
+      raise UnhealthyEnvironmentError.new(
+        environment_name: name,
+        cause: e,
+      )
+    end
+
+    def deploy_version(version_label)
+      elastic_beanstalk.update_environment(
+        environment_name: name,
+        version_label: version_label,
+      )
+
+      wait_environment(wait_status: "Updating", wait_health_status: "Info")
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    rescue ::Aws::Errors::ServiceError => e
+      raise UnhealthyEnvironmentError.new(environment_name: name, cause: e)
+    end
+
+    def update_configuration
+      elastic_beanstalk.update_environment(
+        environment_name: name,
+        template_name: template_name,
+        tier: {name: tier_name, type: tier_type},
+      )
+      wait_environment(wait_status: "Updating", wait_health_status: "Info")
+    rescue ::Aws::ElasticBeanstalk::Errors::InvalidParameterValue
+      raise MissingEnvironmentError.new(environment_name: name)
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    end
+
+    def update_environment(env_vars)
+      new_env_settings = env_vars.map { |k, v|
+        {namespace: "aws:elasticbeanstalk:application:environment", option_name: k, value: v}
+      }
+      elastic_beanstalk.update_environment(
+        environment_name: name,
+        option_settings: new_env_settings,
+      )
+
+      wait_environment(wait_status: "Updating", wait_health_status: "Info")
+    rescue ::Aws::ElasticBeanstalk::Errors::InvalidParameterValue
+      raise MissingEnvironmentError.new(environment_name: name)
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    end
+
+    def cname
+      environment = environment_description
+      unless environment
+        raise MissingEnvironmentError.new(environment_name: name)
+      end
+      environment.cname
+    end
+
+    def status
+      environment = environment_description
+      unless environment
+        raise MissingEnvironmentError.new(environment_name: name)
+      end
+      environment.status
+    end
+
+    protected
+
+    attr_reader :application, :version, :elastic_beanstalk
+
+    def environment_description
+      elastic_beanstalk.describe_environments(
+        environment_names: [name],
+      ).environments.find { |environment|
+        environment.status !~ /Terminat/
+      }
+    rescue ::Aws::ElasticBeanstalk::Errors::Throttling
+      sleep 5
+      retry
+    end
+
+    def template_name
+      TEMPLATE_NAME
+    end
+
+    def tier_name
+      TIER_NAME
+    end
+
+    def tier_type
+      TIER_TYPE
+    end
+
+    def wait_environment(wait_status:, wait_health_status:)
+      wait_status = Array(wait_status)
+      wait_health_status = Array(wait_health_status)
+
+      status = wait_status[0]
+      health = "Grey"
+      health_status = wait_health_status[0]
+      Timeout.timeout(1800) do
+        while wait_status.include?(status) || wait_health_status.include?(health_status)
+          sleep 5
+          environment = environment_description
+          status = environment.status
+          health = environment.health
+          health_status = environment.health_status
+        end
+      end
+
+      # Wait a little bit longer. Sometimes apps are Ready but still Degraded for a few seconds.
+      Timeout.timeout(30) do
+        while status == "Ready" && health != "Green"
+          sleep 5
+          environment = environment_description
+          status = environment.status
+          health = environment.health
+          health_status = environment.health_status
+        end
+      end
+
+      unless status == "Ready" && health == "Green" && (health_status.nil? || health_status == "Ok")
+        raise UnhealthyEnvironmentError.new(
+          environment_name: name,
+          status: status,
+          health: health,
+          health_status: health_status,
+        )
+      end
+    rescue Timeout::Error
+      raise UnhealthyEnvironmentError.new(
+        environment_name: name,
+        status: status,
+        health: health,
+        health_status: health_status,
+      )
+    end
+
+    class MissingConfigurationError < ElasticBeans::Error
+      def message
+        require "elastic_beans/command/configure"
+        <<-MESSAGE
+Some configuration must be set before creating an environment:
+
+* keypair
+* SSL configuration
+* environment variables that Rails always requires
+    * DATABASE_URL
+    * SECRET_KEY_BASE
+
+    #{$0} #{ElasticBeans::Command::Configure::USAGE}
+        MESSAGE
+      end
+    end
+
+    class MissingEnvironmentError < ElasticBeans::Error
+      def initialize(environment_name:)
+        @environment_name = environment_name
+      end
+
+      def message
+        require "elastic_beans/command/create"
+        <<-MESSAGE
+Environment `#{@environment_name}' does not exist. Try creating it!
+
+    #{$0} #{ElasticBeans::Command::Create::USAGE}
+        MESSAGE
+      end
+    end
+
+    class UnhealthyEnvironmentError < ElasticBeans::Error
+      include Nesty::NestedError
+
+      def initialize(environment_name:, status: nil, health: nil, health_status: nil, cause: nil)
+        @environment_name = environment_name
+        @health_status = health_status
+        @health = health
+        @status = status
+        @nested = cause
+      end
+
+      def message
+        msg = "Environment `#{@environment_name}' is not healthy."
+        msg << "\nIt is in '#{@health_status}' ('#{@health}') health with a status of '#{@status}'." if @health || @health_status || @status
+        msg << "\nThe error from AWS was \"#{@nested.message}\"." if @nested
+        msg
+      end
+    end
+
+    class UnknownEnvironmentType < ElasticBeans::Error
+      def initialize(environment_type:)
+        @environment_type = environment_type
+      end
+
+      def message
+        "Unknown environment type `#{@environment_type}'"
+      end
+    end
+  end
+end