percheron 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61e4d66006bf086c797d921852dae42438f8abca
-  data.tar.gz: b91b6698c444e51757bee46fa5f290b67211670b
+  metadata.gz: cbab3f52787ff0b165f9482186771b07ff673df1
+  data.tar.gz: ce6eb63e3621d595f814c8806728bfe9b43fae7b
 SHA512:
-  metadata.gz: 9a136f407d6823d6983723a36ea9056f56e440411e56df65e2101348fbb4dcd957027f570a9af29b21f9e5c273698ca9a460a05666fa79353577413c00e8892e
-  data.tar.gz: b87043f174f595bd1aed913e087089575d7ee602d5a46a5810d01c98aebd38d4816aa1a45145f2b7b685fb443bb1fd4d10c29a3e7ed0dc8396048a0299bbb97c
+  metadata.gz: 4b198258dc8f5226a08563b77d1826af3f56eea705c35632d85bbca4d9e49be216c17fc5b776404fe7caac50ac2e84aa1d5c507493faf4edbaf110b276a1c3bc
+  data.tar.gz: f790fdeb14e59ce702f5569ea4043fd4747acfd6bc91934ed86646be290bd7e7d98782e049c0da198e9446f9b83d20e7724e7d17e8229502825172bc8d940077

data/.cane

@@ -0,0 +1,4 @@
+--abc-glob ./lib/**/*.rb
+--style-glob ./lib/**/*.rb
+--style-measure 100
+--no-doc

data/.gitignore

@@ -9,3 +9,4 @@
 /tmp/
 .ruby-version
 percheron.sublime-*
+.envrc

data/.rubocop.yml

@@ -0,0 +1,31 @@
+Style/SpaceInsideBrackets:
+  Enabled: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/IndentationConsistency:
+  Enabled: false
+
+Style/FormatString:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false
+
+Style/RegexpLiteral:
+  EnforcedStyle: mixed
+  AllowInnerSlashes: false
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 150
+
+Style/SpaceAroundEqualsInParameterDefault:
+  Enabled: false

data/.travis.yml

@@ -5,4 +5,7 @@ branches:
   only:
     - master
     - wip
-script: bundle exec rake spec
+script:
+  - bundle exec cane
+  - bundle exec rubocop
+  - bundle exec rake spec:unit

data/Guardfile

@@ -1,5 +1,5 @@
 guard :rspec, cmd: 'bundle exec rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^spec\/.+_spec\.rb$})
+  watch(%r{^lib\/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { 'spec' }
 end

data/README.md

@@ -6,8 +6,6 @@
 [![Test Coverage](https://codeclimate.com/github/ashmckenzie/percheron/badges/coverage.svg)](https://codeclimate.com/github/ashmckenzie/percheron)
 [![Dependency Status](https://gemnasium.com/ashmckenzie/percheron.svg)](https://gemnasium.com/ashmckenzie/percheron)
 
-![Percheron](https://raw.githubusercontent.com/ashmckenzie/percheron/master/assets/percheron.png)
-
 Organise your Docker containers with muscle and intelligence.
 
 ## Installation
@@ -30,9 +28,27 @@ Or install it yourself as:
 $ gem install percheron
 ```
 
+## Requirements
+
+* Ruby 2.x
+* Docker 1.6.x
+
 ## Usage
 
-WIP, not ready yet :)
+TODO
+
+## Examples
+
+* Rails - https://github.com/ashmckenzie/percheron-rails#quickstart
+* Torrent - https://github.com/ashmckenzie/percheron-torrent#quickstart
+
+## Testing
+
+All (cane, RuboCop, unit and integration):
+
+```shell
+bundle exec test
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,4 +1,27 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'cane/rake_task'
+require 'rubocop/rake_task'
 
-RSpec::Core::RakeTask.new('spec')
+desc 'Run cane, rubocop, unit and integration tests'
+task test: %w(test:cane test:rubocop spec:unit spec:integration)
+
+namespace :test do
+  desc 'Run cane'
+  Cane::RakeTask.new(:cane)
+
+  desc 'Run RuboCop'
+  RuboCop::RakeTask.new
+end
+
+RSpec::Core::RakeTask.new('spec') do |config|
+  config.pattern = './spec/**{,/*/**}/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:unit') do |config|
+  config.pattern = './spec/unit/**{,/*/**}/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('spec:integration') do |config|
+  config.pattern = './spec/integration/**{,/*/**}/*_spec.rb'
+end

data/bin/percheron

@@ -3,28 +3,10 @@
 lib = File.expand_path('../../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require 'logger'
 require 'percheron'
 require 'percheron/commands'
-
-$metastore = Metastore::Cabinet.new(File.join(ENV['HOME'], '.percheron', 'metastore.yaml'))
-$logger = Logger.new(STDOUT)
-
-logger_level = Logger::INFO
-
-if ENV['QUIET'] == 'true'
-  logger_level = Logger::WARN
-end
-
-if ENV['DEBUG'] == 'true' || ENV['DOCKER_DEBUG'] == 'true'
-  require 'pry-byebug'
-  require 'awesome_print'
-  logger_level = Logger::DEBUG
-
-  Docker.logger = $logger if ENV['DOCKER_DEBUG'] == 'true'
-end
-
-$logger.level = logger_level
+require 'percheron/logger'
+require 'percheron/metastore'
 
 begin
   Percheron::Commands::Main.run

data/lib/percheron/actions/base.rb

@@ -1,7 +1,6 @@
 module Percheron
   module Actions
     module Base
-
       def base_dir
         container.dockerfile.dirname.to_s
       end
@@ -13,44 +12,6 @@ module Percheron
       ensure
         Dir.chdir(old_dir)
       end
-
-      def now_timestamp
-        Time.now.strftime('%Y%m%d%H%M%S')
-      end
-
-      def insert_files!(files)
-        files.each do |file|
-          file = Pathname.new(File.expand_path(file, base_dir))
-          container.image.insert_local('localPath' => file.to_s, 'outputPath' => "/tmp/#{file.basename}").tap do |new_image|
-            new_image.tag(repo: container.name, tag: container.version.to_s, force: true)
-          end
-        end
-      end
-
-      def stop_containers!(containers)
-        exec_on_containers!(containers) do |container|
-          if container.running?
-            $logger.debug "Stopping '#{container.name}' container"
-            Stop.new(container).execute!
-          end
-        end
-      end
-
-      def start_containers!(containers, exec_scripts: true)
-        exec_on_containers!(containers) do |container|
-          unless container.running?
-            $logger.debug "Starting '#{container.name}' container"
-            Start.new(container, dependant_containers: container.dependant_containers.values, exec_scripts: exec_scripts).execute!
-          end
-        end
-      end
-
-      def exec_on_containers!(containers)
-        containers.inject([]) do |all, container|
-          all << container if yield(container)
-          all
-        end.compact
-      end
     end
   end
 end

data/lib/percheron/actions/build.rb

@@ -4,22 +4,24 @@ module Percheron
 
       include Base
 
-      def initialize(container, nocache: false)
+      def initialize(container, nocache: false, exec_scripts: true)
         @container = container
         @nocache = nocache
+        @exec_scripts = exec_scripts
       end
 
       def execute!
         results = []
-        results << build!
+        results << build! if container.buildable?
         results.compact.empty? ? nil : container
       end
 
       private
 
-        attr_reader :container, :nocache
+        attr_reader :container, :nocache, :exec_scripts
+        alias_method :exec_scripts?, :exec_scripts
 
-        def build_opts
+        def options
           {
             'dockerfile'  => container.dockerfile.basename.to_s,
             't'           => container.image_name,
@@ -30,18 +32,18 @@ module Percheron
 
         def build!
           in_working_directory(base_dir) do
-            execute_pre_build_scripts!  unless container.pre_build_scripts.empty?
+            execute_pre_build_scripts!
             $logger.info "Building '#{container.image_name}' image"
-            Docker::Image.build_from_dir(base_dir, build_opts) do |out|
+            Docker::Image.build_from_dir(base_dir, options) do |out|
               $logger.debug '%s' % [ out.strip ]
             end
           end
         end
 
         def execute_pre_build_scripts!
+          return nil if !exec_scripts? && container.pre_build_scripts.empty?
           ExecLocal.new(container, container.pre_build_scripts, 'PRE build').execute!
         end
-
     end
   end
 end

data/lib/percheron/actions/create.rb

@@ -4,37 +4,44 @@ module Percheron
 
       include Base
 
-      def initialize(container, recreate: false)
+      def initialize(container, start: false, cmd: false, exec_scripts: true)
         @container = container
-        @recreate = recreate
+        @start = start
+        @exec_scripts = exec_scripts
+        @cmd = cmd
+        @container_image_existed = container.image_exists?
       end
 
-      def execute!(opts={})
+      def execute!
         results = []
-        if recreate? || !container.exists?
-          results << create!(opts)
-        else
+        if container.exists?
           $logger.debug "Container '#{container.name}' already exists"
+        else
+          results << create!
         end
         results.compact.empty? ? nil : container
       end
 
       private
 
-        attr_reader :container, :recreate
+        attr_reader :container, :start, :exec_scripts, :container_image_existed
+        alias_method :start?, :start
+        alias_method :exec_scripts?, :exec_scripts
+        alias_method :container_image_existed?, :container_image_existed
+
+        def cmd
+          @cmd ||= (@cmd || container.start_args)
+        end
 
         def base_options
           {
-            'name'          => container.name,
+            'name'          => container.full_name,
             'Image'         => container.image_name,
-            'Hostname'      => container.name,
+            'Hostname'      => container.hostname,
             'Env'           => container.env,
             'ExposedPorts'  => container.exposed_ports,
-            'HostConfig'    => {
-              'PortBindings'  => port_bindings,
-              'Links'         => container.links,
-              'Binds'         => container.volumes
-            }
+            'Cmd'           => cmd,
+            'Labels'        => container.labels
           }
         end
 
@@ -43,55 +50,74 @@ module Percheron
             'HostConfig'    => {
               'PortBindings'  => port_bindings,
               'Links'         => container.links,
-              'Binds'         => container.volumes
+              'Binds'         => container.volumes,
+              'Dns'           => container.dns
             }
           }
         end
 
+        def options
+          @options ||= base_options.merge(host_config_options)
+        end
+
         def port_bindings
-          container.ports.inject({}) do |all, p|
+          container.ports.each_with_object({}) do |p, all|
             destination, source = p.split(':')
             all[source] = [ { 'HostPort' => destination } ]
-            all
           end
         end
 
-        def recreate?
-          recreate
-        end
-
-        def create!(opts)
-          build_image! unless container.image_exists?
+        def create!
+          container.buildable? ? build_image! : pull_image!
+          return unless container.startable?
           insert_scripts!
-          create_container!(opts.fetch(:create, {}))
-          execute_post_create_scripts! unless container.post_create_scripts.empty?
-          set_dockerfile_md5!
+          create_container!
+          update_dockerfile_md5!
+          start!
         end
 
         def build_image!
-          Build.new(container).execute!
+          Build.new(container).execute! unless container.image_exists?
         end
 
-        def insert_scripts!
-          insert_files!(container.post_create_scripts)
-          insert_files!(container.post_start_scripts)
+        # FIXME: move this
+        def pull_image!
+          return nil if container.image_exists?
+          $logger.info "Pulling '#{container.image_name}' image"
+          Docker::Image.create(fromImage: container.image_name) do |out|
+            $logger.debug JSON.parse(out)
+          end
         end
 
-        def create_container!(opts)
-          options = base_options.merge(host_config_options).merge(opts)
-          $logger.info "Creating '%s' container" % options['name']
+        def create_container!
+          $logger.info "Creating '#{container.name}' container"
           Docker::Container.create(options)
         end
 
-        def execute_post_create_scripts!
-          Exec.new(container, container.dependant_containers.values, container.post_create_scripts, 'POST create').execute!
+        def start!
+          return nil if !container.startable? || !start?
+          Start.new(container).execute!
         end
 
-        def set_dockerfile_md5!
-          $logger.info "Setting MD5 for '#{container.name}' container to #{container.current_dockerfile_md5}"
-          $metastore.set("#{container.metastore_key}.dockerfile_md5", container.current_dockerfile_md5)
+        def update_dockerfile_md5!
+          container.update_dockerfile_md5!
         end
 
+        def insert_scripts!
+          return nil if container_image_existed?
+          insert_files!(container.post_start_scripts)
+        end
+
+        def insert_files!(files)
+          files.each { |file| insert_file!(file) }
+        end
+
+        def insert_file!(file)
+          file = Pathname.new(File.expand_path(file, base_dir))
+          opts = { 'localPath' => file.to_s, 'outputPath' => "/tmp/#{file.basename}" }
+          new_image = container.image.insert_local(opts)
+          new_image.tag(repo: container.image_repo, tag: container.version.to_s, force: true)
+        end
     end
   end
 end

data/lib/percheron/actions/exec.rb

@@ -12,11 +12,8 @@ module Percheron
       end
 
       def execute!
-        results = []
-        $logger.debug "Executing #{description} scripts '#{scripts.inspect}' on '#{container.name}'"
-        started_dependant_containers = start_containers!(dependant_containers)
-        results << execute_scripts_on_running_container!
-        results << stop_containers!(started_dependant_containers)
+        $logger.debug "Executing #{description} #{scripts.inspect} on '#{container.name}' container"
+        results = exec!
         results.compact.empty? ? nil : container
       end
 
@@ -24,29 +21,64 @@ module Percheron
 
         attr_reader :container, :dependant_containers, :scripts, :description
 
+        def exec!
+          results = []
+          started_dependant_containers = start_containers!(dependant_containers)
+          results << execute_scripts_on_running_container!
+          results << stop_containers!(started_dependant_containers)
+          results
+        end
+
         def execute_scripts_on_running_container!
           container_running = container.running?
           Start.new(container, exec_scripts: false).execute! unless container_running
           execute_scripts!
+          commit_and_tag_new_image!
           Stop.new(container).execute!  unless container_running
         end
 
+        # FIXME
+        def commit_and_tag_new_image!
+          new_image = container.docker_container.commit
+          new_image.tag(repo: container.image_repo, tag: container.version.to_s, force: true)
+        end
+
         def execute_scripts!
           scripts.each do |script|
             in_working_directory(base_dir) do
               file = Pathname.new(File.expand_path(script, base_dir))
-              execute_command!('/bin/bash -x /tmp/%s 2>&1' % file.basename)
+              execute_command!('/bin/sh /tmp/%s 2>&1' % file.basename)
             end
           end
         end
 
         def execute_command!(command)
           $logger.info "Executing #{description} '#{command}' for '#{container.name}' container"
-          container.docker_container.exec(command.split(' ')) do |device, out|
-            $logger.debug '%s: %s' % [ device, out.strip ]
+          container.docker_container.exec(command.split(' ')) do |stream, out|
+            $logger.debug '%s: %s' % [ stream, out.strip ]
+          end
+        end
+
+        def stop_containers!(containers)
+          exec_on_containers!(containers) do |container|
+            Stop.new(container).execute! if container.running?
+          end
+        end
+
+        def start_containers!(containers, scripts: true)
+          exec_on_containers!(containers) do |container|
+            next if container.running?
+            containers = container.startable_dependant_containers.values
+            Start.new(container, dependant_containers: containers, exec_scripts: scripts).execute!
           end
         end
 
+        def exec_on_containers!(containers)
+          containers.each_with_object([]) do |container, all|
+            all << container if yield(container)
+          end.compact
+        end
+
     end
   end
 end

data/lib/percheron/actions/exec_local.rb

@@ -26,15 +26,15 @@ module Percheron
           $logger.debug "Executing #{description} scripts '#{scripts.inspect}' locally"
           scripts.each do |script|
             in_working_directory(base_dir) do
-              execute_command!('/bin/bash -x %s 2>&1' % Pathname.new(File.expand_path(script)))
+              execute_command!('/bin/sh %s 2>&1' % Pathname.new(File.expand_path(script)))
             end
           end
         end
 
         def execute_command!(command)
-          $logger.info "Executing #{description} '#{command}' locally"
-          Open3.popen2e(command) do |stdin, stdout_stderr, wait_thr|
-            while line = stdout_stderr.gets
+          $logger.info "Executing #{description} script '#{command}' locally"
+          Open3.popen2e(command) do |_, stdout_stderr, _|
+            while (line = stdout_stderr.gets)
               $logger.debug line.strip
             end
           end

data/lib/percheron/actions/logs.rb

@@ -0,0 +1,44 @@
+module Percheron
+  module Actions
+    class Logs
+      include Base
+
+      def initialize(container, follow: false)
+        @container = container
+        @follow = follow
+      end
+
+      def execute!
+        $logger.debug "Showing logs on '#{container.name}' container"
+        display_logs!
+      end
+
+      private
+
+        attr_reader :container, :follow
+        alias_method :follow?, :follow
+
+        def options
+          {
+            stdout:     true,
+            stderr:     true,
+            timestamps: true,
+            tail:       100
+          }
+        end
+
+        def display_logs!
+          if follow?
+            opts = options.merge(follow: true)
+            container.docker_container.streaming_logs(opts) do |stream, chunk|
+              puts "#{stream}: #{chunk}"
+            end
+          else
+            puts container.docker_container.logs(options)
+          end
+        rescue Interrupt
+          nil
+        end
+    end
+  end
+end

data/lib/percheron/actions/purge.rb

@@ -4,34 +4,45 @@ module Percheron
 
       include Base
 
-      def initialize(container)
+      def initialize(container, delete_image: true)
         @container = container
+        @delete_image = delete_image
       end
 
       def execute!
         results = []
         results << stop!
-        results << delete_container! if container.exists?
-        results << delete_image!     if container.image_exists?
+        results << delete_container!
+        results << delete_image!
         results.compact.empty? ? nil : container
       end
 
       private
 
-        attr_reader :container
+        attr_reader :container, :delete_image
 
         def stop!
           Stop.new(container).execute!
         end
 
+        def delete_image?
+          delete_image && container.image_exists? && container.buildable?
+        end
+
         def delete_container!
+          return nil unless container.exists?
           $logger.info "Deleting '#{container.name}' container"
           container.docker_container.remove
+        rescue Docker::Error::ConflictError => e
+          $logger.error "Unable to delete '%s' container - %s" % [ container.name, e.inspect ]
         end
 
         def delete_image!
+          return nil unless delete_image?
           $logger.info "Deleting '#{container.image_name}' image"
           container.image.remove
+        rescue Docker::Error::ConflictError => e
+          $logger.error "Unable to delete '%s' image - %s" % [ container.image_name, e.inspect ]
         end
 
     end