orchestration 0.1.0 → 0.2.0

data/lib/orchestration/environment.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Orchestration
+  class Environment
+    def initialize(options = {})
+      @environment = options.fetch(:environment, nil)
+    end
+
+    def environment
+      return @environment unless @environment.nil?
+
+      ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+    end
+
+    def database_url
+      ENV['DATABASE_URL']
+    end
+
+    def mongoid_configuration_path
+      root.join('config', 'mongoid.yml')
+    end
+
+    def database_configuration_path
+      root.join('config', 'database.yml')
+    end
+
+    def rabbitmq_configuration_path
+      root.join('config', 'rabbitmq.yml')
+    end
+
+    def orchestration_configuration_path
+      root.join('.orchestration.yml')
+    end
+
+    def application_name
+      Rails.application.class.parent.name.underscore
+    end
+
+    def settings
+      Settings.new(orchestration_configuration_path)
+    end
+
+    def root
+      Rails.root
+    end
+  end
+end

data/lib/orchestration/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Orchestration
+  class OrchestrationError < StandardError; end
+  class DatabaseConfigurationError < OrchestrationError; end
+  class MongoConfigurationError < OrchestrationError; end
+end

data/lib/orchestration/file_helpers.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module FileHelpers
+    private
+
+    def template(template_name, environment = {})
+      Erubis::Eruby.new(read_template(template_name))
+                   .result(environment)
+    end
+
+    def delete_and_inject_after(path, pattern, replacement)
+      return write_file(path, pattern + replacement) unless File.exist?(path)
+
+      input = File.read(path)
+      index = append_index(pattern, input)
+      output = input[0...index] + pattern + replacement
+
+      return @terminal.write(:identical, relative_path(path)) if input == output
+
+      update_file(path, output)
+    end
+
+    def append_index(pattern, input)
+      return 0 if input.empty?
+
+      index = input.index(pattern)
+      index.nil? ? (input.size + 1) : index
+    end
+
+    def relative_path(path)
+      path.relative_path_from(Rails.root).to_s
+    end
+
+    def write_file(path, content, options = {})
+      relpath = relative_path(path)
+      overwrite = options.fetch(:overwrite, true)
+      return @terminal.write(:skip, relpath) if File.exist?(path) && !overwrite
+
+      File.write(path, content)
+      @terminal.write(:create, relative_path(path))
+    end
+
+    def update_file(path, content)
+      File.write(path, content)
+      @terminal.write(:update, relative_path(path))
+    end
+
+    def append_file(path, content, echo: true)
+      return write_file(path, content) unless File.exist?(path)
+
+      File.write(path, content, File.size(path), mode: 'a')
+      @terminal.write(:update, relative_path(path)) if echo
+    end
+
+    def ensure_lines_in_file(path, lines)
+      updated = lines.map do |line|
+        ensure_line_in_file(path, line, echo: false)
+      end.compact
+      relpath = relative_path(path)
+
+      return @terminal.write(:update, relpath) if updated.any?
+
+      @terminal.write(:skip, relpath)
+    end
+
+    def ensure_line_in_file(path, line, echo: true)
+      return if line_in_file?(path, line)
+
+      append_file(path, "\n#{line.chomp}\n", echo: echo)
+      true
+    end
+
+    def line_in_file?(path, line)
+      return false unless File.exist?(path)
+
+      File.readlines(path).map(&:chomp).include?(line.chomp)
+    end
+
+    def templates_path
+      Orchestration.root.join('lib', 'orchestration', 'templates')
+    end
+
+    def read_template(template)
+      File.read(templates_path.join("#{template}.tt"))
+    end
+  end
+end

data/lib/orchestration/healthcheck_base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module HealthcheckBase
+    attr_reader :configuration
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def start(env = nil, terminal = nil)
+        env ||= Environment.new
+        terminal ||= Terminal.new
+        check = ServiceCheck.new(new(env), terminal)
+
+        exit 1 unless check.run
+      end
+    end
+  end
+end

data/lib/orchestration/install_generator.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'tempfile'
+
+module Orchestration
+  class InstallGenerator < Thor::Group
+    include FileHelpers
+
+    def initialize(*_args)
+      super
+      @env = Environment.new(environment: 'test')
+      @terminal ||= Terminal.new
+    end
+
+    def orchestration_configuration
+      path = @env.orchestration_configuration_path
+      settings = Settings.new(path)
+      docker_username(settings)
+      relpath = relative_path(path)
+      return @terminal.write(:create, relpath) unless settings.exist?
+      return @terminal.write(:update, relpath) if settings.dirty?
+
+      @terminal.write(:skip, relpath)
+    end
+
+    def makefile
+      environment = {
+        app_id: @env.application_name,
+        wait_commands: wait_commands
+      }
+      content = template('Makefile', environment)
+      path = @env.root.join('Makefile')
+      delete_and_inject_after(path, "\n#!!orchestration\n", content)
+    end
+
+    def dockerfile
+      docker_dir = Rails.root.join('docker')
+      path = docker_dir.join('Dockerfile')
+      content = template('Dockerfile', ruby_version: RUBY_VERSION)
+      FileUtils.mkdir(docker_dir) unless Dir.exist?(docker_dir)
+      write_file(path, content, overwrite: false)
+    end
+
+    def gitignore
+      path = Rails.root.join('.gitignore')
+      entries = [
+        'docker/.build',
+        'docker/Gemfile',
+        'docker/Gemfile.lock',
+        'docker/*.gemspec'
+      ].map { |entry| "#{entry} # Orchestration" }
+      ensure_lines_in_file(path, entries)
+    end
+
+    def docker_compose
+      path = Rails.root.join('docker-compose.yml')
+      return if File.exist?(path)
+
+      docker_compose = DockerCompose::Services.new(
+        database: configuration(:database),
+        mongo: configuration(:mongo),
+        rabbitmq: configuration(:rabbitmq)
+      )
+      write_file(path, docker_compose.structure.to_yaml)
+    end
+
+    private
+
+    def configuration(service)
+      # REVIEW: At the moment we only handle test dependencies - it would be
+      # nice to also handle development dependencies.
+      {
+        database: Services::Database::Configuration,
+        mongo: Services::Mongo::Configuration,
+        rabbitmq: Services::RabbitMQ::Configuration
+      }.fetch(service).new(@env)
+    end
+
+    def wait_commands
+      [
+        configuration(:database).settings.nil? ? nil : 'wait-database',
+        configuration(:mongo).settings.nil? ? nil : 'wait-mongo',
+        configuration(:rabbitmq).settings.nil? ? nil : 'wait-rabbitmq'
+      ].compact.join(' ')
+    end
+
+    def docker_username(settings)
+      return unless settings.get('docker.username').nil?
+
+      @terminal.write(:setup, I18n.t('orchestration.docker.username_request'))
+      settings.set('docker.username', @terminal.read('[username]:'))
+    end
+  end
+end

data/lib/orchestration/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Orchestration
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/orchestration.rake'
+    end
+  end
+end

data/lib/orchestration/service_check.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Orchestration
+  class ServiceCheck
+    ATTEMPT_LIMIT = 10
+    RETRY_INTERVAL = 3 # seconds
+
+    def initialize(service, terminal, options = {})
+      @service = service
+      @service_name = service_name(service)
+      @terminal = terminal
+      @attempt_limit = options.fetch(:attempt_limit, ATTEMPT_LIMIT)
+      @retry_interval = options.fetch(:retry_interval, RETRY_INTERVAL)
+      @attempts = 0
+      @failure_callback = options.fetch(:failure_callback, nil)
+    end
+
+    def run
+      echo_start
+      success = attempt_connection
+      echo_ready if success
+      success
+    end
+
+    private
+
+    def attempt_connection
+      echo_waiting
+      @service.connect
+      true
+    rescue *@service.connection_errors => e
+      @attempts += 1
+      sleep @retry_interval
+      retry unless @attempts == @attempt_limit
+      echo_error(e)
+      echo_failure
+      false
+    end
+
+    def echo_start
+      @terminal.write(@service_name.to_sym, '', :status)
+    end
+
+    def echo_waiting
+      @terminal.write(
+        :waiting,
+        I18n.t(
+          "orchestration.#{@service_name}.waiting",
+          config: @service.configuration.friendly_config
+        )
+      )
+    end
+
+    def echo_ready
+      @terminal.write(
+        :ready,
+        I18n.t(
+          "orchestration.#{@service_name}.ready",
+          config: @service.configuration.friendly_config
+        )
+      )
+    end
+
+    def echo_failure
+      @terminal.write(
+        :failure,
+        I18n.t('orchestration.attempt_limit', limit: ATTEMPT_LIMIT)
+      )
+    end
+
+    def echo_error(error)
+      @terminal.write(:error, "[#{error.class.name}] #{error.message}")
+    end
+
+    def service_name(service)
+      # e.g.:
+      # Orchestration::Services::RabbitMQ::Healthcheck => 'rabbitmq'
+      service.class.name.split('::')[-2].downcase
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+      module Adapters
+        class Mysql2
+          def credentials
+            {
+              'username' => 'root',
+              'password' => 'password',
+              'database' => 'mysql'
+            }
+          end
+
+          def errors
+            [::Mysql2::Error]
+          end
+
+          def default_port
+            3306
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+      module Adapters
+        class Postgresql
+          def credentials
+            {
+              'username' => 'postgres',
+              'password' => 'password',
+              'database' => 'postgres'
+            }
+          end
+
+          def errors
+            [PG::ConnectionBad]
+          end
+
+          def default_port
+            5432
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+      module Adapters
+        class Sqlite3
+          def credentials
+            {
+              'username' => '',
+              'password' => '',
+              'database' => 'healthcheck'
+            }
+          end
+
+          def errors
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Orchestration
+  module Services
+    module Database
+      module Adapters
+      end
+    end
+  end
+end
+
+require 'orchestration/services/database/adapters/mysql2'
+require 'orchestration/services/database/adapters/postgresql'
+require 'orchestration/services/database/adapters/sqlite3'