docker-rails 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8076e4ce6d1d20d727afadb4c99e5b9e57c18e21
-  data.tar.gz: 235f58b8be4f973954bbad1055df04b7bfb2a523
+  metadata.gz: 796f9a53d45a20066b265a383d0e649c69f3a870
+  data.tar.gz: c265056920b6b21936b3726b780ceb08b28875b3
 SHA512:
-  metadata.gz: 92189a1adf213f3cbb9def7fc31e95819c251c7b2a2e196add0971ce97bcc1c733d9af9154a8597d28eb03518fda597627df3418421e0b1d242899afe05e28ed
-  data.tar.gz: 5f977d58eebb066ce2a7717000dc60d6836010e55633dcd4b07e74f5ee61b48be34a417479e02186d4656a8df0f34775c7663dfa08630624cea6ae9e2e795aa9
+  metadata.gz: 880934be3caa2524812e4ddf8a18f089cf1333473549c59b49919fd4917912ddc27a93a1fbada92d5b3d5d03c33606163260bfaed647a19817fd50503fb82f0f
+  data.tar.gz: e8c352b19260fc47ace95a562f66a72d43df67dd622f83a50cd23f605e668bd23097a93d713a3cda9d6db242c2957c8d7235e193e21411a4873e874e3f4ad782

data/README.md

@@ -6,31 +6,39 @@
 A simplified pattern to execute rails applications within Docker (with a CI build emphasis).
 
 ## Features
-- Provides individual functions for development/test usage, or a full workflow for CI usage (with automated container, volume, and image cleanup).
+- DRY declarative `docker-rails.yml` allowing multiple environments to be defined with an inherited docker `compose` configuration
+- Provides individual convenience functions `up | bash | stop | cleanup` to easily work with target environment (even in a concurrent situation)
+- Full workflow for CI usage with automated container, volume, and image cleanup.
 - Automated cached global gems data volume based on ruby version
-- DRY declarative `docker-rails.yml` allowing multiple environments to be defined with an inherited `docker-compose` configuration
-- Interpolates `docker-compose.yml` making CI builds much easier
+- Interpolates variables `docker-compose.yml` making CI builds much easier
 - DB check CLI function provided for docker-compose `command` to check if db is ready
 
 ## Usage
 
 ```bash
 Commands:
-  docker-rails ci <build_name> <environment_name>          # Execute the works, everything with cleanup included i.e. bundle exec docker-rails ci 222 test
-  docker-rails compose <build_name> <environment_name>     # Writes a resolved docker-compose.yml file
-  docker-rails db_check <db>                               # Runs db_check
-  docker-rails gems_volume <command>                       # Gems volume management
-  docker-rails help [COMMAND]                              # Describe available commands or one specific command
-  docker-rails rm_compose                                  # Remove generated docker_compose file
-  docker-rails rm_dangling                                 # Remove danging images
-  docker-rails rm_volumes <build_name> <environment_name>  # Stop all running containers and remove corresponding volumes for the given build_name/environment_name
-  docker-rails show_all_containers                         # Show all remaining containers regardless of state
-  docker-rails stop <build_name> <environment_name>        # Stop all running containers for the given build_name/environment_name
-  docker-rails up <build_name> <environment_name>          # Up the docker-compose configuration for the given build_name/environment_name
+  docker-rails bash <target> <service_name>  # Open a bash shell to a running container e.g. bundle exec docker-rails bash --build=222 development db
+  docker-rails ci <target>                   # Execute the works, everything with cleanup included e.g. bundle exec docker-rails ci --build=222 test
+  docker-rails cleanup <target>              # Runs container cleanup functions stop, rm_volumes, rm_compose, rm_dangling, ps_all e.g. bundle exec docker-rails cleanup --build=222 development
+  docker-rails compose <target>              # Writes a resolved docker-compose.yml file e.g. bundle exec docker-rails compose --build=222 test
+  docker-rails db_check <db>                 # Runs db_check e.g. bundle exec docker-rails db_check mysql
+  docker-rails gems_volume <command>         # Gems volume management e.g. bundle exec docker-rails gems_volume create
+  docker-rails help [COMMAND]                # Describe available commands or one specific command
+  docker-rails ps <target>                   # List containers for the target compose configuration e.g. bundle exec docker-rails ps --build=222 development
+  docker-rails ps_all                        # List all remaining containers regardless of state e.g. bundle exec docker-rails ps_all
+  docker-rails rm_compose                    # Remove generated docker_compose file e.g. bundle exec docker-rails rm_compose --build=222 development
+  docker-rails rm_dangling                   # Remove danging images e.g. bundle exec docker-rails rm_dangling
+  docker-rails rm_volumes <target>           # Stop all running containers and remove corresponding volumes for the given build/target e.g. bundle exec docker-rails rm_volumes --build=222 development
+  docker-rails stop <target>                 # Stop all running containers for the given build/target e.g. bundle exec docker-rails stop --build=222 development
+  docker-rails up <target>                   # Up the docker-compose configuration for the given build/target. Use -d for detached mode. e.g. bundle exec docker-rails up -d --build=222 test
+
+Options:
+  -b, [--build=BUILD]  # Build name e.g. 123
+                       # Default: 1
 ```
 
 ## Work in progress - contributions welcome
-Open to pull requests. It can be expanded to suit many different configurations.
+Open to pull requests. Open to refactoring. It can be expanded to suit many different configurations.
 
 TODO:
 - **Permissions** - [Shared volume for project has files written as root](https://github.com/alienfast/docker-rails/issues/5)
@@ -77,7 +85,7 @@ ENV DEBIAN_FRONTEND newt
 ### 2. Add a docker-rails.yml
 
 Environment variables will be interpolated, so feel free to use them. 
-Below shows an example with all of the environments `development | test | parallel_tests | staging` to show reuse of the primary `docker-compose' configuration. 
+Below shows an example with all of the environments `development | test | parallel_tests | staging` to show reuse of the primary `compose` configuration. 
 
 ```yaml
 verbose: true
@@ -224,12 +232,12 @@ compose:
 
     volumes_from:
       # Mount the gems data volume container for cached bundler gem files
-      - #{GEMS_VOLUME_NAME}
+      - #{DOCKER_RAILS_GEMS_VOLUME_NAME}
 
     # https://docs.docker.com/v1.6/docker-compose/cli/#environment-variables
     environment:
       # Tell bundler where to get the files
-      - GEM_HOME=#{GEMS_VOLUME_PATH}
+      - GEM_HOME=#{DOCKER_RAILS_GEMS_VOLUME_PATH}
 
   db:
     # https://github.com/docker-library/docs/tree/master/mysql

data/lib/docker/rails.rb

@@ -8,6 +8,8 @@ end
 require 'thor'
 require 'docker'
 
+require 'docker/rails/core_ext/hash'
+
 require 'docker/rails/config'
 require 'docker/rails/compose_config'
 require 'docker/rails/app'

data/lib/docker/rails/app.rb

@@ -3,15 +3,15 @@ module Docker
     require 'singleton'
     class App
       include Singleton
-      attr_reader :config, :compose_config, :ruby_version, :build_name, :environment_name, :gems_volume_path, :gems_volume_name, :compose_filename
+      attr_reader :config, :compose_config, :ruby_version, :build, :target, :gems_volume_path, :gems_volume_name, :compose_filename
 
       class << self
-        def configured(build_name, environment_name)
+        def configured(target, options)
           app = App.instance
           if app.is_configured?
-            puts "Already configured"
+            # puts "Already configured"
           else
-            app.configure(build_name: build_name, environment_name: environment_name)
+            app.configure(Thor::CoreExt::HashWithIndifferentAccess.new(target: target).merge(options))
           end
           app
         end
@@ -23,12 +23,12 @@ module Docker
       end
 
       def configure(options)
-        ENV['BUILD_NAME'] = @build_name = options[:build_name]
-        @environment_name = options[:environment_name]
+        ENV['DOCKER_RAILS_BUILD'] = @build = options[:build]
+        @target = options[:target]
 
         # load the docker-rails.yml
         @config = Docker::Rails::Config.new
-        @config.load!(@environment_name)
+        @config.load!(@target)
 
         @is_configured = true
       end
@@ -39,7 +39,7 @@ module Docker
 
       def compose
         # Write a docker-compose.yml with interpolated variables
-        @compose_filename = compose_filename_from @build_name, @environment_name
+        @compose_filename = compose_filename_from @build, @target
 
         rm_compose
 
@@ -59,9 +59,14 @@ module Docker
         (exec before_command unless before_command.nil?) #unless skip? :before_command
       end
 
-      def exec_up
+      def exec_up(options = '')
         # Run the compose configuration
-        exec_compose 'up' #unless skip? :up
+        exec_compose 'up', false, options #unless skip? :up
+      end
+
+      def exec_ps
+        # Run the compose configuration
+        exec_compose 'ps'
       end
 
       def exec_stop
@@ -95,6 +100,12 @@ module Docker
         system 'docker ps -a'
       end
 
+      def exec_bash(service_name)
+        # docker exec -it 222_db_1 bash
+        container_name = get_container_name(service_name)
+        exec "docker exec -it #{container_name} bash"
+      end
+
       protected
 
       def exec(cmd, capture = false)
@@ -110,8 +121,8 @@ module Docker
       end
 
       # convenience to execute docker-compose with file and project params
-      def exec_compose(cmd, capture = false)
-        exec("docker-compose -f #{@compose_filename} -p #{App.instance.build_name} #{cmd}", capture)
+      def exec_compose(cmd, capture = false, options = '')
+        exec("docker-compose -f #{@compose_filename} -p #{@build} #{cmd} #{options}", capture)
       end
 
       # service_name i.e. 'db' or 'web'
@@ -157,8 +168,8 @@ module Docker
 
       def set_gems_volume_vars
         # Set as variable for interpolation
-        ENV['GEMS_VOLUME_PATH'] = @gems_volume_path = "/gems/#{@ruby_version}"
-        ENV['GEMS_VOLUME_NAME'] = @gems_volume_name = "gems-#{@ruby_version}"
+        ENV['DOCKER_RAILS_GEMS_VOLUME_PATH'] = @gems_volume_path = "/gems/#{@ruby_version}"
+        ENV['DOCKER_RAILS_GEMS_VOLUME_NAME'] = @gems_volume_name = "gems-#{@ruby_version}"
       end
 
       def discover_ruby_version
@@ -168,8 +179,8 @@ module Docker
       end
 
       # accessible so that we can delete patterns
-      def compose_filename_from(build_name, environment_name)
-        "docker-compose-build-#{build_name}-#{environment_name}.yml"
+      def compose_filename_from(build, target)
+        "docker-compose-#{target}-#{build}.yml"
       end
     end
   end

data/lib/docker/rails/cli/gems_volume.rb

@@ -6,9 +6,9 @@ module Docker
         default_task :help
 
         desc 'create', 'Create a gem volume'
-        def create(build_name = nil, environment_name = nil)
+        def create(target = nil)
           # Create global gems data volume to cache gems for this version of ruby
-          app = App.configured(build_name, environment_name)
+          app = App.configured(target, options)
           begin
             Docker::Container.get(app.gems_volume_name)
             puts "Gem data volume container #{app.gems_volume_name} already exists."

data/lib/docker/rails/cli/main.rb

@@ -4,112 +4,133 @@ module Docker
       class Main < Thor
         # default_task :help
 
-        desc 'db_check <db>', 'Runs db_check'
-        subcommand 'db_check', Docker::Rails::CLI::DbCheck
+        class_option :build, aliases: ['-b'], type: :string, desc: 'Build name e.g. 123', default: '1'
 
+        desc 'db_check <db>', 'Runs db_check e.g. bundle exec docker-rails db_check mysql'
+        subcommand 'db_check', Docker::Rails::CLI::DbCheck
 
-        desc 'gems_volume <command>', 'Gems volume management'
+        desc 'gems_volume <command>', 'Gems volume management e.g. bundle exec docker-rails gems_volume create'
         subcommand 'gems_volume', Docker::Rails::CLI::GemsVolume
 
-
-        desc 'ci <build_name> <environment_name>', 'Execute the works, everything with cleanup included i.e. bundle exec docker-rails ci 222 test'
+        desc 'ci <target>', 'Execute the works, everything with cleanup included e.g. bundle exec docker-rails ci --build=222 test'
         long_desc <<-D
 
-          `ci` will run the targeted environment_name with the given build number then cleanup everything upon completion.
+          `ci` will run the target with the given build (-b) number then cleanup everything upon completion.
           While it is named `ci`, there is no harm in using this for other environments as long as you understand that volumes
           and remaining dangling images will be cleaned up upon completion.
         D
 
-        def ci(build_name, environment_name)
+        def ci(target)
+          # init singleton with full options
+          App.configured(target, options)
+
           invoke :compose
-          invoke CLI::GemsVolume, :create
+          invoke CLI::GemsVolume, :create, [target], options
           invoke :before
           begin
             invoke :up
           ensure
-            invoke :stop
-            invoke :rm_volumes
-            invoke :rm_compose
-            invoke :rm_dangling
-            invoke :show_all_containers
+            invoke :cleanup
           end
         end
 
-        desc 'compose <build_name> <environment_name>', 'Writes a resolved docker-compose.yml file'
-
-        def compose(build_name, environment_name)
-          App.configured(build_name, environment_name).compose
+        desc 'cleanup <target>', 'Runs container cleanup functions stop, rm_volumes, rm_compose, rm_dangling, ps_all e.g. bundle exec docker-rails cleanup --build=222 development'
+        def cleanup(target)
+          invoke :stop
+          invoke :rm_volumes
+          invoke :rm_compose
+          invoke :rm_dangling
+          invoke :ps_all
         end
 
-        desc 'before <build_name> <environment_name>', 'Invoke before_command', hide: true
+        desc 'up <target>', 'Up the docker-compose configuration for the given build/target. Use -d for detached mode. e.g. bundle exec docker-rails up -d --build=222 test'
 
-        def before(build_name, environment_name)
-          invoke :compose
-          App.configured(build_name, environment_name).exec_before_command
+        option :detached, aliases: ['-d'], type: :boolean, desc: 'Detached mode: Run containers in the background'
+
+        def up(target)
+          # init singleton with full options
+          app = App.configured(target, options)
+          base_options = options.except(:detached)
+
+          invoke CLI::GemsVolume, :create, [target], base_options
+          invoke :before, [target], base_options
+
+          compose_options = ''
+          compose_options = '-d' if options[:detached]
+
+          app.exec_up(compose_options)
         end
 
-        desc 'up <build_name> <environment_name>', 'Up the docker-compose configuration for the given build_name/environment_name'
+        desc 'compose <target>', 'Writes a resolved docker-compose.yml file e.g. bundle exec docker-rails compose --build=222 test'
 
-        def up(build_name, environment_name)
+        def compose(target)
+          App.configured(target, options).compose
+        end
 
-          invoke CLI::GemsVolume, :create
-          invoke :before
-          App.configured(build_name, environment_name).exec_up
+        desc 'before <target>', 'Invoke before_command', hide: true
+
+        def before(target)
+          invoke :compose, [target]
+          App.configured(target, options).exec_before_command
         end
 
-        desc 'stop <build_name> <environment_name>', 'Stop all running containers for the given build_name/environment_name'
 
-        def stop(build_name, environment_name)
+        desc 'stop <target>', 'Stop all running containers for the given build/target e.g. bundle exec docker-rails stop --build=222 development'
+
+        def stop(target)
           invoke :compose
-          App.configured(build_name, environment_name).exec_stop
+          App.configured(target, options).exec_stop
         end
 
-        desc 'rm_volumes <build_name> <environment_name>', 'Stop all running containers and remove corresponding volumes for the given build_name/environment_name'
+        desc 'rm_volumes <target>', 'Stop all running containers and remove corresponding volumes for the given build/target e.g. bundle exec docker-rails rm_volumes --build=222 development'
 
-        def rm_volumes(build_name, environment_name)
+        def rm_volumes(target)
           invoke :stop
-          App.configured(build_name, environment_name).exec_remove_volumes
+          App.configured(target, options).exec_remove_volumes
         end
 
-        desc 'rm_compose', 'Remove generated docker_compose file'
+        desc 'rm_compose', 'Remove generated docker_compose file e.g. bundle exec docker-rails rm_compose --build=222 development'
 
-        def rm_compose(build_name = nil, environment_name = nil)
+        def rm_compose(build = nil, target = nil)
           App.instance.rm_compose
         end
 
-        desc 'rm_dangling', 'Remove danging images'
+        desc 'rm_dangling', 'Remove danging images e.g. bundle exec docker-rails rm_dangling'
 
-        def rm_dangling(build_name = nil, environment_name = nil)
+        def rm_dangling(build = nil, target = nil)
           App.instance.rm_dangling
         end
 
-        desc 'show_all_containers', 'Show all remaining containers regardless of state'
+        desc 'ps <target>', 'List containers for the target compose configuration e.g. bundle exec docker-rails ps --build=222 development'
+
+        def ps(target)
+          invoke :compose
+          App.configured(target, options).exec_ps
+        end
+
+        desc 'ps_all', 'List all remaining containers regardless of state e.g. bundle exec docker-rails ps_all'
 
-        def show_all_containers(build_name = nil, environment_name = nil)
+        def ps_all(build = nil, target = nil)
           App.instance.show_all_containers
         end
 
+        desc 'bash <target> <service_name>', 'Open a bash shell to a running container e.g. bundle exec docker-rails bash --build=222 development db'
+
+        def bash(target, service_name)
+          # init singleton with full options
+          app = App.configured(target, options)
+
+          invoke :compose, [target], []
+
+          app.exec_bash(service_name)
+        end
+
+
+        protected
 
-        # desc 'hello NAME', 'This will greet you'
-        # long_desc <<-HELLO_WORLD
-        #
-        # `hello NAME` will print out a message to the person of your choosing.
-        #
-        # Brian Kernighan actually wrote the first "Hello, World!" program
-        # as part of the documentation for the BCPL programming language
-        # developed by Martin Richards. BCPL was used while C was being
-        # developed at Bell Labs a few years before the publication of
-        # Kernighan and Ritchie's C book in 1972.
-        #
-        # http://stackoverflow.com/a/12785204
-        # HELLO_WORLD
-        #
-        # option :upcase
-        #
-        # def hello(name)
-        #   greeting = "Hello, #{name}"
-        #   greeting.upcase! if options[:upcase]
-        #   puts greeting
+        # invoke with an empty set of options
+        # def invoke_new(command, options=[])
+        #   invoke command, nil, options
         # end
       end
     end

data/lib/docker/rails/core_ext/hash.rb

@@ -0,0 +1,21 @@
+class Hash
+  # Returns a hash that includes everything but the given keys.
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.except(:c) # => { a: true, b: false}
+  #   hash # => { a: true, b: false, c: nil}
+  #
+  # This is useful for limiting a set of parameters to everything but a few known toggles:
+  #   @person.update(params[:person].except(:admin))
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.except!(:c) # => { a: true, b: false}
+  #   hash # => { a: true, b: false }
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/lib/docker/rails/version.rb

@@ -1,5 +1,5 @@
 module Docker
   module Rails
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

data/spec/docker/rails/docker-rails.yml

@@ -141,12 +141,12 @@ compose:
 
     volumes_from:
       # Mount the gems data volume container for cached bundler gem files
-      - #{GEMS_VOLUME_NAME}
+      - #{DOCKER_RAILS_GEMS_VOLUME_NAME}
 
     # https://docs.docker.com/v1.6/compose/cli/#environment-variables
     environment:
       # Tell bundler where to get the files
-      - GEM_HOME=#{GEMS_VOLUME_PATH}
+      - GEM_HOME=#{DOCKER_RAILS_GEMS_VOLUME_PATH}
 
   db:
     # https://github.com/docker-library/docs/tree/master/mysql

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docker-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kevin Ross
@@ -148,6 +148,7 @@ files:
 - lib/docker/rails/cli/main.rb
 - lib/docker/rails/compose_config.rb
 - lib/docker/rails/config.rb
+- lib/docker/rails/core_ext/hash.rb
 - lib/docker/rails/version.rb
 - spec/docker/rails/config_spec.rb
 - spec/docker/rails/docker-rails.yml