orchestration 0.3.17 → 0.4.0

data/lib/orchestration/templates/orchestration.mk.erb

@@ -1,66 +1,107 @@
 ### Environment setup ###
-
 SHELL:=/bin/bash
 
--include .env
+<%= macros %>
+
+ifdef env_file
+  -include ${env_file}
+else
+  -include .env
+endif
+
 export
 
 ifneq (,$(env))
-  env:=$(env)
+  # `env` set by current shell.
 else ifneq (,$(RAILS_ENV))
-  env:=$(RAILS_ENV)
+  env=$(RAILS_ENV)
 else ifneq (,$(RACK_ENV))
-  env:=$(RACK_ENV)
+  env=$(RACK_ENV)
 else
-  env:=development
+  env=development
 endif
 
-ifeq (,$(wildcard ./bin/rake))
-  rake:=RACK_ENV=${env} RAILS_ENV=${env} bundle exec rake
+DOCKER_TAG ?= latest
+
+ifneq (,$(wildcard ./bin/rake))
+  rake=RACK_ENV=${env} RAILS_ENV=${env} bin/rake
+else ifneq (,$(wildcard ./Gemfile))
+  rake=RACK_ENV=${env} RAILS_ENV=${env} bundle exec rake
 else
-  rake:=RACK_ENV=${env} RAILS_ENV=${env} bin/rake
+  rake=RACK_ENV=${env} RAILS_ENV=${env} rake
 endif
 
-docker_organization:=$(shell bash ./<%= env.orchestration_dir_name %>/yaml.bash docker_organization)
-docker_repository:=$(shell bash ./<%= env.orchestration_dir_name %>/yaml.bash docker_repository)
+ifneq (,$(wildcard ${env_file}))
+  rake=. ${env_file} && ${rake}
+endif
 
-compose_base:=env HOST_UID=$(shell id -u) \
-              DOCKER_ORGANIZATION=${docker_organization} \
-              DOCKER_REPOSITORY=${docker_repository} \
-              docker-compose \
-              -p ${docker_repository}_${env} \
-              -f <%= env.orchestration_dir_name %>/docker-compose.yml \
+docker_organization=$(shell bash ${orchestration_dir}/yaml.bash docker_organization)
+docker_repository=$(shell bash ${orchestration_dir}/yaml.bash docker_repository)
 
-git_branch:=$(if $(branch),$(branch),$(shell git rev-parse --abbrev-ref HEAD))
-git_version:=$(shell git rev-parse --short --verify ${git_branch})
+compose_base=env HOST_UID=$(shell id -u) \
+             DOCKER_ORGANIZATION="${docker_organization}" \
+             DOCKER_REPOSITORY="${docker_repository}" \
+             docker-compose \
+             -p "${docker_repository}_${env}" \
+             -f "${orchestration_dir}/docker-compose.yml"
 
-compose:=${compose_base} -f <%= env.orchestration_dir_name %>/docker-compose.${env}.yml -f <%= env.orchestration_dir_name %>/docker-compose.override.yml
+git_branch ?= $(if $(branch),$(branch),$(shell git rev-parse --abbrev-ref HEAD))
+git_version ?= $(shell git rev-parse --short --verify ${git_branch})
+docker_image=${docker_organization}/${docker_repository}:${git_version}
 
-ifneq (,$(wildcard <%= env.orchestration_dir_name %>/docker-compose.local.yml))
-  compose:=${compose} -f <%= env.orchestration_dir_name %>/docker-compose.local.yml
+compose=${compose_base} -f ${orchestration_dir}/docker-compose.${env}.yml -f ${orchestration_dir}/docker-compose.override.yml
+random_str=cat /dev/urandom | LC_ALL=C tr -dc 'a-z' | head -c $1
+
+ifneq (,$(wildcard ${orchestration_dir}/docker-compose.local.yml))
+  compose:=${compose} -f ${orchestration_dir}/docker-compose.local.yml
 endif
 
+all: build
+
 ### Container management commands ###
 
 .PHONY: start
-start:
-	@echo "Starting containers..."
+start: _clean-logs
+	@$(call print,'${yellow}Starting containers${reset} ...')
 ifeq (${env},$(filter ${env},test development))
-	@# If our hostname is also known to Docker as a container ID then join
-	@# the same network as our dependencies. This allows us to run side-car
-	@# dependencies if we are running in a container (e.g. in Jenkins).
-	@(docker ps --format "{{.ID}}" | grep -q $(shell hostname) && ${compose} up -d && docker network connect ${docker_repository}_${env}_default $(shell hostname)) || ${compose} up -d
+	@${compose} up -d --force-recreate ${services} ${log_progress} || ${fail}
+	@[ '${is_container}' == '1' ] && \
+         ( \
+           docker network connect '${network}' '$(shell hostname)' ${log} \
+           || \
+           $(call println,'${yellow}Warning${reset}: Unable to join network: "${yellow}${network}${reset}". Container will not be able to connect to dependency services.') \
+         ) \
+         || ( [ '${is_container}' == '0' ] || ${fail} )
 else
-	@${compose} up -d --scale app=$${instances:-1}
+	@${compose} up -d --scale app=$${instances:-1} ${services} ${log_progress} || ${fail}
 endif
-	@$(MAKE) wait
+	@$(call printrawln,' ${green}started${reset} ${tick}')
+	@$(call println,'${yellow}Waiting for services to become available${reset} ...')
+ifdef services
+	@$(call make,wait services='${services}') 2>${stderr} || ${fail}
+else
+	@$(call make,wait) 2>${stderr} || ${fail}
+endif
+
+<% services.each do |service| %>
+.PHONY: start-<%= service %>
+start-<%= service %>:
+	@$(call make,start services='<%= service %>')
+
+<% end %>
 
 .PHONY: stop
-stop:
-	@echo "Stopping containers..."
-	@(docker ps --format "{{.ID}}" | grep -q $(shell hostname) && docker network disconnect ${docker_repository}_${env}_default $(shell hostname))
-	@${compose} down
-	@echo "All containers stopped."
+stop: _clean-logs
+	@$(call print,'${yellow}Stopping containers${reset} ...')
+	@if docker ps --format "{{.ID}}" | grep -q $(shell hostname) ; \
+          then \
+            ( ${compose} down ${log_progress} || ${fail} ) \
+            && \
+            ( docker network connect ${docker_repository}_${env}_default $(shell hostname) ${log} || : ) ; \
+          else \
+            ${compose} down ${log_progress} || ${fail} ; \
+          fi
+	@$(call printrawln,' ${green}stopped${reset}. ${tick}')
 
 .PHONY: logs
 logs:
@@ -74,78 +115,135 @@ config:
 compose:
 	@echo ${compose}
 
+### Development/Test Utility Commands
+
+.PHONY: serve
+serve: env_file ?= ./.env
+serve: rails = RAILS_ENV='${env}' bundle exec rails server ${server}
+serve: _verify_env
+	@if [ "${custom_env_file}" == "1" ] && [ ! -f "${env_file}" ] ; \
+         then \
+           $(call println_error,'${red}Error${reset}: Environment file "${yellow}${env_file}${reset}" not found. ${cross}') ; \
+           ${fail} ; \
+         fi
+	@if [ -f "${env_file}" ] ; \
+         then ( \
+                $(call println,'${yellow}Environment${reset}: ${green}${env_file}${reset}') && \
+                cat '${env_file}' | ${format_env} && \
+                $(call println,'') && \
+                set -a && . '${env_file}' && set +a && \
+                ${rails} \
+            ) ; \
+         else ${rails} ; \
+         fi
+
 .PHONY: test-setup
+test-setup: env := test
 test-setup:
-	@$(MAKE) start migrate env=test
+	@$(call make,start env=test)
+ifneq (,$(wildcard config/database.yml))
+	${rake} db:create || :
+  ifneq (,$(wildcard db/structure.sql))
+	${rake} db:structure:load
+  else ifneq (,$(wildcard db/schema.rb))
+	${rake} db:schema:load
+  endif
+
+	${rake} db:migrate
+endif
+
+.PHONY: dump
+dump:
+	@$(call println)
+	@$(call println,'${yellow}Captured${reset} ${green}stdout${reset} ${yellow}and${reset} ${red}stderr${reset} ${yellow}log data${reset}:')
+	@$(call println)
+	@echo
+	@test -f '${stdout}' && ( \
+          $(call hr,${green}) ; \
+          $(call println,'${gray}${stdout}${reset}') ; \
+          $(call hr,${green}) ; \
+          echo ; cat '${stdout}' ; echo ; \
+          $(call hr,${green}) ; \
+        )
+
+	@test -f '${stdout}' && ( \
+          echo ; \
+          $(call hr,${red}) ; \
+          $(call println,'${gray}${stderr}${reset}') ; \
+          $(call hr,${red}) ; \
+          echo ; cat '${stderr}' ; echo ; \
+          $(call hr,${red}) ; \
+        )
+
+.PHONY: image
+image:
+	@echo ${docker_image}
 
 ### Deployment utility commands ###
 
 .PHONY: bundle
 bundle:
-	@echo 'Building deployment bundle...'
-	@rm -rf <%= env.orchestration_dir_name %>/.deploy/
-	@mkdir -p <%= env.orchestration_dir_name %>/.deploy/${docker_repository}/
+ifndef path
+	@$(warning Missing `path` parameter; using `./bundle.tar`. Set a custom path with `make bundle path=/tmp/bundle.tar`)
+endif
+	@rm -rf ${orchestration_dir}/.deploy/
+	@mkdir -p ${orchestration_dir}/.deploy/${docker_repository}/
 	@sed -e "s/%%VERSION%%/${git_version}/g" \
              -e "s/%%REPOSITORY%%/${docker_repository}/g" \
              -e "s/%%ORGANIZATION%%/${docker_organization}/g" \
-             <%= env.orchestration_dir_name %>/deploy.mk > \
-             <%= env.orchestration_dir_name %>/.deploy/${docker_repository}/Makefile
-	@cp <%= env.orchestration_dir_name %>/docker-compose.yml \
-            <%= env.orchestration_dir_name %>/docker-compose.production.yml \
-            <%= env.orchestration_dir_name %>/docker-compose.override.yml \
-            <%= env.orchestration_dir_name %>/.deploy/${docker_repository}/
-	@tar -C <%= env.orchestration_dir_name %>/.deploy -cf ./deploy.tar ./${docker_repository}
-	@echo 'Deployment bundle written to ./deploy.tar'
+             ${orchestration_dir}/deploy.mk > \
+             ${orchestration_dir}/.deploy/${docker_repository}/Makefile
+	@cp ${orchestration_dir}/docker-compose.yml \
+            ${orchestration_dir}/docker-compose.production.yml \
+            ${orchestration_dir}/docker-compose.override.yml \
+            ${orchestration_dir}/.deploy/${docker_repository}/
+	@bundle_path="${path}" ; tar -C '${orchestration_dir}/.deploy' -cf "$${bundle_path:-./bundle.tar}" ./${docker_repository}
 
 .PHONY: deploy
-deploy:
 ifndef manager
-	@$(error Missing `manager` parameter: `make deploy manager=swarm-manager.example.com`)
-else
-	@echo 'Deploying stack via ${manager}...'
-endif
-
-ifndef env_file
-	$(MAKE) bundle \
-     && workdir=$$(mktemp -d) \
-     && mv deploy.tar $${workdir}/ \
-     && cd $${workdir} \
-     && tar xf deploy.tar \
-     && cd ${docker_repository} \
-     && tar -cf - . | ssh ${manager} 'cd $$(mktemp -d) && chmod 0700 . && cat - | tar -x && make deploy-stack && rm -r $$(pwd)'
-else
-	$(MAKE) bundle \
-     && workdir=$$(mktemp -d) \
-     && mv deploy.tar $${workdir}/ \
-     && cd $${workdir} \
-     && tar xf deploy.tar \
-     && cd ${docker_repository} \
-     && cp "${env_file}" ./.env \
-     && tar -cf - . | ssh ${manager} 'cd $$(mktemp -d) && chmod 0700 . && cat - | tar -x && make deploy-stack && rm -r $$(pwd)'
-endif
-
-### Database utility commands ###
-
-.PHONY: migrate
-migrate:
-	@echo "Running migrations..."
-	@(${rake} db:create && ${rake} db:migrate) || ${rake} db:migrate
-	@echo "Migrations complete."
-
-.PHONY: migrate-container
-migrate-container:
-	@echo "[app] Running migrations..."
-ifdef env_file
-	@cp ${env_file} ./.env
+	@$(call println_error,'Missing `manager` parameter: `make deploy manager=swarm-manager.example.cor`')
 endif
-	${compose} run --rm app bundle exec rake db:migrate
-	@echo "[app] Migrations complete."
+deploy: env := production
+deploy: project_name = ${docker_repository}_${env}
+deploy: path = $(shell mktemp -d)
+deploy: RAILS_ENV = ${env}
+deploy: RACK_ENV = ${env}
+deploy: DOCKER_TAG = ${git_version}
+deploy:
+	@$(call println,'${yellow}Deploying stack via${reset} ${green}${manager}${reset} ...') && \
+          ( \
+            $(call make,_verify_compose env_file=${env_file} env=${env}) && \
+            $(call make,bundle path='${path}/bundle.tar') ${log} && \
+            cd '${path}' ${log} && \
+            tar xf './bundle.tar' ${log} && \
+            cd '${docker_repository}' ${log} && \
+               ( [ -z '${env_file}' ] || cp '${env_file}' './.env' ${log} ) && \
+               $(call println,'${yellow}Deployment environment${reset}:') && \
+               ( test -f '.env' && cat '.env' | ${format_env} || : ) && \
+               echo 'DOCKER_ORGANIZATION=${docker_organization}' >> './.env' && \
+               echo 'DOCKER_REPOSITORY=${docker_repository}' >> './.env' && \
+               echo 'DOCKER_TAG=${git_version}' >> ./.env && \
+               $(call println,'') && \
+               $(call println,'${yellow}Application image${reset}: ${cyan}${docker_image}${reset}') && \
+               ${compose} config 2>${stderr} | ssh "${manager}" 'docker stack deploy --prune --with-registry-auth -c - "${project_name}"' ${log} && \
+            ( [ -z "${path}" ] || rm -rf "${path}" ${log} ) \
+          ) \
+          || ${fail}
+
+	@$(call println,'${yellow}Deployment${reset} ${green}complete${reset}. ${tick}')
 
 ### Service healthcheck commands ###
 
 .PHONY: wait
-wait: <%= wait_commands.join(' ') %>
-	@echo "All Containers ready."
+<% services.each do |service| %>
+ifneq (,$(findstring <%= service %>,${services}))
+wait: wait-<%= service %>
+endif
+<% end %>
+ifndef services
+wait: <%= services.map { |command| "wait-#{command}" }.join(' ') %>
+endif
+	@$(call println,'${yellow}All services${reset} ${green}ready${reset}. ${tick}')
 
 ## Generic Listener healthcheck for TCP services ##
 
@@ -154,23 +252,13 @@ wait-listener:
 
 ## Test/development wait commands
 
-.PHONY: wait-database
-wait-database:
-ifeq (${env},$(filter ${env},test development))
-	@${rake} orchestration:database:wait
-endif
+<% services.each do |service| %>
+<% next if service.to_sym == :app %>
+.PHONY: wait-<%= service %>
+wait-<%= service %>:
+	@${rake} orchestration:<%= service %>:wait
 
-.PHONY: wait-mongo
-wait-mongo:
-ifeq (${env},$(filter ${env},test development))
-	@${rake} orchestration:mongo:wait
-endif
-
-.PHONY: wait-rabbitmq
-wait-rabbitmq:
-ifeq (${env},$(filter ${env},test development))
-	@${rake} orchestration:rabbitmq:wait
-endif
+<% end %>
 
 .PHONY: wait-app
 wait-app:
@@ -179,23 +267,57 @@ wait-app:
 ### Docker build commands ###
 
 .PHONY: build
+build: context = ${orchestration_dir}/.build/context.tar
 build:
-	@echo "Preparing build from ${git_branch}"
-	@mkdir -p ./<%= env.orchestration_dir_name %>/.build
-	@git show ${git_branch}:./Gemfile > ./<%= env.orchestration_dir_name %>/.build/Gemfile
-	@git show ${git_branch}:./Gemfile.lock > ./<%= env.orchestration_dir_name %>/.build/Gemfile.lock
-<% if defined?(Webpacker) %>	@git show ${git_branch}:./package.json > ./<%= env.orchestration_dir_name %>/.build/package.json<% end %>
-<% if defined?(Webpacker) %>	@git show ${git_branch}:./yarn.lock > ./<%= env.orchestration_dir_name %>/.build/yarn.lock<% end %>
-	@echo "Building..."
-	@git archive --format tar.gz -o ./<%= env.orchestration_dir_name %>/.build/context.tar.gz ${git_branch}
+	@$(call print,'${yellow}Preparing build context from${reset} ${cyan}${git_branch}:${git_version}${reset} ... ')
+	@mkdir -p ${orchestration_dir}/.build ${log} || ${fail}
+	@git show ${git_branch}:./Gemfile > ${orchestration_dir}/.build/Gemfile 2>${stderr} || ${fail}
+	@git show ${git_branch}:./Gemfile.lock > ${orchestration_dir}/.build/Gemfile.lock 2>${stderr} || ${fail}
+<% if defined?(Webpacker) %>	@git show ${git_branch}:./package.json > ${orchestration_dir}/.build/package.json 2>${stderr} || ${fail}<% end %>
+<% if defined?(Webpacker) %>	@git show ${git_branch}:./yarn.lock > ${orchestration_dir}/.build/yarn.lock 2>${stderr} || ${fail}<% end %>
+	@git archive --format 'tar' -o '${context}' '${git_branch}' ${log} || ${fail}
+	@temp=$$(mktemp -d) ; ( cd "$${temp}" && touch './.orchestration_container_flag' && tar -uvf '${context}' . ) ${log} || ${fail}
+	@$(call printrawln,'${green}complete.${reset} ${tick}')
+	@$(call print,'${yellow}Building image${reset} ...')
 	@docker build \
-	             --build-arg BUNDLE_GITHUB__COM \
-	             --build-arg BUNDLE_BITBUCKET__ORG \
-		     -t ${docker_organization}/${docker_repository} \
-		     -t ${docker_organization}/${docker_repository}:${git_version} \
-		     ./<%= env.orchestration_dir_name %>/
-	@echo "Build complete."
+                        --build-arg BUNDLE_GITHUB__COM \
+                        --build-arg BUNDLE_BITBUCKET__ORG \
+                        -t ${docker_organization}/${docker_repository} \
+                        -t ${docker_organization}/${docker_repository}:${git_version} \
+                        ${orchestration_dir}/ ${log_progress} || ${fail}
+	@$(call printrawln,' ${green}complete${reset}. ${tick}')
+	@$(call println,'[${green}tag${reset}] ${cyan}${docker_organization}/${docker_repository}${reset}')
+	@$(call println,'[${green}tag${reset}] ${cyan}${docker_organization}/${docker_repository}:${git_version}${reset}')
 
 .PHONY: push
 push:
-	docker push ${docker_organization}/${docker_repository}:${git_version}
+	@$(call print,'${yellow}Pushing${reset} ${cyan}${docker_image}${reset} ...')
+	@docker push ${docker_image} ${log_progress} || ${fail}
+	@$(call printrawln,' ${green}complete${reset}. ${tick}')
+
+### Internal Commands ###
+#
+.PHONY: _verify_app_image
+_verify_app_image:
+	@docker inspect '${docker_image}'
+
+.PHONY: _verify_compose
+_verify_compose: _verify_env
+	@$(call print,'${yellow}Verifying compose file(s)${reset} ... ')
+	@${replace_env}
+	@${compose} config ${log} || ${fail}
+	@${restore_env}
+	@$(call printrawln,'${green}success${reset}. ${tick}')
+
+.PHONY: _verify_env
+_verify_env:
+	@if [ "${custom_env_file}" == "1" ] && [ ! -f "${env_file}" ] ; \
+         then \
+           $(call print_error,'${red}Error${reset}: Environment file "${yellow}${env_file}${reset}" not found. ${cross}') ; \
+           exit 1 ; \
+         fi
+
+.PHONY: _clean-logs
+_clean-logs:
+	@rm -f '${stdout}' '${stderr}'
+	@touch '${stdout}' '${stderr}'

data/lib/orchestration/templates/puma.rb.erb

@@ -0,0 +1,19 @@
+environment ENV.fetch('RAILS_ENV') { 'development' }
+
+port ENV.fetch('WEB_PORT') { 3000 }
+workers ENV.fetch('WEB_CONCURRENCY') { 4 }
+threads_count = ENV.fetch('RAILS_MAX_THREADS') { 8 }
+
+pidfile './tmp/pids/server.pid'
+threads threads_count, threads_count
+
+preload_app! if ENV.key?('WEB_PRELOAD_APP')
+
+before_fork do
+  ActiveRecord::Base.connection_pool.disconnect! if defined?(ActiveRecord)
+end
+
+on_worker_boot do
+  ActiveRecord::Base.establish_connection if defined?(ActiveRecord)
+end
+

data/lib/orchestration/templates/rabbitmq.yml.erb

@@ -0,0 +1,12 @@
+<% if compose.call('development').services.key?('rabbitmq') %>
+development:
+  url: amqp://127.0.0.1:<%= compose.call('development').local_port('rabbitmq') %>
+<% end %>
+
+<% if compose.call('test').services.key?('rabbitmq') %>
+test:
+  url: amqp://127.0.0.1:<%= compose.call('test').local_port('rabbitmq') %>
+<% end %>
+
+production:
+  url: <%%= ENV['RABBITMQ_URL'] %>

data/lib/orchestration/templates/unicorn.rb.erb

@@ -1,12 +1,12 @@
-listen '0.0.0.0:8080', tcp_nopush: true
+listen "0.0.0.0:#{ENV.fetch('WEB_PORT', '8080')}", tcp_nopush: true
 
-pid '/app/tmp/pids/unicorn.pid'
+pid '/app/tmp/pids/server.pid'
 
-preload_app ENV.fetch('UNICORN_PRELOAD_APP', '1') == '1'
+preload_app ENV.key?('WEB_PRELOAD_APP')
 
-timeout ENV.fetch('UNICORN_TIMEOUT', 60).to_i
+timeout ENV.fetch('WEB_TIMEOUT', 60).to_i
 
-worker_processes ENV.fetch('UNICORN_WORKER_PROCESSES', 8).to_i
+worker_processes ENV.fetch('WEB_CONCURRENCY', 8).to_i
 
 before_fork do |_server, _worker|
   ActiveRecord::Base.connection.disconnect! if defined?(ActiveRecord)

data/lib/orchestration/terminal.rb

@@ -2,16 +2,17 @@
 
 module Orchestration
   COLOR_MAP = {
-    failure: :light_red,
-    error: :red,
-    waiting: :yellow,
-    ready: :green,
-    create: :green,
-    update: :yellow,
-    status: :blue,
-    setup: :blue,
-    input: :red,
-    skip: :light_yellow
+    failure: %i[red bright],
+    error: %i[red],
+    waiting: %i[yellow],
+    ready: %i[green],
+    create: %i[green],
+    update: %i[yellow],
+    backup: %i[blue],
+    status: %i[blue],
+    setup: %i[blue],
+    input: %i[red],
+    skip: %i[yellow bright]
   }.freeze
 
   class Terminal
@@ -55,11 +56,8 @@ module Orchestration
               else
                 COLOR_MAP.fetch(color_name)
               end
-      desc
-        .to_s
-        .rjust(15)
-        .colorize(mode: :default, color: color)
-        .concat(' ' + message)
+
+      Paint[desc.to_s.rjust(15), *color] + ' ' + message
     end
 
     def t(key)

data/lib/orchestration/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Orchestration
-  VERSION = '0.3.17'
+  VERSION = '0.4.0'
 end

data/lib/orchestration.rb

@@ -1,12 +1,17 @@
 # frozen_string_literal: true
 
-require 'colorize'
+require 'erb'
+require 'pathname'
+require 'socket'
+
+require 'database_url'
 require 'erubis'
 require 'i18n'
+require 'paint'
 begin
   require 'rails'
 rescue LoadError
-  STDERR.puts('Rails not detected; continuing without Rails support.')
+  STDERR.puts('[orchestration] Rails not detected; skipping.')
 end
 
 I18n.load_path += Dir[File.join(File.expand_path('..', __dir__),
@@ -33,4 +38,17 @@ module Orchestration
   def self.rakefile
     root.join('lib', 'Rakefile')
   end
+
+  def self.error(key, options = {})
+    STDERR.puts('# Orchestration Error')
+    STDERR.puts('# ' + I18n.t("orchestration.#{key}", options))
+  end
+
+  def self.random_local_port
+    socket = Socket.new(:INET, :STREAM, 0)
+    socket.bind(Addrinfo.tcp('127.0.0.1', 0))
+    port = socket.local_address.ip_port
+    socket.close
+    port
+  end
 end

data/lib/tasks/orchestration.rake

@@ -18,7 +18,9 @@ namespace :orchestration do
   namespace :database do
     desc I18n.t('orchestration.rake.database.wait')
     task :wait do
-      Orchestration::Services::Database::Healthcheck.start
+      Orchestration::Services::Database::Healthcheck.start(
+        nil, nil, init: ENV.key?('init')
+      )
     end
   end
 

data/orchestration.gemspec

@@ -16,19 +16,17 @@ Gem::Specification.new do |spec|
   spec.homepage = url
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      f.match(%r{^(test|spec|features)/})
-    end
+    File.readlines('MANIFEST').map(&:chomp)
   end
   spec.bindir = 'bin'
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'colorize', '~> 0.8.1'
+  spec.add_runtime_dependency 'database_url', '~> 0.1.2'
   spec.add_runtime_dependency 'erubis', '~> 2.7'
   spec.add_runtime_dependency 'i18n', '>= 0.5'
+  spec.add_runtime_dependency 'paint', '~> 2.0'
   spec.add_runtime_dependency 'thor', '~> 0.20.0'
-  spec.add_runtime_dependency 'unicorn', '~> 5.4'
 
   spec.add_development_dependency 'activerecord', '~> 5.2'
   spec.add_development_dependency 'betterp', '~> 0.1.3'