orchestration 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 416fd08805e2ce12b2397a91f5baf894130f26d1ddf047f11a6b788b89783f16
-  data.tar.gz: 7b2f05787d2173d2e160a4ec40a4359e12f9e0d108384c7bd13c6fba43118692
+  metadata.gz: efffd8ac9ad681e2dd8341b2fb72dd709a118a5d862c670b19e0c146e15aaf5a
+  data.tar.gz: f62fd59095ff2f6ee7b615e834107625ba51ae63241e7c3d0b1766e53ff28048
 SHA512:
-  metadata.gz: 7a48ebb75ada7116256385d8bcf4d7db9a3bc6a9236b56b641078148a79b4fbb60cf75d4a488d0141415857d85f1d222d99adfd1212dd6346f7a7f6f14c7dbbc
-  data.tar.gz: f9df0d2800ea58090177d05b146236c44aff5e7cbbdd407b10f99214bea3fb8ae5de69f3893fd52eafa996491132cba9a25ecd7119c24320a4d420400e469396
+  metadata.gz: 441ff4f44916715e7999c0899fa94c232f76e53e43e94cdd151f1e19f4a63e41d4175ab99f3efca4bc3b33aa3e3f5f29061f4957041943a013fa80937e2c750a
+  data.tar.gz: 1ceb6dac11bb36e7eca7c645a390655675e1c7860c743e9e189854a668a18abb488cbcd2ce619d13ec60d7a725541ce56e3bf062dd56eb03ae82a5c37f2ec1d4

data/Makefile

@@ -4,3 +4,6 @@ test:
 	./bin/rspec
 	./bin/rubocop
 	./bin/strong_versions
+
+readme:
+	markdown-toc -i README.md

data/README.md

@@ -1,101 +1,237 @@
 # Orchestration
 
-## Overview
+_Orchestration_ is a toolkit for testing, building, and deploying _Ruby_ (including _Rails_) applications in _Docker_.
 
-_Orchestration_ provides a toolkit for building and launching _Rails_ applications and dependencies in _Docker_.
+## Getting Started
 
-A suite of tools is provided to assist in creating configuration files, launching service dependencies, verifying that dependencies have launched successfully (e.g. for running tests in contiuous integration tools), and building, tagging, and pushing _Docker_ images.
+[_Docker_](https://www.docker.com/get-started) and [_Docker Compose_](https://docs.docker.com/compose/install/) must be installed on your system.
 
-Containers are automatically created for the following dependencies:
+### Install
 
-* MySQL
-* MongoDB
-* PostgreSQL
-* RabbitMQ
-
-## Installation
-
-Add this line to your application's Gemfile:
+Add _Orchestration_ to your Gemfile:
 
 ```ruby
-gem 'orchestration', '~> 0.3.4'
+gem 'orchestration', '~> 0.3.5'
 ```
 
-And then build your bundle:
-``` bash
-$ bundle install
+Install:
+
+```bash
+bundle install
 ```
 
-## Usage
+### Setup
 
-### Generating configuration files
+Generate configuration files:
 
-A _Rake_ task is provided to generate the following files:
+```bash
+bin/rake orchestration:install
+```
 
-* `.gitignore` - ensures any unwanted files created by _Orchestration_ do not clutter your project's version control system.
-* `.orchestration.yml` - _Orchestration_ internal configuration, e.g. _Docker_ username.
-* `Makefile` - Adds `orchestration/Makefile` as an `include` to avoid clobbering any existing _make_ commands.
-* `orchestration/docker-compose.yml` - a custom-made set of services to allow you to run your application's dependencies locally.
-* `orchestration/Dockerfile` - a ready-to-use _Docker_ build script which should need minimal (if any) modification to build your _Rails_ project.
-* `orchestration/entrypoint.sh` - Container setup for your Docker application.
-* `orchestration/Makefile` - provides easy access to all _Orchestration_ utilities.
-* `orchestration/yaml.bash` - A _bash_ _YAML_ parser (used by _make_ utilities).
+Commit changes:
 
-### Building and pushing your project as a _Docker_ image
+```bash
+git add .
+git commit -m "Add Orchestration gem"
+```
 
-#### Private Git repository authentication
+## Usage
+
+Start your dependencies:
 
-If your project has any dependencies on private  _Git_ repositories then you will need to create an authentication token. See the relevant documentation for your _Git_ host:
+```bash
+make start
+```
 
-* [GitHub](https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/)
-* [Bitbucket](https://confluence.atlassian.com/bitbucket/app-passwords-828781300.html)
+Log in to your _Docker_ registry, then build and push your image:
+```bash
+docker login
+make build push
+```
 
-Create a file named `.env` in your project's root directory and add one or both of the following (note that _Bitbucket_ and _GitHub_ use a different format):
+Make a compact, portable, production-ready tarball:
+```
+make bundle
+```
 
+Copy tarball to your server and unpack:
 ```bash
-BUNDLE_BITBUCKET__ORG=<bitbucket-username>:<app-password>
-BUNDLE_GITHUB__COM=x-oauth-basic:<auth-token>
+tar xf deploy.tar
+cd <your-app-name>/
 ```
 
-#### Docker installation
-_Docker_ must be installed on your system. See the [_Docker_ getting started guide](https://www.docker.com/get-started) for instructions.
+Add required config to `.env` file:
+```
+# .env
+SECRET_KEY_BASE=<your-secure-token>
+LISTEN_PORT=8080
+VIRTUAL_HOST=yourdomain.com
+```
 
-#### DockerHub account
+Load three instances of your container, load-balanced by _Nginx_, with dependecies:
+```
+make start instances=3
+```
 
-You will need an account with _Docker Hub_ (or your preferred _Docker_ image host) to push your images. Visit the [_Docker Hub_ webpage](https://hub.docker.com/) to sign up, then run the following command and enter your credentials when prompted to log in to your new account:
-```bash
-$ docker login
+Or deploy to _Docker Swarm_:
+```
+make deploy
 ```
 
-#### Using provided `Makefile`
+## Table of Contents
+
+<!-- toc -->
+
+- [Configuration Files](#configuration-files)
+  * [Makefile](#makefile)
+  * [.orchestration.yml](#orchestrationyml)
+  * [.env](#env)
+  * [orchestration/Dockerfile](#orchestrationdockerfile)
+  * [orchestration/entrypoint.sh](#orchestrationentrypointsh)
+  * [orchestration/docker-compose.yml](#orchestrationdocker-composeyml)
+  * [config/unicorn.rb](#configunicornrb)
+- [Building](#building)
+- [Build Environment](#build-environment)
+- [Commands](#commands)
+- [Dependencies](#dependencies)
+
+<!-- tocstop -->
+
+## Configuration Files
+
+_Orchestration_ autogenerates boilerplate configuration based on your application's requirements and configuration.
+
+When supported dependencies are detected they will be created as services in your _Docker Compose_ configurations ready for use in testing, development, and production.
+
+The following files are created on setup:
+
+### Makefile
+
+Contains an `include` for the main _Orchestration_ `Makefile`. If this file already exists then the `include` will be added to the top of the file.
+
+### .orchestration.yml
+
+_Orchestration_-specific configuration such as your _Docker_ registry and username.
+
+### .env
+
+Specify any environment variables (e.g. `SECRET_KEY_BASE`) your application will need to run in production mode.
+
+The following two variables _must_ be defined:
 
-To build and push your image run:
 ```bash
-$ make docker
+VIRTUAL_HOST=localhost
+LISTEN_PORT=3000
 ```
 
-Or run the two steps separately:
+When running in production mode your application will be load-balanced by _Nginx_ proxy and available at http://localhost:3000/
+
+Take a look at `orchestration/docker-compose.production.yml` to see what variables will be exposed to various containers.
+
+### orchestration/Dockerfile
+
+The basic requirements of a typical _Rails_ application. It is optimised for build speed and will automatically build assets (with our without `Webpacker`).
+
+### orchestration/entrypoint.sh
+
+Entrypoint script to handle user switching, permissions, stale pidfiles, etc.
+
+### orchestration/docker-compose.yml
+
+Along with the base `docker-compose.yml` a separate configuration is created for each environment. An override file is also generated.
+
+See related documentation:
+
+https://docs.docker.com/compose/extends/
+
+* `orchestration/docker-compose.yml`
+* `orchestration/docker-compose.test.yml`
+* `orchestration/docker-compose.development.yml`
+* `orchestration/docker-compose.production.yml`
+* `orchestration/docker-compose.override.yml`
+
+You can modify these files to suit your requirements.
+
+The famous [`jwilder/nginx-proxy`](https://github.com/jwilder/nginx-proxy) is used to load-balance replicas of your application when running in production.
+
+### config/unicorn.rb
+
+If not already present, a [Unicorn](https://bogomips.org/unicorn/) configuration will be created. This is the default server when running in production.
+
+## Building
+
+_Orchestration_ provides tools for building your application as a _Docker_ image.
+
 ```bash
-$ make docker-build
-$ make docker-push
+make build
 ```
 
-### Starting and waiting for services when running your tests
+Running `make build` does the following:
 
-To start services:
+* Takes a snapshot of your application from current _Git_ `HEAD`. Only committed files are included.
+* Copies your `Gemfile` and installs your bundle (optimised for _Docker_ image caching).
+* Tags your image with your configured username/organisation, repository, and the current commit hash (abbreviated) of `HEAD`, e.g. `myorg/myapp:abc123`
 
-```bash
-$ make start
+Your image can then be pushed to your configured registry (use `docker login` before running):
+
+```
+make push
+```
+
+## Build Environment
+
+The following environment variables will be passed as `ARG` variables when building your image:
+
+```
+BUNDLE_BITBUCKET__ORG
+BUNDLE_GITHUB__COM
 ```
 
-It is recommended that you create a `test` command in your `Makefile` which will launch all dependencies and wait for them to be ready before running all tests. For example:
+See related documentation:
 
-```Makefile
-test: start wait
-	bundle exec rspec
-	yarn test app/javascript
-	bundle exec rubocop
-	yarn run eslint app/javascript
+* https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/
+* https://confluence.atlassian.com/bitbucket/app-passwords-828781300.html
+
+## Commands
+
+_Orchestration_ provides a number of `make` commands to help you work with your application in _Docker_.
+
+All commands respect `RAILS_ENV` or `RACK_ENV`. Alternatively you can pass `env` to any command:
+```bash
+make config env=production
 ```
 
-This is especially useful for continuous integration as it provides a uniform command (`make test`) that can be run by your CI tool without any extra setup.
+The following commands are implemented:
+
+| Command | Description |
+|---|---|
+| `start` | Start all containers and wait for their services to become available. In production mode, pass `instances=N` to start `N` replicas of your app. |
+| `stop` | Stop all containers. |
+| `logs` | Tail logs for all containers. |
+| `config` | Output the full configuration for the current environment with all variables substituted. |
+| `compose` | Output full `docker-compose` command. Run arbitrary commands for your environment, e.g. `$(make compose env=test) ps --services` |
+| `test-setup` | Launch test dependency containers, wait for them to become ready, run database migrations. Call before running tests in a CI environment. |
+| `wait` | Wait for all dependencies to be ready (i.e. verify that database is up and accepting connections, etc.). |
+| `wait-database` | Wait for database container (supported: _PostgreSQL_ and _MySQL_) to become available. |
+| `wait-mongo` | Wait for _Mongo_ container to become available.
+| `wait-rabbitmq` | Wait for _RabbitMQ_ container to become available. |
+| `wait-nginx_proxy` | Wait for _Nginx_ container to become available (`production` only). |
+| `wait-app` | Wait for main application container to become available (`production` only). |
+| `build` | Build your application as a _Docker_ image. |
+| `push` | Push the current version of your application image to a _Docker_ registry. |
+| `bundle` | Create `deploy.tar` which contains pre-cooked production configurations and `Makefile` ready to deploy your application on any machine with _Docker_ and _Docker Compose_ installed.
+
+## Dependencies
+
+Dependencies are automatically detected. The following services are currently supported:
+
+| Service | Configuration File |
+|---|---|
+| _PostrgeSQL_ | `config/database.yml` |
+| _MySQL_ | `config/database.yml` |
+| _RabbitMQ_ | `config/rabbitmq.yml` |
+| _Mongo_ | `config/mongoid.yml` |
+
+Running `bin/rake orchestration:install` will automatically add services to your _Compose_ configurations that reflect your configuration files.
+
+For _RabbitMQ_, `config/rabbitmq.yml` should contain `host` and `port` fields for each environment.

data/TODO

@@ -1,9 +1,19 @@
 Refactor docker-compose services - these really belong in
 lib/orchestration/services/<service-name>/docker_compose.rb
 
-Standardise on log formats - by policy or recommendation ?
+Add default logging section to each service ?
 
 Redis support
 
 Use `Paint` instead of `Colorize` for colouring output - better licensing and no
 monkeypatching `String` etc.
+
+Make unicorn `config.rb` resilient to database connectivity failures
+
+Group healthcheck rake tasks - run all at once in the same process. Create a
+master process that generates config files and calls each healthcheck in batch.
+
+Provide a way of declaratively configuring bespoke healthchecks.
+
+Auto-healthcheck any services with a local port bind using the Listener
+healthcheck.

data/config/locales/en.yml

@@ -16,6 +16,7 @@ en:
     mongo:
       waiting: "Waiting for Mongo: %{config}"
       ready: "Mongo is ready."
+      bad_config: "Unable to parse Mongo config: %{path}. Expected section for one of: %{expected}"
 
     nginx_proxy:
       waiting: "Waiting for Nginx proxy: %{config}"
@@ -31,9 +32,9 @@ en:
 
     settings:
       docker:
-        username:
-          description: "Docker registry username"
-          prompt: "username"
+        organization:
+          description: "Docker registry organization/username"
+          prompt: "organization"
 
         repository:
           description: "Project name (will be used as Docker registry repository)"

data/lib/orchestration/docker_compose/app_service.rb

@@ -10,7 +10,7 @@ module Orchestration
 
       def definition
         {
-          'image' => '${DOCKER_USERNAME}/${DOCKER_REPOSITORY}',
+          'image' => '${DOCKER_ORGANIZATION}/${DOCKER_REPOSITORY}',
           'environment' => environment,
           'expose' => [8080],
           'volumes' => [

data/lib/orchestration/docker_compose/mongo_service.rb

@@ -31,17 +31,13 @@ module Orchestration
       end
 
       def local_port
-        _host, _, port = clients.fetch('default')
-                                .fetch('hosts')
-                                .first
-                                .partition(':')
-        port.empty? ? remote_port : port
+        @config.port.nil? ? remote_port : @config.port
       end
 
-      def clients
-        @config.settings.fetch('clients')
-      rescue KeyError
-        @config.settings.fetch('sessions')
+      def client
+        Services::Mong::Configuration::CONFIG_KEYS.each do |key|
+          return @config.settings.fetch(key) if @config.settings.key?(key)
+        end
       end
 
       def remote_port

data/lib/orchestration/install_generator.rb

@@ -17,7 +17,7 @@ module Orchestration
 
     def orchestration_configuration
       path = @env.orchestration_configuration_path
-      @terminal.ask_setting('docker.username')
+      @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?
@@ -27,7 +27,7 @@ module Orchestration
     end
 
     def orchestration_makefile
-      content = template('Makefile', makefile_environment)
+      content = template('orchestration.mk', makefile_environment)
       path = @env.orchestration_root.join('Makefile')
       path.exist? ? update_file(path, content) : create_file(path, content)
     end
@@ -57,7 +57,7 @@ module Orchestration
     def gitignore
       path = @env.root.join('.gitignore')
       globs = %w[.build/ .deploy/ Gemfile Gemfile.lock]
-      entries = ['deploy.tar'] + globs.map do |entry|
+      entries = %w[.env deploy.tar] + globs.map do |entry|
         "#{@env.orchestration_dir_name}/#{entry}"
       end
 

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

@@ -13,8 +13,8 @@ module Orchestration
           @settings = {}
         end
 
-        def docker_username
-          @env.settings.get('docker.username')
+        def docker_organization
+          @env.settings.get('docker.organization')
         end
 
         def app_name

data/lib/orchestration/services/configuration_base.rb

@@ -45,6 +45,11 @@ module Orchestration
             .first
             .to_i
       end
+
+      def yaml(content)
+        # Whitelist `Symbol` and permit aliases:
+        YAML.safe_load(content, [Symbol], [], true)
+      end
     end
   end
 end

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

@@ -52,13 +52,10 @@ module Orchestration
           ERB.new(content).result
         end
 
-        def yaml(content)
-          YAML.safe_load(content, [], [], true) # true: Allow aliases
-        end
-
         def adapter_for(name)
           {
             'mysql2' => adapters::Mysql2,
+            'mysql' => adapters::Mysql2,
             'postgresql' => adapters::Postgresql,
             'sqlite3' => adapters::Sqlite3
           }.fetch(name).new
@@ -79,7 +76,7 @@ module Orchestration
         end
 
         def host
-          return nil if @adapter&.name == 'sqlite3'
+          return nil if @adapter && @adapter.name == 'sqlite3'
 
           super
         end

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

@@ -8,19 +8,29 @@ 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 = { clients_key => hosts_config }
+          @settings = if clients_key.nil?
+                        hosts_config # Host was configured at top level.
+                      else
+                        { clients_key => hosts_config }
+                      end
         end
 
         def friendly_config
           "[mongoid] #{host}:#{local_port}/#{database}"
         end
 
+        def port
+          DockerCompose::MongoService::PORT
+        end
+
         private
 
         def hosts_config
@@ -33,28 +43,39 @@ module Orchestration
         end
 
         def database
-          config
-            .fetch(@env.environment)
+          env_config = config.fetch(@env.environment)
+          return env_config.fetch('database') if env_config.key?('database')
+
+          bad_config_error if clients_key.nil?
+
+          env_config
             .fetch(clients_key)
             .fetch('default')
             .fetch('database')
         end
 
-        def port
-          DockerCompose::MongoService::PORT
-        end
-
         def clients_key
-          return 'clients' if config.fetch(@env.environment).key?('clients')
+          env_config = config.fetch(@env.environment)
 
           # Support older Mongoid versions
-          'sessions'
+          CONFIG_KEYS.each do |key|
+            return key if env_config.key?(key)
+          end
+
+          nil
         end
 
         def config
-          @config ||= YAML.safe_load(
-            File.read(@env.mongoid_configuration_path), [], [], true
-          )
+          @config ||= yaml(File.read(@env.mongoid_configuration_path))
+        end
+
+        def bad_config_error
+          raise ArgumentError,
+                I18n.t(
+                  'orchestration.mongo.bad_config',
+                  path: @env.mongoid_configuration_path,
+                  expected: CONFIG_KEYS.join(', ')
+                )
         end
       end
     end

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

@@ -25,9 +25,7 @@ module Orchestration
         private
 
         def config
-          YAML.safe_load(
-            File.read(@env.rabbitmq_configuration_path), [], [], true
-          )
+          yaml(File.read(@env.rabbitmq_configuration_path))
         end
       end
     end

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

@@ -11,4 +11,4 @@
 .PHONY: test
 test: test-setup
 	bundle exec rspec
-        bundle exec rubocop
+	bundle exec rubocop

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

@@ -1,34 +1,55 @@
-.PHONY: deploy stop start config pull logs migrate
+-include .env
+export
 
-COMPOSE_BASE:=HOST_UID=$(shell id -u) \
+verify-environment:
+ifndef VIRTUAL_HOST
+        @$(error VIRTUAL_HOST must be defined in environment)
+endif
+
+ifndef LISTEN_PORT
+        @$(error LISTEN_PORT must be defined in environment)
+endif
+
+compose_base:=HOST_UID=$(shell id -u) \
               DOCKER_USERNAME=%%USERNAME%% \
               DOCKER_REPOSITORY=%%REPOSITORY%%:%%VERSION%% \
               docker-compose \
               -p %%REPOSITORY%% \
               -f docker-compose.yml
 
-COMPOSE:=${COMPOSE_BASE} -f docker-compose.production.yml -f docker-compose.override.yml
+compose:=${compose_base} -f docker-compose.production.yml -f docker-compose.override.yml
 
+.PHONY: deploy
 deploy:
 	@echo "Deploying application to Docker swarm..."
-	@${COMPOSE} config | docker stack deploy -c - %%REPOSITORY%%
+	@${compose} config | docker stack deploy -c - %%REPOSITORY%%
 
+.PHONY: stop
 stop:
 	@echo "Stopping containers..."
-	@${COMPOSE} down
+	@${compose} down
 
+.PHONY: start
 start:
 	@echo "Launching application..."
-	@${COMPOSE} up -d
+	@${compose} up -d --scale app=$${instances:-1}
 
+.PHONY: config
 config:
-	@${COMPOSE} config
+	@${compose} config
 
+.PHONY: pull
 pull:
-	@${COMPOSE} pull
+	@${compose} pull
 
+.PHONY: logs
 logs:
-	@${COMPOSE} logs -f
+	@${compose} logs -f
 
+.PHONY: migrate
 migrate:
-	@${COMPOSE} run --rm app bundle exec rake db:migrate
+	@${compose} run --rm app bundle exec rake db:migrate
+
+.PHONY: compose
+compose:
+	@echo ${compose}

data/lib/orchestration/templates/{Makefile.erb → orchestration.mk.erb}

@@ -1,19 +1,6 @@
-.PHONY: start stop migrate bundle docker build push start logs compose config test-setup <%= wait_commands.join(' ') %>
-
 ### Environment setup ###
 
-docker_username:=$(shell bash ./<%= env.orchestration_dir_name %>/yaml.bash docker_username)
-docker_repository:=$(shell bash ./<%= env.orchestration_dir_name %>/yaml.bash docker_repository)
-
-compose_base:=HOST_UID=$(shell id -u) \
-              DOCKER_USERNAME=${docker_username} \
-              DOCKER_REPOSITORY=${docker_repository} \
-              docker-compose \
-              -p ${docker_repository} \
-              -f <%= env.orchestration_dir_name %>/docker-compose.yml
-
-git_branch:=$(if $(branch),$(branch),$(shell git rev-parse --abbrev-ref HEAD))
-git_version:=$(shell git rev-parse --short --verify ${git_branch})
+SHELL:=/bin/bash
 
 -include .env
 export
@@ -26,46 +13,71 @@ else ifeq (,$(env))
   env:=development
 endif
 
+ifeq (,$(wildcard ./bin/rake))
+  rake:=RACK_ENV=${env} RAILS_ENV=${env} bundle exec rake
+else
+  rake:=RACK_ENV=${env} RAILS_ENV=${env} bin/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)
+
+compose_base:=env HOST_UID=$(shell id -u) \
+              DOCKER_USERNAME=${docker_organization} \
+              DOCKER_REPOSITORY=${docker_repository} \
+              docker-compose \
+              -p ${docker_repository} \
+              -f <%= env.orchestration_dir_name %>/docker-compose.yml
+
+git_branch:=$(if $(branch),$(branch),$(shell git rev-parse --abbrev-ref HEAD))
+git_version:=$(shell git rev-parse --short --verify ${git_branch})
+
 compose:=${compose_base} -f <%= env.orchestration_dir_name %>/docker-compose.${env}.yml -f <%= env.orchestration_dir_name %>/docker-compose.override.yml
-rake:=RACK_ENV=${env} RAILS_ENV=${env} bin/rake
 
 ### Container management commands ###
 
+.PHONY: start
 start:
 	@echo "Starting containers..."
 ifeq (${env},$(filter ${env},test development))
 	@${compose} up -d
 else
-	@${compose} up -d --scale app=$${INSTANCES:-1}
+	@${compose} up -d --scale app=$${instances:-1}
 endif
 	@$(MAKE) wait
 
+.PHONY: stop
 stop:
 	@echo "Stopping containers..."
 	@${compose} down
 	@echo "All containers stopped."
 
+.PHONY: logs
 logs:
 	@${compose} logs -f
 
+.PHONY: config
 config:
 	@${compose} config
 
+.PHONY: compose
 compose:
-	@${compose} $$cmd
+	@echo ${compose}
 
+.PHONY: test-setup
 test-setup:
-	@$(MAKE) start wait migrate env=test
+	@$(MAKE) start migrate env=test
 
 ### 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}/
 	@sed -e "s/%%VERSION%%/${git_version}/g" \
              -e "s/%%REPOSITORY%%/${docker_repository}/g" \
-             -e "s/%%USERNAME%%/${docker_username}/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 \
@@ -77,10 +89,11 @@ bundle:
 
 ### Database utility commands ###
 
+.PHONY: migrate
 migrate:
 	@echo "Running migrations..."
 ifeq (${env},$(filter ${env},test development))
-	@${rake} db:migrate
+	@(${rake} db:create && ${rake} db:migrate) || ${rake} db:migrate
 else
 	@${compose} run --rm app bin/rake db:migrate RAILS_ENV=${env}
 endif
@@ -88,21 +101,30 @@ endif
 
 ### Service healthcheck commands ###
 
+.PHONY: wait
 wait: <%= wait_commands.join(' ') %>
 	@echo "All Containers ready."
 
+## Generic Listener healthcheck for TCP services ##
+
+wait-listener:
+	@${rake} orchestration:listener:wait service=${service}
+
 ## Test/development wait commands
 
+.PHONY: wait-database
 wait-database:
 ifeq (${env},$(filter ${env},test development))
 	@${rake} orchestration:database:wait
 endif
 
+.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
@@ -110,11 +132,13 @@ endif
 
 ## Production wait commands
 
+.PHONY: wait-nginx_proxy
 wait-nginx_proxy:
 ifneq (${env},$(filter ${env},test development))
 	@${rake} orchestration:nginx_proxy:wait LISTEN_PORT=${LISTEN_PORT}
 endif
 
+.PHONY: wait-app
 wait-app:
 ifneq (${env},$(filter ${env},test development))
 	@${rake} orchestration:app:wait LISTEN_PORT=${LISTEN_PORT}
@@ -122,24 +146,24 @@ endif
 
 ### Docker build commands ###
 
-docker: build push
-
+.PHONY: build
 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 %>
+<% 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}
 	@docker build \
 	             --build-arg BUNDLE_GITHUB__COM \
 	             --build-arg BUNDLE_BITBUCKET__ORG \
-		     -t ${docker_username}/${docker_repository} \
-		     -t ${docker_username}/${docker_repository}:${git_version} \
+		     -t ${docker_organization}/${docker_repository} \
+		     -t ${docker_organization}/${docker_repository}:${git_version} \
 		     ./<%= env.orchestration_dir_name %>/
 	@echo "Build complete."
 
+.PHONY: push
 push:
-	docker push ${docker_username}/${docker_repository}:${git_version}
+	docker push ${docker_organization}/${docker_repository}:${git_version}

data/lib/orchestration/version.rb

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

data/orchestration.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.name = 'orchestration'
   spec.version = Orchestration::VERSION
   spec.authors = ['Bob Farrell']
-  spec.email = ['bob@orchestration.co.uk']
+  spec.email = ['robertanthonyfarrell@gmail.com']
 
   spec.summary = 'Docker orchestration toolkit'
   spec.description = 'Tools to help launch apps in Docker'
@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'unicorn', '~> 5.4'
 
   spec.add_development_dependency 'activerecord', '~> 5.2'
+  spec.add_development_dependency 'betterp', '~> 0.1.3'
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'bunny', '~> 2.12'
   spec.add_development_dependency 'byebug', '~> 10.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: orchestration
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Bob Farrell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-24 00:00:00.000000000 Z
+date: 2019-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: betterp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -278,7 +292,7 @@ dependencies:
         version: '3.4'
 description: Tools to help launch apps in Docker
 email:
-- bob@orchestration.co.uk
+- robertanthonyfarrell@gmail.com
 executables:
 - console
 - rspec
@@ -347,13 +361,13 @@ files:
 - lib/orchestration/services/rabbitmq/healthcheck.rb
 - lib/orchestration/settings.rb
 - lib/orchestration/templates/Dockerfile.erb
-- lib/orchestration/templates/Makefile.erb
 - lib/orchestration/templates/application.mk.erb
 - lib/orchestration/templates/deploy.mk.erb
 - lib/orchestration/templates/docker-compose.override.yml.erb
 - lib/orchestration/templates/entrypoint.sh.erb
 - lib/orchestration/templates/env.erb
 - lib/orchestration/templates/nginx.tmpl.erb
+- lib/orchestration/templates/orchestration.mk.erb
 - lib/orchestration/templates/unicorn.rb.erb
 - lib/orchestration/templates/yaml.bash.erb
 - lib/orchestration/terminal.rb