docker-rails 0.0.2 → 0.1.0

data/docker-rails.gemspec

@@ -20,9 +20,11 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'bundler', '~> 1.6'
   s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'mysql2', '~> 0.3.18' # http://stackoverflow.com/a/32466950/2363935
+  s.add_development_dependency 'activerecord'
 
   s.add_dependency 'docker-api'
-  # s.add_dependency 'parallel_tests'
-  s.add_dependency 'dry-config', '>= 1.1.6'
-  s.add_dependency 'mysql2', '~> 0.3.18' # http://stackoverflow.com/a/32466950/2363935
+  s.add_dependency 'dry-config', '>= 1.2.6'
+  s.add_dependency 'thor'
 end

data/lib/docker/rails.rb

@@ -5,4 +5,14 @@ module Docker
   end
 end
 
-require 'docker/rails/compose_config'
+require 'thor'
+require 'docker'
+
+require 'docker/rails/config'
+require 'docker/rails/compose_config'
+require 'docker/rails/app'
+
+require 'docker/rails/cli/db_check'
+require 'docker/rails/cli/gems_volume'
+
+require 'docker/rails/cli/main'

data/lib/docker/rails/CLI/db_check.rb

@@ -0,0 +1,67 @@
+module Docker
+  module Rails
+    module CLI
+      require 'thor'
+      class DbCheck < Thor
+
+        default_task :help
+
+        desc 'mysql', 'Ping and wait for mysql database to be up'
+        option :count, default: 60, desc: 'Number of attempts'
+        option :host, default: 'db'
+        option :port, default: 3306
+        option :username, default: 'root'
+        option :password, desc: 'Password-less login if unspecified'
+
+        def mysql
+
+          App.instance
+
+          # ping db to see if it is ready before continuing
+          require 'rubygems'
+          require 'active_record'
+          require 'mysql2'
+
+          puts "\n"
+          connect_string = "#{options[:username]}@#{options[:host]}:#{options[:port]}"
+          printf "Waiting for confirmation of db service startup at #{connect_string}..."
+          last_message = ''
+          loop_limit = options[:count].to_i + 1
+          loop_limit.times do |i|
+            if i == loop_limit - 1
+              printf "failed to connect.  #{last_message}\n\n\n"
+              raise "Failed to connect to db service at #{connect_string}.  #{last_message}"
+            end
+
+            connection_options = {
+                adapter: 'mysql2',
+                host: options[:host],
+                port: options[:port],
+                username: options[:username]
+            }
+
+            #puts "Password is nil? #{options[:password].nil?}, |#{options[:password]}|"
+
+            connection_options[:password] = options[:password] unless options[:password].nil?
+
+            ActiveRecord::Base.establish_connection (connection_options)
+            connected =
+                begin
+                  ActiveRecord::Base.connection_pool.with_connection { |con| con.active? }
+                rescue => e
+                  last_message = "#{e.class.name}: #{e.message}"
+                  false
+                end
+            printf '.'
+            if connected
+              printf 'connected.'
+              break
+            end
+            sleep 1
+          end
+          puts "\n"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Docker
+  module Rails
+    module CLI
+      class GemsVolume < Thor
+
+        default_task :help
+
+        desc 'create', 'Create a gem volume'
+        def create(build_name = nil, environment_name = nil)
+          # Create global gems data volume to cache gems for this version of ruby
+          app = App.configured(build_name, environment_name)
+          begin
+            Docker::Container.get(app.gems_volume_name)
+            puts "Gem data volume container #{app.gems_volume_name} already exists."
+          rescue Docker::Error::NotFoundError => e
+
+            exec "docker create -v #{app.gems_volume_path} --name #{app.gems_volume_path} busybox"
+            puts "Gem data volume container #{app.gems_volume_name} created."
+          end
+        end
+
+
+        # TODO: add destroy volume
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Docker
+  module Rails
+    module CLI
+      class Main < Thor
+        # default_task :help
+
+        desc 'db_check <db>', 'Runs db_check'
+        subcommand 'db_check', Docker::Rails::CLI::DbCheck
+
+
+        desc 'gems_volume <command>', 'Gems volume management'
+        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'
+        long_desc <<-D
+
+          `ci` will run the targeted environment_name with the given build 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)
+          invoke :compose
+          invoke CLI::GemsVolume, :create
+          invoke :before
+          begin
+            invoke :up
+          ensure
+            invoke :stop
+            invoke :rm_volumes
+            invoke :rm_compose
+            invoke :rm_dangling
+            invoke :show_all_containers
+          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
+        end
+
+        desc 'before <build_name> <environment_name>', 'Invoke before_command', hide: true
+
+        def before(build_name, environment_name)
+          invoke :compose
+          App.configured(build_name, environment_name).exec_before_command
+        end
+
+        desc 'up <build_name> <environment_name>', 'Up the docker-compose configuration for the given build_name/environment_name'
+
+        def up(build_name, environment_name)
+
+          invoke CLI::GemsVolume, :create
+          invoke :before
+          App.configured(build_name, environment_name).exec_up
+        end
+
+        desc 'stop <build_name> <environment_name>', 'Stop all running containers for the given build_name/environment_name'
+
+        def stop(build_name, environment_name)
+          invoke :compose
+          App.configured(build_name, environment_name).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'
+
+        def rm_volumes(build_name, environment_name)
+          invoke :stop
+          App.configured(build_name, environment_name).exec_remove_volumes
+        end
+
+        desc 'rm_compose', 'Remove generated docker_compose file'
+
+        def rm_compose(build_name = nil, environment_name = nil)
+          App.instance.rm_compose
+        end
+
+        desc 'rm_dangling', 'Remove danging images'
+
+        def rm_dangling(build_name = nil, environment_name = nil)
+          App.instance.rm_dangling
+        end
+
+        desc 'show_all_containers', 'Show all remaining containers regardless of state'
+
+        def show_all_containers(build_name = nil, environment_name = nil)
+          App.instance.show_all_containers
+        end
+
+
+        # 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
+        # end
+      end
+    end
+  end
+end

data/lib/docker/rails/app.rb

@@ -0,0 +1,176 @@
+module Docker
+  module Rails
+    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
+
+      class << self
+        def configured(build_name, environment_name)
+          app = App.instance
+          if app.is_configured?
+            puts "Already configured"
+          else
+            app.configure(build_name: build_name, environment_name: environment_name)
+          end
+          app
+        end
+      end
+
+      def initialize
+        discover_ruby_version
+        set_gems_volume_vars
+      end
+
+      def configure(options)
+        ENV['BUILD_NAME'] = @build_name = options[:build_name]
+        @environment_name = options[:environment_name]
+
+        # load the docker-rails.yml
+        @config = Docker::Rails::Config.new
+        @config.load!(@environment_name)
+
+        @is_configured = true
+      end
+
+      def is_configured?
+        @is_configured || false
+      end
+
+      def compose
+        # Write a docker-compose.yml with interpolated variables
+        @compose_filename = compose_filename_from @build_name, @environment_name
+
+        rm_compose
+
+        @config.write_docker_compose_file(@compose_filename)
+
+        @compose_config = Docker::Rails::ComposeConfig.new
+        @compose_config.load!(nil, @compose_filename)
+      end
+
+      def rm_compose
+        # Delete old docker compose files
+        exec "rm #{compose_filename_from '*', '*'}" rescue ''
+      end
+
+      def exec_before_command
+        before_command = @config['before_command']
+        (exec before_command unless before_command.nil?) #unless skip? :before_command
+      end
+
+      def exec_up
+        # Run the compose configuration
+        exec_compose 'up' #unless skip? :up
+      end
+
+      def exec_stop
+        puts "\n\n\n\nStopping containers..."
+        puts '-----------------------------'
+        @compose_config.each_key do |service_name|
+          stop(service_name)
+        end
+        # puts "\nDone."
+      end
+
+      def exec_remove_volumes
+        puts "\n\nRemoving container volumes..."
+        puts '-----------------------------'
+        @compose_config.each_key do |service_name|
+          rm_v(service_name)
+        end
+        # puts "\nDone."
+      end
+
+      def rm_dangling
+        puts "\n\nCleaning up dangling images..."
+        puts '-----------------------------'
+        exec 'docker images --filter dangling=true -q | xargs docker rmi'
+        # puts "\nDone."
+      end
+
+      def show_all_containers
+        puts "\n\nAll remaining containers..."
+        puts '-----------------------------'
+        system 'docker ps -a'
+      end
+
+      protected
+
+      def exec(cmd, capture = false)
+        puts "Running `#{cmd}`" if verbose?
+        if capture
+          output = %x[#{cmd}]
+        else
+          system cmd
+        end
+
+        raise "Failed to execute: `#{cmd}`" unless $?.success?
+        output
+      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)
+      end
+
+      # service_name i.e. 'db' or 'web'
+      def get_container_name(service_name)
+        output = exec_compose "ps #{service_name}", true
+        # puts "get_container(#{service_name}): \n#{output}"
+        output =~ /^(\w+)/ # grab the name, only thing that is at the start of the line
+        $1
+      end
+
+      # def up_service(service_name, options = '')
+      #   exec_compose "up #{options} #{service_name}"
+      #   container_name = get_container_name(service_name)
+      #   puts "#{service_name}: container_name #{container_name}"
+      #
+      #   container = Docker::Container.get(container_name)
+      #   # container.streaming_logs(stdout: true) { |stream, chunk| puts "#{service_name}: #{chunk}" }
+      #   # puts container
+      #
+      #   {service_name => {'container' => container, 'container_name' => container_name}}
+      # end
+
+      def rm_v(service_name)
+        exec_compose "rm -v --force #{service_name}"
+      end
+
+      def stop(service_name)
+        exec_compose "stop #{service_name}"
+      end
+
+      # def skip?(command)
+      #   skips = @config[:skip]
+      #   return false if skips.nil?
+      #   skip = skips.include? command.to_s
+      #   puts "Skipping #{command}" if skip && verbose?
+      #   skip
+      # end
+
+
+      def verbose?
+        @verbose ||= (@config['verbose'] unless @config.nil?) || false
+      end
+
+      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}"
+      end
+
+      def discover_ruby_version
+        # Discover ruby version from the Dockerfile image
+        IO.read('Dockerfile') =~ /^FROM \w+\/ruby:(\d+.\d+(?:.\d+))/
+        @ruby_version = $1
+      end
+
+      # accessible so that we can delete patterns
+      def compose_filename_from(build_name, environment_name)
+        "docker-compose-build-#{build_name}-#{environment_name}.yml"
+      end
+    end
+  end
+end

data/lib/docker/rails/config.rb

@@ -0,0 +1,40 @@
+module Docker
+  module Rails
+    require 'dry/config'
+    class Config < Dry::Config::Base
+      def initialize(options = {})
+        super({
+                  default_configuration: {
+                      verbose: false
+
+                  },
+                  prune: [:development, :test, :parallel_tests, :staging, :production]
+              }.merge(options))
+      end
+
+      def load!(environment, *filenames)
+        if environment.nil?
+          puts 'Environment unspecified, generating docker-compose.yml based on root docker-compose yaml key.'
+          environment = 'docker-compose'
+        end
+
+        if filenames.empty?
+          puts 'Using docker-rails.yml'
+          filenames = ['docker-rails.yml']
+        end
+
+        super(environment, *filenames)
+      end
+
+      def write_docker_compose_file(output_filename = 'docker-compose.yml')
+        write_yaml_file(output_filename, self[:'docker-compose'])
+      end
+
+      def to_yaml(config = @configuration)
+        yaml = super(config)
+        yaml = yaml.gsub(/command: .$/, 'command: >')
+        yaml
+      end
+    end
+  end
+end