convox_installer 1.0.0

data/lib/convox/client.rb

@@ -0,0 +1,402 @@
+# frozen_string_literal: true
+
+require "logger"
+require "json"
+require "fileutils"
+
+module Convox
+  class Client
+    CONVOX_DIR = File.expand_path("~/.convox").freeze
+    AUTH_FILE = File.join(CONVOX_DIR, "auth")
+    HOST_FILE = File.join(CONVOX_DIR, "host")
+
+    attr_accessor :logger, :config
+
+    def auth
+      load_auth_from_file
+    end
+
+    def initialize(options = {})
+      @logger = Logger.new(STDOUT)
+      logger.level = options[:log_level] || Logger::INFO
+      @config = options[:config] || {}
+    end
+
+    def backup_convox_host_and_rack
+      %w[host rack].each do |f|
+        path = File.join(CONVOX_DIR, f)
+        if File.exist?(path)
+          bak_file = "#{path}.bak"
+          logger.info "Moving existing #{path} to #{bak_file}..."
+          FileUtils.mv(path, bak_file)
+        end
+      end
+    end
+
+    def install_convox
+      require_config(%i[ aws_region stack_name ])
+      region = config.fetch(:aws_region)
+      stack_name = config.fetch(:stack_name)
+
+      if rack_already_installed?
+        logger.info "There is already a Convox stack named #{stack_name} " \
+                    "in the #{region} AWS region. Using this rack. "
+        return true
+      end
+
+      require_config(%i[
+        aws_region
+        aws_access_key_id
+        aws_secret_access_key
+        stack_name
+        instance_type
+      ])
+
+      logger.info "Installing Convox (#{stack_name})..."
+
+      env = {
+        "AWS_REGION" => region,
+        "AWS_ACCESS_KEY_ID" => config.fetch(:aws_access_key_id),
+        "AWS_SECRET_ACCESS_KEY" => config.fetch(:aws_secret_access_key),
+      }
+      command = %Q{rack install aws \
+--name "#{config.fetch(:stack_name)}" \
+"InstanceType=#{config.fetch(:instance_type)}" \
+"BuildInstance="}
+
+      run_convox_command!(command, env)
+    end
+
+    def rack_already_installed?
+      require_config(%i[ aws_region stack_name ])
+
+      unless File.exist?(AUTH_FILE)
+        raise "Could not find auth file at #{AUTH_FILE}!"
+      end
+
+      region = config.fetch(:aws_region)
+      stack_name = config.fetch(:stack_name)
+
+      auth.each do |host, password|
+        if host.match?(/^#{stack_name}-\d+\.#{region}\.elb\.amazonaws\.com$/)
+          return true
+        end
+      end
+      false
+    end
+
+    def validate_convox_auth_and_set_host!
+      require_config(%i[ aws_region stack_name ])
+
+      unless File.exist?(AUTH_FILE)
+        raise "Could not find auth file at #{AUTH_FILE}!"
+      end
+
+      region = config.fetch(:aws_region)
+      stack = config.fetch(:stack_name)
+
+      match_count = 0
+      matching_host = nil
+      auth.each do |host, password|
+        if host.match?(/^#{stack}-\d+\.#{region}\.elb\.amazonaws\.com$/)
+          matching_host = host
+          match_count += 1
+        end
+      end
+
+      if match_count == 1
+        set_host(matching_host)
+        return matching_host
+      end
+
+      if match_count > 1
+        error_message = "Found multiple matching hosts for "
+      else
+        error_message = "Could not find matching authentication for "
+      end
+      error_message += "region: #{region}, stack: #{stack}"
+      raise error_message
+    end
+
+    def set_host(host)
+      logger.debug "Setting convox host to #{host} (in #{HOST_FILE})..."
+      File.open(HOST_FILE, "w") { |f| f.puts host }
+    end
+
+    def validate_convox_rack!
+      require_config(%i[
+        aws_region
+        stack_name
+        instance_type
+      ])
+      logger.debug "Validating that convox rack has the correct attributes..."
+      {
+        provider: "aws",
+        region: config.fetch(:aws_region),
+        type: config.fetch(:instance_type),
+        name: config.fetch(:stack_name),
+      }.each do |k, v|
+        convox_value = convox_rack_data[k.to_s]
+        if convox_value != v
+          raise "Convox data did not match! Expected #{k} to be '#{v}', " \
+                "but was: '#{convox_value}'"
+        end
+      end
+      logger.debug "=> Convox rack has the correct attributes."
+      true
+    end
+
+    def convox_rack_data
+      @convox_rack_data ||= begin
+        logger.debug "Fetching convox rack attributes..."
+        convox_output = `convox api get /system`
+        raise "convox command failed!" unless $?.success?
+        JSON.parse(convox_output)
+      end
+    end
+
+    def create_convox_app!
+      require_config(%i[convox_app_name])
+      return true if convox_app_exists?
+
+      app_name = config.fetch(:convox_app_name)
+
+      logger.info "Creating app: #{app_name}..."
+      logger.info "=> Documentation: " \
+                  "https://docs.convox.com/deployment/creating-an-application"
+
+      run_convox_command! "apps create #{app_name} --wait"
+
+      retries = 0
+      loop do
+        break if convox_app_exists?
+        if retries > 5
+          raise "Something went wrong while creating the #{app_name} app! " \
+                "(Please wait a few moments and then restart the installation script.)"
+        end
+        logger.info "Waiting for #{app_name} to be ready..."
+        sleep 3
+        retries += 1
+      end
+
+      logger.info "=> #{app_name} app created!"
+    end
+
+    def set_default_app_for_directory!
+      logger.info "Setting default app in ./.convox/app..."
+      FileUtils.mkdir_p File.expand_path("./.convox")
+      File.open(File.expand_path("./.convox/app"), "w") do |f|
+        f.puts config.fetch(:convox_app_name)
+      end
+    end
+
+    def convox_app_exists?
+      require_config(%i[convox_app_name])
+      app_name = config.fetch(:convox_app_name)
+
+      logger.debug "Looking for existing #{app_name} app..."
+      convox_output = `convox api get /apps`
+      raise "convox command failed!" unless $?.success?
+
+      apps = JSON.parse(convox_output)
+      apps.each do |app|
+        if app["name"] == app_name
+          logger.debug "=> Found #{app_name} app."
+          return true
+        end
+      end
+      logger.debug "=> Did not find #{app_name} app."
+      false
+    end
+
+    # Create the s3 bucket, and also apply a CORS configuration
+    def create_s3_bucket!
+      require_config(%i[s3_bucket_name])
+      bucket_name = config.fetch(:s3_bucket_name)
+      if s3_bucket_exists?
+        logger.info "#{bucket_name} S3 bucket already exists!"
+      else
+        logger.info "Creating S3 bucket resource (#{bucket_name})..."
+        run_convox_command! "rack resources create s3 " \
+                            "--name \"#{bucket_name}\" " \
+                            "--wait"
+
+        retries = 0
+        loop do
+          return if s3_bucket_exists?
+
+          if retries > 10
+            raise "Something went wrong while creating the #{bucket_name} S3 bucket! " \
+                  "(Please wait a few moments and then restart the installation script.)"
+          end
+          logger.debug "Waiting for S3 bucket to be ready..."
+          sleep 3
+          retries += 1
+        end
+
+        logger.debug "=> S3 bucket created!"
+      end
+
+      set_s3_bucket_cors_policy
+    end
+
+    def s3_bucket_exists?
+      require_config(%i[s3_bucket_name])
+      bucket_name = config.fetch(:s3_bucket_name)
+      logger.debug "Looking up S3 bucket resource: #{bucket_name}"
+      `convox api get /resources/#{bucket_name} 2>/dev/null`
+      $?.success?
+    end
+
+    def s3_bucket_details
+      require_config(%i[s3_bucket_name])
+      @s3_bucket_details ||= begin
+        bucket_name = config.fetch(:s3_bucket_name)
+        logger.debug "Fetching S3 bucket resource details for #{bucket_name}..."
+
+        response = `convox api get /resources/#{bucket_name}`
+        raise "convox command failed!" unless $?.success?
+
+        bucket_data = JSON.parse(response)
+        s3_url = bucket_data["url"]
+        matches = s3_url.match(
+          /^s3:\/\/(?<access_key_id>[^:]*):(?<secret_access_key>[^@]*)@(?<bucket_name>.*)$/
+        )
+
+        match_keys = %i[access_key_id secret_access_key bucket_name]
+        unless matches && match_keys.all? { |k| matches[k].present? }
+          raise "#{s3_url} is an invalid S3 URL!"
+        end
+
+        {
+          access_key_id: matches[:access_key_id],
+          secret_access_key: matches[:secret_access_key],
+          name: matches[:bucket_name],
+        }
+      end
+    end
+
+    def set_s3_bucket_cors_policy
+      require_config(%i[aws_access_key_id aws_secret_access_key])
+      access_key_id = config.fetch(:aws_access_key_id)
+      secret_access_key = config.fetch(:aws_secret_access_key)
+
+      unless config.key? :s3_bucket_cors_policy
+        logger.debug "No CORS policy provided in config: s3_bucket_cors_policy"
+        return
+      end
+      cors_policy_string = config.fetch(:s3_bucket_cors_policy)
+
+      bucket_name = s3_bucket_details[:name]
+
+      logger.debug "Looking up existing CORS policy for #{bucket_name}"
+      existing_cors_policy_string =
+        `AWS_ACCESS_KEY_ID=#{access_key_id} \
+        AWS_SECRET_ACCESS_KEY=#{secret_access_key} \
+        aws s3api get-bucket-cors --bucket #{bucket_name} 2>/dev/null`
+      if $?.success? && existing_cors_policy_string.present?
+        # Sort all the nested arrays so that the equality operator works
+        existing_cors_policy = JSON.parse(existing_cors_policy_string)
+        cors_policy_json = JSON.parse(cors_policy_string)
+        [existing_cors_policy, cors_policy_json].each do |policy_json|
+          if policy_json.is_a?(Hash) && policy_json["CORSRules"]
+            policy_json["CORSRules"].each do |rule|
+              rule["AllowedHeaders"].sort! if rule["AllowedHeaders"]
+              rule["AllowedMethods"].sort! if rule["AllowedMethods"]
+              rule["AllowedOrigins"].sort! if rule["AllowedOrigins"]
+            end
+          end
+        end
+
+        if existing_cors_policy == cors_policy_json
+          logger.debug "=> CORS policy is already up to date for #{bucket_name}."
+          return
+        end
+      end
+
+      begin
+        logger.info "Setting CORS policy for #{bucket_name}..."
+
+        File.open("cors-policy.json", "w") { |f| f.puts cors_policy_string }
+
+        `AWS_ACCESS_KEY_ID=#{access_key_id} \
+        AWS_SECRET_ACCESS_KEY=#{secret_access_key} \
+          aws s3api put-bucket-cors \
+          --bucket #{bucket_name} \
+          --cors-configuration "file://cors-policy.json"`
+        unless $?.success?
+          raise "Something went wrong while setting the S3 bucket CORS policy!"
+        end
+        logger.info "=> Successfully set CORS policy for #{bucket_name}."
+      ensure
+        FileUtils.rm_f "cors-policy.json"
+      end
+    end
+
+    def add_docker_registry!
+      require_config(%i[docker_registry_url docker_registry_username docker_registry_password])
+
+      registry_url = config.fetch(:docker_registry_url)
+
+      logger.debug "Looking up existing Docker registries..."
+      registries_response = `convox api get /registries`
+      unless $?.success?
+        raise "Something went wrong while fetching the list of registries!"
+      end
+      registries = JSON.parse(registries_response)
+
+      if registries.any? { |r| r["server"] == registry_url }
+        logger.debug "=> Docker Registry already exists: #{registry_url}"
+        return true
+      end
+
+      logger.info "Adding Docker Registry: #{registry_url}..."
+      logger.info "=> Documentation: " \
+                  "https://docs.convox.com/deployment/private-registries"
+
+      `convox registries add "#{registry_url}" \
+        "#{config.fetch(:docker_registry_username)}" \
+        "#{config.fetch(:docker_registry_password)}"`
+      unless $?.success?
+        raise "Something went wrong while adding the #{registry_url} registry!"
+      end
+    end
+
+    def default_service_domain_name
+      require_config(%i[convox_app_name default_service])
+
+      @default_service_domain_name ||= begin
+        convox_domain = convox_rack_data["domain"]
+        elb_name_and_region = convox_domain[/([^\.]*\.[^\.]*)\..*/, 1]
+        unless elb_name_and_region.present?
+          raise "Something went wrong while parsing the ELB name and region! " \
+                "(#{elb_name_and_region})"
+        end
+        app = config.fetch(:convox_app_name)
+        service = config.fetch(:default_service)
+
+        "#{app}-#{service}.#{elb_name_and_region}.convox.site"
+      end
+    end
+
+    def run_convox_command!(cmd, env = {})
+      command = "convox #{cmd}"
+      system env, command
+      raise "Error running: #{command}" unless $?.success?
+    end
+
+    private
+
+    def load_auth_from_file
+      return {} unless File.exist?(AUTH_FILE)
+
+      JSON.parse(File.read(AUTH_FILE))
+    end
+
+    def require_config(required_keys)
+      required_keys.each do |k|
+        raise "#{k} is missing from the config!" unless config[k]
+      end
+    end
+  end
+end

data/lib/convox.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "convox/client"

data/lib/convox_installer/config.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "highline"
+require "fileutils"
+require "json"
+require "securerandom"
+
+module ConvoxInstaller
+  class Config
+    attr_accessor :logger, :config, :prompts, :highline
+
+    CONFIG_FILE = File.expand_path("~/.convox/installer_config").freeze
+
+    DEFAULT_PROMPTS = [
+      {
+        key: :stack_name,
+        title: "Convox Stack Name",
+        prompt: "Please enter a name for your Convox installation",
+        default: "convox",
+      },
+      {
+        key: :aws_region,
+        title: "AWS Region",
+        default: "us-east-1",
+      },
+      {
+        key: :instance_type,
+        title: "EC2 Instance Type",
+        default: "t3.medium",
+      },
+      {
+        section: "Admin AWS Credentials",
+      },
+      {
+        key: :aws_access_key_id,
+        title: "AWS Access Key ID",
+      },
+      {
+        key: :aws_secret_access_key,
+        title: "AWS Secret Access Key",
+      },
+    ].freeze
+
+    def initialize(options = {})
+      @logger = Logger.new(STDOUT)
+      logger.level = options[:log_level] || Logger::INFO
+
+      self.prompts = options[:prompts] || DEFAULT_PROMPTS
+      self.config = {}
+      load_config_from_file
+      load_config_from_env
+      self.config = config.merge((options[:config] || {}).symbolize_keys)
+
+      self.highline = options[:highline] || HighLine.new
+    end
+
+    def config_keys
+      prompts.map { |prompt| prompt[:key] }.compact.map(&:to_sym)
+    end
+
+    def prompt_for_config
+      loop do
+        prompts.each do |prompt|
+          if prompt[:section]
+            highline.say "\n#{prompt[:section]}"
+            highline.say "============================================\n\n"
+          end
+          next unless prompt[:key]
+
+          ask_prompt(prompt)
+        end
+
+        show_config_summary
+
+        @completed_prompt = true
+
+        highline.say "Please double check all of these configuration details."
+
+        agree = highline.agree(
+          "Would you like to start the Convox installation?" \
+          " (press 'n' to correct any settings)"
+        )
+        break if agree
+        highline.say "\n"
+      end
+
+      config
+    end
+
+    def show_config_summary
+      highline.say "\n============================================"
+      highline.say "                 SUMMARY"
+      highline.say "============================================\n\n"
+
+      config_titles = prompts.map do |prompt|
+        prompt[:title] || prompt[:key]
+      end.compact
+      max = config_titles.map(&:length).max
+
+      prompts.each do |prompt|
+        next if !prompt[:key] || prompt[:hidden]
+
+        value = config[prompt[:key]]
+        title = prompt[:title] || prompt[:key]
+        padded_key = "#{title}:".ljust(max + 3)
+        highline.say "    #{padded_key} #{value}"
+      end
+      highline.say "\nWe've saved your configuration to: #{CONFIG_FILE}"
+      highline.say "If anything goes wrong during the installation, " \
+                   "you can restart the script to reload the config and continue.\n\n"
+    end
+
+    private
+
+    def ask_prompt(prompt)
+      key = prompt[:key]
+      title = prompt[:title] || key
+
+      # If looping through the config again, ask for all
+      # the config with defaults.
+      if config[key] && !@completed_prompt
+        logger.debug "Found existing config for #{key} => #{config[key]}"
+        return
+      end
+
+      # Used when we want to force a default value and not prompt the user.
+      # (e.g. securely generated passwords)
+      if prompt[:value]
+        return if config[key]
+
+        default = prompt[:value]
+        config[key] = default.is_a?(Proc) ? default.call : default
+        save_config_to_file
+        return
+      end
+
+      prompt_string = prompt[:prompt] || "Please enter your #{title}: "
+
+      config[key] = highline.ask(prompt_string) do |q|
+        if @completed_prompt
+          q.default = config[key]
+        elsif prompt[:default]
+          q.default = prompt[:default]
+        end
+        q.validate = /.+/
+      end
+
+      save_config_to_file
+    end
+
+    def load_config_from_file
+      return unless Config.config_file_exists?
+
+      logger.debug "Loading saved config from #{CONFIG_FILE}..."
+
+      loaded_config = JSON.parse(Config.read_config_file)["config"].symbolize_keys
+      self.config = config.merge(loaded_config).slice(*config_keys)
+    end
+
+    def load_config_from_env
+      config_keys.each do |key|
+        env_key = key.to_s.upcase
+        value = ENV[env_key]
+        next unless value.present?
+
+        logger.debug "Found value for #{key} in env var: #{env_key} => #{value}"
+        config[key] = value
+      end
+    end
+
+    def save_config_to_file
+      FileUtils.mkdir_p File.expand_path("~/.convox")
+      File.open(CONFIG_FILE, "w") do |f|
+        f.puts({config: config}.to_json)
+      end
+    end
+
+    def self.config_file_exists?
+      File.exist?(CONFIG_FILE)
+    end
+
+    def self.read_config_file
+      File.read(CONFIG_FILE)
+    end
+  end
+end

data/lib/convox_installer/requirements.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "highline"
+require "os"
+require "logger"
+
+module ConvoxInstaller
+  class Requirements
+    attr_accessor :ecr_label, :logger
+
+    def initialize(options = {})
+      @ecr_label = options[:ecr_label]
+      @logger = Logger.new(STDOUT)
+      logger.level = options[:log_level] || Logger::INFO
+    end
+
+    def ensure_requirements!
+      logger.debug "Checking for required commands..."
+
+      @missing_packages = []
+      unless has_command? "convox"
+        @missing_packages << {
+          name: "convox",
+          brew: "convox",
+          docs: "https://docs.convox.com/introduction/installation",
+        }
+      end
+
+      unless has_command? "aws"
+        @missing_packages << {
+          name: "aws",
+          brew: "awscli",
+          docs: "https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html",
+        }
+      end
+
+      if @missing_packages.any?
+        logger.error "This script requires the convox and AWS CLI tools."
+        if OS.mac?
+          logger.error "Please run: brew install " \
+                       "#{@missing_packages.map { |p| p[:brew] }.join(" ")}"
+        else
+          logger.error "Installation Instructions:"
+          @missing_packages.each do |package|
+            logger.error "* #{package[:name]}: #{package[:docs]}"
+          end
+        end
+        quit!
+      end
+    end
+
+    def has_command?(command)
+      path = find_command command
+      if path.present?
+        logger.debug "=> Found #{command}: #{path}"
+        return true
+      end
+      logger.debug "=> Could not find #{command}!"
+      false
+    end
+
+    # Stubbed in tests
+    def find_command(command)
+      `which #{command} 2>/dev/null`.chomp
+    end
+
+    def quit!
+      exit 1
+    end
+  end
+end

data/lib/convox_installer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ConvoxInstaller
+  VERSION = '1.0.0'
+end