orchestration 0.1.0 → 0.2.0

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+      class Configuration
+        attr_reader :adapter, :settings
+
+        def initialize(env)
+          @env = env
+          @adapter = nil
+          @settings = nil
+          return unless defined?(ActiveRecord)
+          return unless File.exist?(@env.database_configuration_path)
+
+          setup
+        end
+
+        def friendly_config
+          adapter = @settings['adapter']
+          host = @settings['host']
+          port = @settings['port']
+          return "[#{adapter}]" if adapter == 'sqlite3'
+          return "[#{adapter}] #{host}" unless port.present?
+
+          "[#{adapter}] #{host}:#{port}"
+        end
+
+        private
+
+        def setup
+          environments = parse(File.read(@env.database_configuration_path))
+          base = base_config(environments)
+          @adapter = adapter_object(base['adapter'])
+          @settings = base.merge(@adapter.credentials)
+          @settings.merge!(default_port) unless @settings.key?('port')
+        end
+
+        def parse(content)
+          yaml(erb(content))
+        end
+
+        def erb(content)
+          ERB.new(content).result
+        end
+
+        def yaml(content)
+          YAML.safe_load(content, [], [], true) # true: Allow aliases
+        end
+
+        def adapter_object(name)
+          {
+            'mysql2' => adapters::Mysql2,
+            'postgresql' => adapters::Postgresql,
+            'sqlite3' => adapters::Sqlite3
+          }.fetch(name).new
+        end
+
+        def base_config(environments)
+          missing_default unless environments.key?('default')
+
+          host = url_config['host'] || environments[@env.environment]['host']
+
+          environments
+            .fetch('default')
+            .merge(url_config)
+            .merge('host' => host)
+        end
+
+        def adapters
+          Orchestration::Services::Database::Adapters
+        end
+
+        def default_port
+          return {} if @adapter.is_a?(adapters::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' => adapter_name_from_scheme(uri.scheme),
+            'port' => uri.port
+          }.merge(query_params(uri))
+        end
+
+        def adapter_name_from_scheme(scheme)
+          return 'mysql2' if scheme == 'mysql'
+          return 'postgresql' if scheme == 'postgres'
+          return 'sqlite3' if scheme == 'sqlite3'
+
+          raise ArgumentError,
+                I18n.t('orchestration.unknown_scheme', scheme: scheme)
+        end
+
+        def query_params(uri)
+          return {} if uri.query.nil?
+
+          Hash[URI.decode_www_form(uri.query)]
+        end
+
+        def missing_default
+          raise DatabaseConfigurationError,
+                I18n.t('orchestration.database.missing_default')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+      class Healthcheck
+        include HealthcheckBase
+
+        def initialize(env)
+          @configuration = Configuration.new(env)
+        end
+
+        def connect
+          ActiveRecord::Base.establish_connection(@configuration.settings)
+          ActiveRecord::Base.connection
+        end
+
+        def connection_errors
+          [ActiveRecord::ConnectionNotEstablished].concat(adapter_errors)
+        end
+
+        private
+
+        def adapter_errors
+          @configuration.adapter.errors
+        end
+      end
+    end
+  end
+end

data/lib/orchestration/services/database.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+    end
+  end
+end
+
+require 'erb'
+require 'uri'
+
+require 'orchestration/services/database/adapters'
+require 'orchestration/services/database/configuration'
+require 'orchestration/services/database/healthcheck'

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Mongo
+      class Configuration
+        attr_reader :settings
+
+        def initialize(env)
+          @env = env
+          @settings = nil
+          return unless defined?(Mongoid)
+          return unless File.exist?(@env.mongoid_configuration_path)
+
+          @settings = config.fetch(@env.environment)
+        end
+
+        def ports
+          hosts_and_ports.map { |_host, port| port }
+        end
+
+        def friendly_config
+          hosts_string = hosts_and_ports.map do |host, port|
+            "#{host}:#{port}"
+          end.join(', ')
+
+          "[mongoid] #{hosts_string}"
+        end
+
+        private
+
+        def config
+          YAML.safe_load(
+            File.read(@env.mongoid_configuration_path), [], [], true
+          )
+        end
+
+        def clients
+          # 'sessions' and 'clients' are synonymous but vary between versions of
+          # Mongoid: https://github.com/mongoid/mongoid/commit/657650bc4befa001c0f66e8788e9df6a1af37e84
+          key = @settings.key?('sessions') ? 'sessions' : 'clients'
+
+          @settings.fetch(key)
+        end
+
+        def hosts_and_ports
+          clients.fetch('default').fetch('hosts').map do |host_string|
+            host, _, port = host_string.partition(':')
+            [host, (port.empty? ? PORT : port)]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Mongo
+      class Healthcheck
+        include HealthcheckBase
+
+        def initialize(env)
+          @configuration = Configuration.new(env)
+        end
+
+        def connection_errors
+          [::Mongo::Error::NoServerAvailable]
+        end
+
+        def connect
+          # 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)
+          !Mongoid.default_client.database_names.empty?
+        end
+
+        private
+
+        def clients
+          return Mongoid.sessions if Mongoid.respond_to?(:sessions)
+
+          Mongoid.clients
+        end
+      end
+    end
+  end
+end

data/lib/orchestration/services/mongo.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Mongo
+      PORT = 27_017
+    end
+  end
+end
+
+require 'orchestration/services/mongo/configuration'
+require 'orchestration/services/mongo/healthcheck'

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module RabbitMQ
+      class Configuration
+        attr_reader :settings
+
+        def initialize(env)
+          @env = env
+          @settings = nil
+          return unless defined?(RabbitMQ)
+          return unless File.exist?(@env.rabbitmq_configuration_path)
+
+          @settings = config.fetch(@env.environment)
+          @settings.merge!('port' => PORT) unless @settings.key?('port')
+        end
+
+        def friendly_config
+          host = @settings.fetch('host')
+          port = @settings.fetch('port')
+
+          "[bunny] amqp://#{host}:#{port}"
+        end
+
+        private
+
+        def config
+          YAML.safe_load(
+            File.read(@env.rabbitmq_configuration_path), [], [], true
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module RabbitMQ
+      class Healthcheck
+        include HealthcheckBase
+
+        def initialize(env)
+          @configuration = Configuration.new(env)
+        end
+
+        def connection_errors
+          [
+            Bunny::TCPConnectionFailedForAllHosts,
+            AMQ::Protocol::EmptyResponseError
+          ]
+        end
+
+        def connect
+          host = @configuration.settings.fetch('host')
+          port = @configuration.settings.fetch('port')
+
+          connection = Bunny.new("amqp://#{host}:#{port}", log_file: devnull)
+          connection.start
+          connection.stop
+        end
+
+        private
+
+        def devnull
+          File.open(File::NULL, 'w')
+        end
+      end
+    end
+  end
+end

data/lib/orchestration/services/rabbitmq.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module RabbitMQ
+      PORT = 5672
+    end
+  end
+end
+
+require 'orchestration/services/rabbitmq/configuration'
+require 'orchestration/services/rabbitmq/healthcheck'

data/lib/orchestration/services.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+  end
+end
+
+require 'orchestration/services/database'
+require 'orchestration/services/mongo'
+require 'orchestration/services/rabbitmq'

data/lib/orchestration/settings.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Orchestration
+  class Settings
+    def initialize(path)
+      @path = path
+      @dirty = false
+      @exist = File.exist?(path)
+    end
+
+    def get(identifier)
+      identifier.to_s.split('.').reduce(config) do |result, key|
+        (result || {}).fetch(key)
+      end
+    rescue KeyError
+      nil
+    end
+
+    def set(identifier, val)
+      *keys, setting_key = identifier.to_s.split('.')
+      new_config = config || {}
+      parent = keys.reduce(new_config) { |result, key| result[key] ||= {} }
+      parent[setting_key] = val
+      @dirty ||= config != new_config
+      File.write(@path, new_config.to_yaml)
+    end
+
+    def dirty?
+      @dirty
+    end
+
+    def exist?
+      @exist
+    end
+
+    private
+
+    def config
+      File.write(@path, {}.to_yaml) unless File.exist?(@path)
+      YAML.safe_load(File.read(@path))
+    end
+  end
+end

data/lib/orchestration/templates/Dockerfile.tt

@@ -0,0 +1,11 @@
+FROM ruby:<%= ruby_version %>
+ARG BUNDLE_BITBUCKET__ORG
+RUN apt-get update \
+ && apt-get install -y node.js \
+ && gem install bundler \
+ && mkdir /application
+WORKDIR /application
+COPY Gemfile Gemfile.lock ./
+RUN bundle install --deployment --without development test
+ADD .build/context.tar.gz .
+CMD ["bundle", "exec", "rails", "server", "-p", "3000"]

data/lib/orchestration/templates/Makefile.tt

@@ -0,0 +1,53 @@
+
+# Do not edit this file below this point. Any changes will be overwritten.
+#
+# Example `test` command which will start and wait for all services before
+# running tests:
+#
+# test: start wait
+# 	bundle exec rspec
+# 	yarn test app/javascript
+# 	bundle exec rubocop
+# 	yarn run eslint app/javascript
+#
+.PHONY: docker docker-build docker-push wait-database start
+
+### Container management commands ###
+
+start:
+	docker-compose up -d
+
+stop:
+	docker-compose down
+
+### Service healthcheck commands ###
+
+wait: <%= wait_commands %>
+	@echo "All Containers ready."
+
+wait-database:
+	@RAILS_ENV=test bundle exec rake orchestration:db:wait
+
+wait-mongo:
+	@RAILS_ENV=test bundle exec rake orchestration:mongo:wait
+
+wait-rabbitmq:
+	@RAILS_ENV=test bundle exec rake orchestration:rabbitmq:wait
+
+### Docker build commands ###
+
+docker: docker-build docker-push
+
+docker-build:
+	mkdir -p ./docker/.build
+	git show master:./Gemfile > ./docker/Gemfile
+	git show master:./Gemfile.lock > ./docker/Gemfile.lock
+	git archive --format tar.gz -o docker/.build/context.tar.gz master
+	docker build --build-arg BUNDLE_GITHUB__COM \
+	             --build-arg BUNDLE_BITBUCKET__ORG \
+		     -t $(shell bundle exec rake orchestration:docker:username)/<%= app_id %>:$(shell git rev-parse --short --verify master) \
+		     ./docker/
+
+docker-push: VERSION := $(shell git rev-parse --short --verify master)
+docker-push:
+	docker push $(shell bundle exec rake orchestration:docker:username)/<%= app_id %>:${VERSION}