orchestration 0.3.17 → 0.4.0

data/lib/orchestration/docker_compose/app_service.rb

@@ -8,41 +8,112 @@ module Orchestration
         @config = config
       end
 
+      class << self
+        def command
+          server = env.web_server
+          %w[bundle exec] + case env.web_server
+                            when 'puma'
+                              %w[puma -C config/puma.rb]
+                            when 'unicorn'
+                              %w[unicorn -c config/unicorn.rb]
+                            else
+                              unsupported_web_server(server)
+                            end
+        end
+
+        def entrypoint
+          ["/app/#{orchestration}/entrypoint.sh"]
+        end
+
+        def healthcheck
+          {
+            'test' => ['ruby', "/app/#{orchestration}/healthcheck.rb"],
+            # Defaults according to
+            # https://docs.docker.com/engine/reference/builder/#healthcheck
+            # Except start_period which cannot be set to 0s
+            'interval' => '30s',
+            'timeout' => '30s',
+            'start_period' => '5s',
+            'retries' => 3
+          }
+        end
+
+        private
+
+        def orchestration
+          env.orchestration_dir_name
+        end
+
+        def env
+          @env ||= Environment.new
+        end
+
+        def unsupported_web_server(server)
+          raise ArgumentError,
+                I18n.t(
+                  'orchestration.rake.app.unspported_web_server',
+                  server: server,
+                  expected: %w[puma unicorn]
+                )
+        end
+      end
+
       def definition
         {
           'image' => image,
           'environment' => environment,
-          'ports' => ports
+          'ports' => ports,
+          'deploy' => deploy,
+          'logging' => logging
         }
       end
 
       private
 
       def image
-        '${DOCKER_ORGANIZATION}/${DOCKER_REPOSITORY}'
+        '${DOCKER_ORGANIZATION}/${DOCKER_REPOSITORY}:${DOCKER_TAG}'
+      end
+
+      def deploy
+        {
+          'mode' => 'replicated',
+          'replicas' => '${REPLICAS}'
+        }
+      end
+
+      def logging
+        {
+          'driver' => 'json-file',
+          'options' => {
+            'max-size' => '10m',
+            'max-file' => '5'
+          }
+        }
       end
 
       def environment
         {
           'RAILS_LOG_TO_STDOUT' => '1',
           'RAILS_SERVE_STATIC_FILES' => '1',
-          'UNICORN_PRELOAD_APP' => '1',
-          'UNICORN_TIMEOUT' => '60',
-          'UNICORN_WORKER_PROCESSES' => '8'
-        }.merge(inherited_environment)
+          'WEB_PRELOAD_APP' => '1',
+          'WEB_HEALTHCHECK_PATH' => '/'
+        }.merge(Hash[inherited_environment.map { |key| [key, nil] }])
       end
 
       def inherited_environment
-        {
-          'DATABASE_URL' => nil,
-          'HOST_UID' => nil,
-          'RAILS_ENV' => nil,
-          'SECRET_KEY_BASE' => nil
-        }
+        %w[
+          DATABASE_URL
+          HOST_UID
+          RAILS_ENV
+          SECRET_KEY_BASE
+          WEB_CONCURRENCY
+          WEB_TIMEOUT
+          WEB_WORKER_PROCESSES
+        ]
       end
 
       def ports
-        ['${LISTEN_PORT}:8080']
+        ['${CONTAINER_PORT:?CONTAINER_PORT must be provided}:8080']
       end
     end
   end

data/lib/orchestration/docker_compose/compose_configuration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module DockerCompose
+    class ComposeConfiguration
+      def initialize(env)
+        @env = env
+      end
+
+      def services
+        config['services']
+      end
+
+      def database_adapter_name
+        return nil unless defined?(ActiveRecord)
+        return 'postgresql' if defined?(::PG)
+        return 'mysql2' if defined?(::Mysql2)
+        return 'sqlite3' if defined?(::SQLite3)
+
+        nil
+      end
+
+      def database_adapter
+        return nil unless defined?(ActiveRecord)
+
+        base = Orchestration::Services::Database::Adapters
+        return base::Postgresql.new if defined?(::PG)
+        return base::Mysql2.new if defined?(::Mysql2)
+        return base::Sqlite3.new if defined?(::SQLite3)
+
+        nil
+      end
+
+      def local_port(name, remote_port = nil)
+        return nil if ports(name).empty?
+        return ports(name).first[:local].to_i if remote_port.nil?
+
+        ports(name).find { |mapping| mapping[:remote] == remote_port }
+                   .fetch(:local)
+                   .to_i
+      end
+
+      private
+
+      def config
+        @config ||= @env.docker_compose_config
+      end
+
+      def ports(name)
+        services
+          .fetch(name.to_s)
+          .fetch('ports', [])
+          .map do |mapping|
+            next short_format_ports(mapping) if mapping.is_a?(String)
+
+            {
+              local: mapping.fetch('published'),
+              remote: mapping.fetch('target')
+            }
+          end
+      end
+
+      def short_format_ports(mapping)
+        local, _, remote = mapping.partition(':')
+        { local: local, remote: remote }
+      end
+    end
+  end
+end

data/lib/orchestration/docker_compose/database_service.rb

@@ -3,41 +3,43 @@
 module Orchestration
   module DockerCompose
     class DatabaseService
-      # We dictate which port all database services will run on in their
-      # container to simplify port mapping.
-      PORT = 3354
-
       def initialize(config, environment)
         @environment = environment
         @config = config
       end
 
       def definition
-        return nil if @config.settings.nil?
-        return nil if @config.adapter.name == 'sqlite3'
+        return nil unless @config.enabled?
+        return nil if adapter.name == 'sqlite3'
 
         {
-          'image' => @config.adapter.image,
-          'environment' => @config.adapter.environment
+          'image' => adapter.image,
+          'environment' => adapter.environment
         }.merge(ports).merge(volumes)
       end
 
       private
 
-      def volume
-        @config.env.database_volume
+      def adapter
+        name = ComposeConfiguration.new(@environment).database_adapter_name
+        base = 'Orchestration::Services::Database::Adapters'
+        Object.const_get("#{base}::#{name.capitalize}").new
+      end
+
+      def remote_port
+        adapter.default_port
       end
 
       def ports
         return {} unless %i[development test].include?(@environment)
 
-        { 'ports' => ["#{@config.settings.fetch('port')}:#{PORT}"] }
+        { 'ports' => ["#{Orchestration.random_local_port}:#{remote_port}"] }
       end
 
       def volumes
-        return {} unless @environment == :development
+        return {} if @environment == :test
 
-        { 'volumes' => ["#{volume}:#{@config.adapter.data_dir}"] }
+        { 'volumes' => ["#{@config.env.database_volume}:#{adapter.data_dir}"] }
       end
     end
   end

data/lib/orchestration/docker_compose/install_generator.rb

@@ -56,7 +56,8 @@ module Orchestration
       def structure(environment = nil)
         {
           'version' => compose_config(environment).version,
-          'services' => services(environment)
+          'services' => services(environment),
+          'volumes' => volumes(environment)
         }
       end
 
@@ -107,7 +108,7 @@ module Orchestration
       end
 
       def service_enabled?(service_name)
-        return false if configuration(service_name).settings.nil?
+        return false unless configuration(service_name).enabled?
 
         true
       end

data/lib/orchestration/docker_compose/mongo_service.rb

@@ -11,7 +11,7 @@ module Orchestration
       end
 
       def definition
-        return nil if @config.settings.nil?
+        return nil unless @config.enabled?
 
         { 'image' => 'library/mongo' }.merge(ports).merge(volumes)
       end
@@ -30,16 +30,16 @@ module Orchestration
         { 'volumes' => ["#{@config.env.mongo_volume}:/data/db"] }
       end
 
-      def local_port
-        @config.port.nil? ? remote_port : @config.port
-      end
-
       def client
         Services::Mong::Configuration::CONFIG_KEYS.each do |key|
           return @config.settings.fetch(key) if @config.settings.key?(key)
         end
       end
 
+      def local_port
+        Orchestration.random_local_port
+      end
+
       def remote_port
         Orchestration::Services::Mongo::PORT
       end

data/lib/orchestration/docker_compose/rabbitmq_service.rb

@@ -9,7 +9,7 @@ module Orchestration
       end
 
       def definition
-        return nil if @config.settings.nil?
+        return nil unless @config.enabled?
 
         { 'image' => 'library/rabbitmq' }.merge(ports)
       end
@@ -17,10 +17,9 @@ module Orchestration
       def ports
         return {} unless %i[development test].include?(@environment)
 
-        host_port = @config.settings.fetch('port', 5672)
         container_port = Orchestration::Services::RabbitMQ::PORT
 
-        { 'ports' => ["#{host_port}:#{container_port}"] }
+        { 'ports' => ["#{Orchestration.random_local_port}:#{container_port}"] }
       end
     end
   end

data/lib/orchestration/docker_compose.rb

@@ -7,6 +7,7 @@ end
 
 require 'orchestration/docker_compose/install_generator'
 require 'orchestration/docker_compose/configuration'
+require 'orchestration/docker_compose/compose_configuration'
 
 require 'orchestration/docker_compose/app_service'
 require 'orchestration/docker_compose/database_service'

data/lib/orchestration/environment.rb

@@ -12,10 +12,19 @@ module Orchestration
       ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
     end
 
+    def web_server
+      # Used at installation time only
+      ENV.fetch('server', 'puma')
+    end
+
     def database_url
       ENV['DATABASE_URL']
     end
 
+    def mongo_url
+      ENV['MONGO_URL']
+    end
+
     def mongoid_configuration_path
       root.join('config', 'mongoid.yml')
     end
@@ -61,6 +70,14 @@ module Orchestration
       Rails.application.class.parent.name.underscore
     end
 
+    def rabbitmq_url
+      ENV.fetch('RABBITMQ_URL', nil)
+    end
+
+    def app_port
+      ENV.fetch('CONTAINER_PORT', ENV.fetch('WEB_PORT', '3000')).to_i
+    end
+
     def app_name
       settings.get('docker.repository')
     end
@@ -83,16 +100,12 @@ module Orchestration
       'orchestration'
     end
 
-    def public_volume
-      "#{app_name}_public"
-    end
-
     def database_volume
-      "#{app_name}_database"
+      'database'
     end
 
     def mongo_volume
-      "#{app_name}_mongo"
+      'mongo'
     end
   end
 end

data/lib/orchestration/errors.rb

@@ -3,7 +3,7 @@
 module Orchestration
   class OrchestrationError < StandardError; end
 
-  class AppConnectionError < OrchestrationError; end
+  class HTTPConnectionError < OrchestrationError; end
   class DatabaseConfigurationError < OrchestrationError; end
   class MongoConfigurationError < OrchestrationError; end
 

data/lib/orchestration/file_helpers.rb

@@ -30,7 +30,8 @@ module Orchestration
       path.relative_path_from(@env.root).to_s
     end
 
-    def simple_copy(template_name, dest, options = {})
+    def simple_copy(template_name, dest = nil, options = {})
+      dest ||= @env.orchestration_root.join(template_name)
       update_file(
         dest,
         template(template_name, env: @env),
@@ -42,8 +43,10 @@ module Orchestration
       relpath = relative_path(path)
       overwrite = options.fetch(:overwrite, true)
       present = File.exist?(path)
-      return @terminal.write(:skip, relpath) if present && !overwrite
+      return @terminal.write(:skip, relpath) if present && !overwrite && !force?
 
+      previous_content = File.read(path) if present
+      backup(path, previous_content) if options.fetch(:backup, false)
       write_file(path, content)
       @terminal.write(:create, relative_path(path))
     end
@@ -52,14 +55,29 @@ module Orchestration
       present = File.exist?(path)
       return create_file(path, content) unless present
 
-      overwrite = options.fetch(:overwrite, true)
       previous_content = File.read(path) if present
-      if present && (!overwrite || previous_content == content)
+      if skip?(present, content, previous_content, options)
         return @terminal.write(:skip, relative_path(path))
       end
 
       File.write(path, content)
       @terminal.write(:update, relative_path(path))
+
+      backup(path, previous_content) if options.fetch(:backup, false)
+    end
+
+    def skip?(present, content, previous_content, options)
+      overwrite = options.fetch(:overwrite, true)
+      return false unless present
+      return true unless overwrite || force?
+
+      previous_content == content
+    end
+
+    def backup(path, previous_content)
+      backup_path = Pathname.new("#{path}.bak")
+      File.write(backup_path, previous_content)
+      @terminal.write(:backup, relative_path(backup_path))
     end
 
     def append_file(path, content, echo: true)
@@ -105,5 +123,10 @@ module Orchestration
       FileUtils.mkdir_p(File.dirname(path))
       File.write(path, content)
     end
+
+    def force?
+      # Rake task was invoked with `force=yes`
+      ENV['force'] == 'yes'
+    end
   end
 end

data/lib/orchestration/install_generator.rb

@@ -4,6 +4,7 @@ require 'thor'
 require 'tempfile'
 
 module Orchestration
+  # rubocop:disable Metrics/ClassLength
   class InstallGenerator < Thor::Group
     include FileHelpers
 
@@ -20,7 +21,7 @@ module Orchestration
       @terminal.ask_setting('docker.organization')
       @terminal.ask_setting('docker.repository', @env.default_app_name)
       relpath = relative_path(path)
-      return @terminal.write(:create, relpath) unless @settings.exist?
+      return @terminal.write(:create, relpath) unless @settings.exist? || force?
       return @terminal.write(:update, relpath) if @settings.dirty?
 
       @terminal.write(:skip, relpath)
@@ -39,10 +40,9 @@ module Orchestration
     end
 
     def dockerfile
-      content = template('Dockerfile', ruby_version: RUBY_VERSION)
       create_file(
         orchestration_dir.join('Dockerfile'),
-        content,
+        dockerfile_content,
         overwrite: false
       )
     end
@@ -64,14 +64,55 @@ module Orchestration
       ensure_lines_in_file(path, entries)
     end
 
+    def docker_compose
+      @docker_compose.docker_compose_yml
+      @docker_compose.docker_compose_test_yml
+      @docker_compose.docker_compose_development_yml
+      @docker_compose.docker_compose_local_yml
+      @docker_compose.docker_compose_production_yml
+      @docker_compose.docker_compose_override_yml
+    end
+
+    def puma
+      return nil unless @env.web_server == 'puma'
+
+      content = template('puma.rb')
+      path = @env.root.join('config', 'puma.rb')
+      create_file(path, content, backup: true)
+    end
+
     def unicorn
+      return nil unless @env.web_server == 'unicorn'
+
       content = template('unicorn.rb')
       path = @env.root.join('config', 'unicorn.rb')
-      create_file(path, content, overwrite: false)
+      create_file(path, content, backup: true)
+    end
+
+    def database_yml
+      return unless defined?(ActiveRecord)
+
+      service_config('database.yml', Services::Database::Configuration)
+    end
+
+    def mongoid_yml
+      return unless defined?(Mongoid)
+
+      service_config('mongoid.yml', Services::Mongo::Configuration)
+    end
+
+    def rabbitmq_yml
+      return unless defined?(Bunny)
+
+      service_config('rabbitmq.yml', Services::RabbitMQ::Configuration)
+    end
+
+    def healthcheck
+      simple_copy('healthcheck.rb')
     end
 
     def yaml_bash
-      simple_copy('yaml.bash', @env.orchestration_root.join('yaml.bash'))
+      simple_copy('yaml.bash')
     end
 
     def env
@@ -79,16 +120,7 @@ module Orchestration
     end
 
     def deploy_mk
-      simple_copy('deploy.mk', @env.orchestration_root.join('deploy.mk'))
-    end
-
-    def docker_compose
-      @docker_compose.docker_compose_yml
-      @docker_compose.docker_compose_test_yml
-      @docker_compose.docker_compose_development_yml
-      @docker_compose.docker_compose_local_yml
-      @docker_compose.docker_compose_production_yml
-      @docker_compose.docker_compose_override_yml
+      simple_copy('deploy.mk')
     end
 
     private
@@ -98,15 +130,48 @@ module Orchestration
     end
 
     def makefile_environment
-      { env: @env, wait_commands: wait_commands }
+      macros = template('makefile_macros.mk', env: @env)
+
+      { env: @env, services: enabled_services, macros: macros }
     end
 
-    def wait_commands
+    def enabled_services
       %i[test development production].map do |environment|
-        @docker_compose.enabled_services(environment).map do |service|
-          "wait-#{service}"
-        end
+        @docker_compose.enabled_services(environment)
       end.flatten.uniq
     end
+
+    def service_config(filename, config_class)
+      content = service_config_content(filename, config_class)
+      path = @env.root.join('config', filename)
+      if path.exist?
+        update_file(path, content, backup: true)
+      else
+        create_file(path, content)
+      end
+    end
+
+    def service_config_content(filename, config_class)
+      template(
+        filename,
+        config: config_class.new(@env),
+        compose: proc do |env|
+          DockerCompose::ComposeConfiguration.new(
+            Environment.new(environment: env)
+          )
+        end
+      )
+    end
+
+    def dockerfile_content
+      template(
+        'Dockerfile',
+        ruby_version: RUBY_VERSION,
+        command: DockerCompose::AppService.command,
+        entrypoint: DockerCompose::AppService.entrypoint,
+        healthcheck: DockerCompose::AppService.healthcheck
+      )
+    end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/orchestration/services/app/configuration.rb

@@ -8,6 +8,10 @@ module Orchestration
 
         self.service_name = 'app'
 
+        def enabled?
+          true
+        end
+
         def initialize(env, service_name = nil)
           super
           @settings = {}
@@ -22,7 +26,7 @@ module Orchestration
         end
 
         def friendly_config
-          "[#{app_name}] #{host}:#{local_port}"
+          "[#{app_name}] #{host}:#{port}"
         end
 
         def database_settings
@@ -40,14 +44,14 @@ module Orchestration
         private
 
         def build_database_url(settings)
-          scheme = settings.fetch('scheme')
+          adapter = settings.fetch('adapter')
           database = settings.fetch('database')
           username = settings.fetch('username')
           password = settings.fetch('password')
-          port = DockerCompose::DatabaseService::PORT
-          host = Database::Configuration.service_name
+          port = settings.fetch('port')
+          host = settings['host'] || Database::Configuration.service_name
 
-          "#{scheme}://#{username}:#{password}@#{host}:#{port}/#{database}"
+          "#{adapter}://#{username}:#{password}@#{host}:#{port}/#{database}"
         end
       end
     end

data/lib/orchestration/services/app/healthcheck.rb

@@ -5,28 +5,7 @@ module Orchestration
     module App
       class Healthcheck
         include HealthcheckBase
-
-        def connect
-          response = Net::HTTP.get_response(
-            URI("http://localhost:#{@configuration.local_port}")
-          )
-          connection_error(response.code) if connection_error?(response.code)
-        end
-
-        def connection_errors
-          [Errno::ECONNREFUSED, AppConnectionError]
-        end
-
-        private
-
-        def connection_error(code)
-          raise AppConnectionError,
-                I18n.t('orchestration.app.connection_error', code: code)
-        end
-
-        def connection_error?(code)
-          %w[502 503 500].include?(code)
-        end
+        include HTTPHealthcheck
       end
     end
   end