orchestration 0.3.17 → 0.4.0

data/lib/orchestration/services/database/adapters/mysql2.rb

@@ -10,6 +10,8 @@ module Orchestration
           end
 
           def image
+            return mysql5_7 if gem_version < Gem::Version.new('0.4')
+
             'library/mysql'
           end
 
@@ -31,14 +33,23 @@ module Orchestration
 
           def environment
             {
-              'MYSQL_ROOT_PASSWORD' => 'password',
-              'MYSQL_TCP_PORT' => DockerCompose::DatabaseService::PORT.to_s
+              'MYSQL_ROOT_PASSWORD' => 'password'
             }
           end
 
           def data_dir
             '/var/lib/mysql'
           end
+
+          private
+
+          def mysql5_7
+            'library/mysql:5.7'
+          end
+
+          def gem_version
+            Gem::Version.new(Gem.loaded_specs['mysql2'].version)
+          end
         end
       end
     end

data/lib/orchestration/services/database/adapters/postgresql.rb

@@ -31,7 +31,6 @@ module Orchestration
 
           def environment
             {
-              'PGPORT' => DockerCompose::DatabaseService::PORT.to_s,
               'POSTGRES_PASSWORD' => 'password',
               'PGDATA' => data_dir
             }

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

@@ -8,114 +8,107 @@ module Orchestration
 
         self.service_name = 'database'
 
-        attr_reader :adapter
+        def enabled?
+          defined?(::ActiveRecord)
+        end
 
-        def initialize(env, service_name = nil)
-          super
-          @adapter = nil
-          @settings = nil
-          return unless defined?(ActiveRecord)
-          return unless File.exist?(@env.database_configuration_path)
+        def friendly_config
+          return "[#{adapter.name}]" if adapter.name == 'sqlite3'
 
-          @environments = parse(File.read(@env.database_configuration_path))
-          setup
+          "[#{adapter.name}] #{host}:#{port}"
         end
 
-        def friendly_config
-          return "[#{@adapter.name}]" if @adapter.name == 'sqlite3'
+        def settings
+          {
+            adapter: adapter.name,
+            host: host,
+            port: port,
+            username: username,
+            password: password,
+            database: database
+          }.transform_keys(&:to_s)
+        end
 
-          "[#{@adapter.name}] #{@settings['host']}:#{@settings['port']}"
+        def adapter
+          url_adapter = url_config['adapter']
+          file_adapter = file_config['adapter']
+
+          return adapter_by_name(url_adapter) unless url_adapter.nil?
+          return adapter_by_name(file_adapter) unless file_adapter.nil?
+          return adapter_by_name('sqlite3') if defined?(SQLite3)
+
+          nil
         end
 
         private
 
-        def setup
-          @adapter = adapter_for(base['adapter'])
-          @settings = merged_settings
-          return if @adapter.name == 'sqlite3'
-          return unless %w[test development].include?(@env.environment)
+        def file_config
+          return {} unless File.exist?(@env.database_configuration_path)
 
-          merge_port
+          yaml = ERB.new(File.read(env.database_configuration_path)).result
+          YAML.safe_load(yaml, [], [], true)[@env.environment] || {}
         end
 
-        def merge_port
-          return if environment.key?('port') || url_config['port']
+        def url_config
+          return {} if env.database_url.nil?
+
+          config = DatabaseUrl.to_active_record_hash(env.database_url)
+                             &.transform_keys(&:to_s)
 
-          @settings.merge!('port' => local_port) if @env.docker_compose_config?
+          # A quirk of DatabaseUrl is that if no "/path" is present then the
+          # `database` component is an empty string. In this unique case, we
+          # want `nil` instead so that we can delegate to a default.
+          config['database'] = nil if config['database']&.empty?
+          config
         end
 
-        def merged_settings
-          port = base['port'] || DockerCompose::DatabaseService::PORT
-          base.merge(@adapter.credentials)
-              .merge('scheme' => base['adapter'], 'port' => port)
+        def host
+          url_config['host'] || file_config['host'] || super
+        end
+
+        def port
+          url_config['port'] || file_config['port'] || super
+        end
+
+        def username
+          (
+            url_config['username'] ||
+            file_config['username'] ||
+            (adapter && adapter.credentials['username'])
+          )
         end
 
-        def parse(content)
-          yaml(erb(content))
+        def password
+          (
+            url_config['password'] ||
+            file_config['password'] ||
+            (adapter && adapter.credentials['password'])
+          )
         end
 
-        def erb(content)
-          ERB.new(content).result
+        def database
+          (
+            url_config['database'] ||
+            file_config['database'] ||
+            (adapter && adapter.credentials['database'])
+          )
         end
 
-        def adapter_for(name)
+        def adapter_by_name(name)
           {
             'mysql2' => adapters::Mysql2,
             'mysql' => adapters::Mysql2,
             'postgresql' => adapters::Postgresql,
             'sqlite3' => adapters::Sqlite3
           }.fetch(name).new
-        end
-
-        def environment
-          @environments.fetch(@env.environment)
         rescue KeyError
-          raise UnknownEnvironmentError,
-                I18n.t(
-                  'orchestration.database.unknown_environment',
-                  environment: @env.environment
-                )
-        end
-
-        def base
-          environment.merge(url_config).merge('host' => host)
-        end
-
-        def host
-          return nil if @adapter && @adapter.name == 'sqlite3'
-          return url_config['host'] if url_config['host']
-          return environment['host'] if environment.key?('host')
-
-          super
+          Orchestration.error('database.unknown_adapter', adapter: name.inspect)
+          raise
         end
 
         def adapters
           Orchestration::Services::Database::Adapters
         end
-
-        def default_port
-          return {} if @adapter.name == 'sqlite3'
-
-          { 'port' => @adapter.default_port }
-        end
-
-        def url_config
-          return {} if @env.database_url.nil?
-
-          uri = URI.parse(@env.database_url)
-
-          {
-            'host' => uri.hostname,
-            'adapter' => uri.scheme,
-            'port' => uri.port
-          }.merge(query_params(uri))
-        end
-
-        def query_params(uri)
-          return {} if uri.query.nil?
-
-          Hash[URI.decode_www_form(uri.query)]
-        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module Orchestration
         dependencies 'active_record'
 
         def connect
-          ActiveRecord::Base.establish_connection(@configuration.settings)
+          ActiveRecord::Base.establish_connection(settings)
           ActiveRecord::Base.connection
         end
 
@@ -22,6 +22,15 @@ module Orchestration
         def adapter_errors
           @configuration.adapter.errors
         end
+
+        def settings
+          return @configuration.settings unless @options[:init]
+
+          {
+            adapter: @configuration.adapter.name,
+            port: DockerCompose::DatabaseService::PORT
+          }.merge(@configuration.adapter.credentials)
+        end
       end
     end
   end

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

@@ -11,7 +11,7 @@ module Orchestration
         end
 
         def friendly_config
-          "[#{@service_name}] #{host}:#{local_port}"
+          "[#{@service_name}] #{host}:#{port}"
         end
       end
     end

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

@@ -7,11 +7,11 @@ module Orchestration
         include HealthcheckBase
 
         def connect
-          Net::HTTP.start('localhost', @configuration.local_port)
+          Net::HTTP.start(@configuration.host, @configuration.port)
         end
 
         def connection_errors
-          [Errno::ECONNREFUSED]
+          [Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL]
         end
       end
     end

data/lib/orchestration/services/{configuration_base.rb → mixins/configuration_base.rb}

@@ -3,7 +3,7 @@
 module Orchestration
   module Services
     module ConfigurationBase
-      attr_reader :settings, :service_name, :env
+      attr_reader :service_name, :env
 
       def self.included(base)
         base.extend(ClassMethods)
@@ -28,20 +28,22 @@ module Orchestration
       end
 
       def host
-        '127.0.0.1'
+        return '127.0.0.1' if %w[test development].include?(@env.environment)
+
+        @service_name
       end
 
-      def local_port
-        return ENV.fetch('LISTEN_PORT', '3000').to_i if @service_name == 'app'
-
-        @env.docker_compose_config
-            .fetch('services')
-            .fetch(@service_name)
-            .fetch('ports')
-            .first
-            .partition(':')
-            .first
-            .to_i
+      def port
+        return @env.app_port if @service_name == 'app'
+
+        local, _, remote = @env.docker_compose_config
+                               .fetch('services')
+                               .fetch(@service_name)
+                               .fetch('ports')
+                               .first
+                               .partition(':')
+
+        (@env.environment == 'production' ? remote : local).to_i
       end
 
       def yaml(content)

data/lib/orchestration/services/{healthcheck_base.rb → mixins/healthcheck_base.rb}

@@ -17,7 +17,7 @@ module Orchestration
           env ||= Environment.new
           terminal ||= Terminal.new(env.settings)
           name = options.delete(:service_name)
-          check = ServiceCheck.new(new(env, name), terminal, options)
+          check = ServiceCheck.new(new(env, name, options), terminal, options)
 
           exit 1 if !check.run && exit_on_error
         end
@@ -35,7 +35,8 @@ module Orchestration
         end
       end
 
-      def initialize(env, service_name = nil)
+      def initialize(env, service_name = nil, options = {})
+        @options = options
         @configuration = configuration_class.new(env, service_name)
       end
 

data/lib/orchestration/services/mixins/http_healthcheck.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module HTTPHealthcheck
+      def connect
+        code = Net::HTTP.get_response(
+          URI("http://#{@configuration.host}:#{@configuration.port}")
+        ).code
+        connection_error(code) if connection_error?(code)
+        connection_error(code) unless connection_success?(code)
+      end
+
+      def connection_errors
+        [Errno::ECONNREFUSED, HTTPConnectionError]
+      end
+
+      private
+
+      def connection_error(code)
+        raise HTTPConnectionError,
+              I18n.t('orchestration.http.connection_error', code: code)
+      end
+
+      def connection_error?(code)
+        %w[502 503 500].include?(code)
+      end
+
+      def connection_success?(_code)
+        # Override if specific success codes needed, otherwise default to true
+        # (i.e. an error code [as defined above] was not returned so we assume
+        # success).
+
+        true
+      end
+    end
+  end
+end

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

@@ -8,95 +8,69 @@ module Orchestration
 
         self.service_name = 'mongo'
 
-        CONFIG_KEYS = %w[clients sessions hosts].freeze
-
-        def initialize(env, service_name = nil)
-          super
-          @settings = nil
-          return unless defined?(Mongoid)
-          return unless File.exist?(@env.mongoid_configuration_path)
-
-          @settings = if clients_key.nil?
-                        hosts_config # Host was configured at top level.
-                      else
-                        { clients_key => hosts_config }
-                      end
+        def enabled?
+          defined?(::Mongoid)
         end
 
         def friendly_config
-          "[mongoid] #{host}:#{port}/#{database}"
+          "[mongoid] mongodb://#{host}:#{port}/#{database}"
         end
 
-        def port
-          return url_config[:port] unless url_config.nil?
+        def database
+          return url_config['database'] unless @env.mongo_url.nil?
 
-          DockerCompose::MongoService::PORT
+          file_config.fetch('database', default_database)
         end
 
         def host
-          return url_config[:host] unless url_config.nil?
+          return url_config['host'] unless @env.mongo_url.nil?
 
           super
         end
 
-        private
+        def port
+          return url_config['port'] unless @env.mongo_url.nil?
 
-        def hosts_config
-          {
-            'default' => {
-              'hosts' => ["#{host}:#{port}"],
-              'database' => database
-            }
-          }
+          super
         end
 
-        def url_config
-          return nil unless ENV.key?('MONGO_URL')
+        private
 
-          host, _, port = ENV['MONGO_URL'].rpartition('/').first.partition(':')
-          _, _, database = ENV['MONGO_URL'].rpartition('/')
-          { host: host, port: port.empty? ? '27017' : port, database: database }
+        def default_database
+          "#{@env.environment}db"
         end
 
-        def database
-          return url_config[:database] unless url_config.nil?
-
-          env_config = config.fetch(@env.environment)
-          return env_config.fetch('database') if env_config.key?('database')
-
-          bad_config_error if clients_key.nil?
-          merged_config(env_config)
-        end
+        def url_config
+          uri = URI.parse(@env.mongo_url)
+          unless uri.scheme == 'mongodb'
+            raise ArgumentError, 'MONGO_URL protocol must be mongodb://'
+          end
 
-        def merged_config(env_config)
-          env_config
-            .fetch(clients_key)
-            .fetch('default')
-            .fetch('database')
+          url_config_structure(uri)
         end
 
-        def clients_key
-          env_config = config.fetch(@env.environment)
+        def url_config_structure(uri)
+          hosts = uri.host.split(',')
+          database = uri.path.partition('/').last
 
-          # Support older Mongoid versions
-          CONFIG_KEYS.each do |key|
-            return key if env_config.key?(key)
-          end
-
-          nil
+          {
+            'user' => uri.user,
+            'password' => uri.password,
+            'host' => hosts.first,
+            'port' => uri.port || Services::Mongo::PORT,
+            'database' => database == '' ? default_database : database
+          }
         end
 
-        def config
-          @config ||= yaml(File.read(@env.mongoid_configuration_path))
-        end
+        def file_config
+          return {} unless File.exist?(@env.mongoid_configuration_path)
+
+          yaml = File.read(@env.mongoid_configuration_path)
+          config = YAML.safe_load(yaml, [], [], true)
+          env = config.fetch(@env.environment, nil)
+          return {} if env.nil?
 
-        def bad_config_error
-          raise ArgumentError,
-                I18n.t(
-                  'orchestration.mongo.bad_config',
-                  path: @env.mongoid_configuration_path,
-                  expected: CONFIG_KEYS.join(', ')
-                )
+          env.fetch('clients', env.fetch('sessions', {})).fetch('default', {})
         end
       end
     end

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

@@ -5,39 +5,10 @@ module Orchestration
     module Mongo
       class Healthcheck
         include HealthcheckBase
+        include HTTPHealthcheck
 
-        dependencies 'mongoid'
-
-        def connection_errors
-          return [Moped::Errors::ConnectionFailure] if defined?(Moped)
-
-          [::Mongo::Error::NoServerAvailable]
-        end
-
-        def connect
-          silence_warnings
-
-          # REVIEW: For some reason this is extremely slow. Worth trying
-          # to see if there's a faster way to fail.
-          Mongoid.load_configuration(@configuration.settings)
-          !default_client.database_names.empty?
-        end
-
-        private
-
-        def default_client
-          return Mongoid.default_client if Mongoid.respond_to?(:default_client)
-
-          # Support older versions of Mongoid
-          Mongoid.default_session
-        end
-
-        def silence_warnings
-          if defined?(Moped)
-            Moped.logger = Logger.new(devnull)
-          else
-            Mongoid.logger = Logger.new(devnull)
-          end
+        def connection_success?(code)
+          code == '200'
         end
       end
     end

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

@@ -8,41 +8,30 @@ module Orchestration
 
         self.service_name = 'rabbitmq'
 
-        def initialize(env, service_name = nil)
-          super
-          @settings = nil
-          return unless defined?(RabbitMQ)
-          return unless File.exist?(@env.rabbitmq_configuration_path)
-
-          if ENV.key?('RABBITMQ_URL')
-            @settings = from_url
-            return
-          end
-
-          @settings = config.fetch(@env.environment)
-          @settings.merge!('port' => PORT) unless @settings.key?('port')
+        def enabled?
+          defined?(::Bunny)
         end
 
         def friendly_config
           "[bunny] amqp://#{host}:#{port}"
         end
 
-        private
-
-        def config
-          yaml(File.read(@env.rabbitmq_configuration_path))
-        end
-
         def host
-          @settings.fetch('host')
+          return from_url['host'] unless @env.rabbitmq_url.nil?
+
+          super
         end
 
         def port
-          @settings.fetch('port')
+          return from_url['port'] unless @env.rabbitmq_url.nil?
+
+          super
         end
 
+        private
+
         def from_url
-          uri = URI.parse(ENV.fetch('RABBITMQ_URL'))
+          uri = URI.parse(@env.rabbitmq_url)
           { 'host' => uri.host, 'port' => uri.port || 5672 }
         end
       end

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

@@ -17,8 +17,8 @@ module Orchestration
         end
 
         def connect
-          host = @configuration.settings.fetch('host')
-          port = @configuration.settings.fetch('port')
+          host = @configuration.host
+          port = @configuration.port
           connection = Bunny.new("amqp://#{host}:#{port}", log_file: devnull)
           connection.start
           connection.stop

data/lib/orchestration/services.rb

@@ -5,8 +5,9 @@ module Orchestration
   end
 end
 
-require 'orchestration/services/configuration_base'
-require 'orchestration/services/healthcheck_base'
+require 'orchestration/services/mixins/configuration_base'
+require 'orchestration/services/mixins/healthcheck_base'
+require 'orchestration/services/mixins/http_healthcheck'
 
 require 'orchestration/services/app'
 require 'orchestration/services/database'

data/lib/orchestration/templates/Dockerfile.erb

@@ -17,8 +17,12 @@ RUN bundle install --without development test --deployment
 COPY .build/package.json .build/yarn.lock ./
 RUN . /root/.bashrc && yarn install
 <% end %>
-COPY entrypoint.sh /
-ADD .build/context.tar.gz .
+ADD .build/context.tar .
 <% if defined?(Webpacker) %>RUN . /root/.bashrc && NODE_ENV=production RAILS_ENV=production yarn install && NODE_ENV=production RAILS_ENV=production SECRET_KEY_BASE=abc123 bundle exec rake assets:precompile<% elsif Rake::Task.tasks.map(&:name).include?('assets:precompile') %>RUN NODE_ENV=production RAILS_ENV=production SECRET_KEY_BASE=abc123 bundle exec rake assets:precompile<% end %>
-ENTRYPOINT ["/entrypoint.sh"]
-CMD ["bundle", "exec", "unicorn", "-c", "/app/config/unicorn.rb"]
+HEALTHCHECK --interval=<%= healthcheck['interval'] %> \
+            --timeout=<%= healthcheck['timeout'] %> \
+            --start-period=<%= healthcheck['start_period'] %> \
+            --retries=<%= healthcheck['retries'] %> \
+            CMD <%= healthcheck['test'].to_json %>
+ENTRYPOINT <%= entrypoint.to_json %>
+CMD <%= command.to_json %>