percheron 0.7.16 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b3358819570477f97ff3f4c1b21b689a7007390
-  data.tar.gz: 04f82dae87c48a51b0ebff986bf4bab889036c7b
+  metadata.gz: 4c4858cd5f4ec9b26b7976179c56f074a1cb5570
+  data.tar.gz: 050b74b700b9c127766e5454eba7aea97c85ba7c
 SHA512:
-  metadata.gz: 4cafe93d3bddf33b7098cdae3aa87afbe4a4a27d78f65b3e3a36c96808cd9867bbd2881a3a6499f7f334d97a1f8565402129117c93b32cbe32b04a44432005d0
-  data.tar.gz: 502ca1ee96c79cda8f55b347cb1b3ba30f61645374540a057143ea4b3b6ff0cca0ce06ab450f982e812a315ecd5798b9cd12ca6e1875a5fe4550af62485a8e85
+  metadata.gz: 9865aad4f0d56c8e2607bd74dc579443d7c645afc20c1362b855ad867c09475080d5588ffcdf89f86ed89e5cf7ab0e3791b2f85cc8e91565b54fda597198ecb0
+  data.tar.gz: 438581d49d52687a2d06cf5d6bd538b3f1bf0df2dfe7b5dab655e1b2bd5a87f62fa5a194f559a3b41dfdf5bebeb32f54aadc24c0a4be3bdc5f6f510ee7bd31ef

data/.rubocop.yml

@@ -19,10 +19,6 @@ Metrics/LineLength:
 Style/GlobalVars:
   Enabled: false
 
-Style/RegexpLiteral:
-  EnforcedStyle: mixed
-  AllowInnerSlashes: false
-
 Metrics/ClassLength:
   CountComments: false
   Max: 150

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## v0.8.0 / 2015-08-19
+
+* Hostname is the full `<stack_name>_<name>` by default
+* Support for defining restart policy for each unit
+* Support privileged mode
+* Tidied up (re)create, (re)build and log commands
+* Improved logging and error handling
+
 ## v0.7.16 / 2015-08-07
 
 * Improved graph look

data/Guardfile

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

data/lib/percheron/actions/build.rb

@@ -1,12 +1,11 @@
 module Percheron
   module Actions
     class Build
-
       include Base
 
-      def initialize(unit, nocache: false, forcerm: false, exec_scripts: true)
+      def initialize(unit, usecache: true, forcerm: false, exec_scripts: true)
         @unit = unit
-        @nocache = nocache
+        @usecache = usecache
         @forcerm = forcerm
         @exec_scripts = exec_scripts
       end
@@ -22,15 +21,17 @@ module Percheron
 
       private
 
-        attr_reader :unit, :nocache, :forcerm, :exec_scripts
+        attr_reader :unit, :usecache, :forcerm, :exec_scripts
+        alias_method :usecache?, :usecache
+        alias_method :forcerm?, :forcerm
         alias_method :exec_scripts?, :exec_scripts
 
         def options
           {
             'dockerfile'  => dockerfile,
             't'           => unit.image_name,
-            'forcerm'     => forcerm,
-            'nocache'     => nocache
+            'forcerm'     => forcerm?,
+            'nocache'     => !usecache?
           }
         end
 
@@ -67,13 +68,19 @@ module Percheron
             execute_pre_build_scripts!
             $logger.info "Building '#{unit.image_name}' image"
             Connection.perform(Docker::Image, :build_from_dir, base_dir, options) do |out|
-              $logger.debug '%s' % [ out.strip ]
+              $logger.info '%s' % [ extract_content(out) ]
             end
           end
         ensure
           remove_temp_dockerfile!
         end
 
+        def extract_content(out)
+          json = JSON.parse(out)
+          return '' unless json['stream']
+          json['stream'].strip
+        end
+
         def execute_pre_build_scripts!
           return nil if !exec_scripts? && unit.pre_build_scripts.empty?
           ExecLocal.new(unit, unit.pre_build_scripts, 'PRE build').execute!

data/lib/percheron/actions/create.rb

@@ -1,36 +1,32 @@
 module Percheron
   module Actions
     class Create
-
       include Base
 
-      def initialize(unit, start: false, cmd: false, exec_scripts: true)
+      def initialize(unit, build: true, start: false, force: false, cmd: false)
         @unit = unit
+        @build = build
         @start = start
-        @exec_scripts = exec_scripts
-        @cmd = cmd
-        @unit_image_existed = unit.image_exists?
+        @force = force
+        @cmd = (cmd || unit.start_args)
       end
 
       def execute!
         results = []
-        if unit.exists?
-          $logger.debug "Unit '#{unit.display_name}' already exists"
-        else
-          results << create!
-        end
+        results << build_or_pull_image!
+        results << create!
         results.compact.empty? ? nil : unit
       end
 
       private
 
-        attr_reader :unit, :start, :exec_scripts, :unit_image_existed
+        attr_reader :unit, :build, :start, :force, :cmd
+        alias_method :build?, :build
         alias_method :start?, :start
-        alias_method :exec_scripts?, :exec_scripts
-        alias_method :unit_image_existed?, :unit_image_existed
+        alias_method :force?, :force
 
-        def cmd
-          @cmd ||= (@cmd || unit.start_args)
+        def create?
+          unit.startable? && (!unit.exists? || force)
         end
 
         def base_options
@@ -46,19 +42,25 @@ module Percheron
         end
 
         def host_config_options
-          config = {
-            'HostConfig'    => {
+          {
+            'HostConfig' => {
               'PortBindings'  => port_bindings,
               'Links'         => unit.links,
-              'Binds'         => unit.volumes
+              'Binds'         => unit.volumes,
+              'RestartPolicy' => unit.restart_policy,
+              'Privileged'    => unit.privileged
             }
           }
-          config['Dns'] = unit.dns unless unit.dns.empty?
-          config
+        end
+
+        def host_config_dns_options
+          unit.dns.empty? ? {} : { 'HostConfig' => { 'Dns' => unit.dns } }
         end
 
         def options
-          @options ||= base_options.merge(host_config_options)
+          @options ||= begin
+            base_options.merge(host_config_options).merge(host_config_dns_options)
+          end
         end
 
         def port_bindings
@@ -68,49 +70,58 @@ module Percheron
           end
         end
 
-        def create!
+        def build_or_pull_image!
           unit.buildable? ? build_image! : pull_image!
-          return unless unit.startable?
-          insert_scripts!
-          create_unit!
-          update_dockerfile_md5!
-          start!
+        end
+
+        def create!
+          if create?
+            create_unit!
+            update_dockerfile_md5!
+            start_and_insert_scripts! if start?
+          else
+            $logger.warn("Unit '#{unit.display_name}' already exists (--force to overwrite)")
+          end
+        rescue Errors::DockerContainerCannotDelete => e
+          $logger.error "Unable to delete '%s' unit - %s" % [ unit.name, e.inspect ]
         end
 
         def build_image!
-          Build.new(unit).execute! unless unit.image_exists?
+          Build.new(unit).execute! if build?
         end
 
-        # FIXME: move this
         def pull_image!
           return nil if unit.image_exists?
           $logger.info "Pulling '#{unit.image_name}' image"
           Connection.perform(Docker::Image, :create, fromImage: unit.image_name) do |out|
-            $logger.debug JSON.parse(out)
+            $logger.info JSON.parse(out)
           end
         end
 
+        def delete_unit!
+          $logger.info "Deleting '#{unit.display_name}' unit"
+          unit.container.remove(force: force?)
+        rescue Docker::Error::ConflictError => e
+          raise(Errors::DockerContainerCannotDelete.new, e)
+        end
+
         def create_unit!
+          delete_unit! if force?
           $logger.info "Creating '#{unit.display_name}' unit"
           Connection.perform(Docker::Container, :create, options)
         end
 
-        def start!
-          return nil if !unit.startable? || !start?
+        def start_and_insert_scripts!
           Start.new(unit).execute!
+          insert_post_start_scripts!
         end
 
         def update_dockerfile_md5!
           unit.update_dockerfile_md5!
         end
 
-        def insert_scripts!
-          return nil if unit_image_existed?
-          insert_files!(unit.post_start_scripts)
-        end
-
-        def insert_files!(files)
-          files.each { |file| insert_file!(file) }
+        def insert_post_start_scripts!
+          unit.post_start_scripts.each { |file| insert_file!(file) }
         end
 
         def insert_file!(file)

data/lib/percheron/actions/exec.rb

@@ -1,12 +1,11 @@
 module Percheron
   module Actions
     class Exec
-
       include Base
 
-      def initialize(unit, dependant_units, scripts, description)
+      def initialize(unit, needed_units, scripts, description)
         @unit = unit
-        @dependant_units = dependant_units
+        @needed_units = needed_units
         @scripts = scripts
         @description = description
       end
@@ -19,13 +18,13 @@ module Percheron
 
       private
 
-        attr_reader :unit, :dependant_units, :scripts, :description
+        attr_reader :unit, :needed_units, :scripts, :description
 
         def exec!
           results = []
-          started_dependant_units = start_units!(dependant_units)
+          started_needed_units = start_units!(needed_units)
           results << execute_scripts_on_running_unit!
-          results << stop_units!(started_dependant_units)
+          results << stop_units!(started_needed_units)
           results
         end
 
@@ -34,7 +33,7 @@ module Percheron
           Start.new(unit, exec_scripts: false).execute! unless unit_running
           execute_scripts!
           commit_and_tag_new_image!
-          Stop.new(unit).execute!  unless unit_running
+          Stop.new(unit).execute! unless unit_running
         end
 
         def commit_and_tag_new_image!
@@ -67,8 +66,8 @@ module Percheron
         def start_units!(units, scripts: true)
           exec_on_units!(units) do |unit|
             next if unit.running?
-            units = unit.startable_dependant_units.values
-            Start.new(unit, dependant_units: units, exec_scripts: scripts).execute!
+            units = unit.startable_needed_units.values
+            Start.new(unit, needed_units: units, exec_scripts: scripts).execute!
           end
         end
 

data/lib/percheron/actions/exec_local.rb

@@ -3,7 +3,6 @@ require 'open3'
 module Percheron
   module Actions
     class ExecLocal
-
       include Base
 
       def initialize(unit, scripts, description)
@@ -26,7 +25,7 @@ module Percheron
           $logger.debug "Executing #{description} scripts '#{scripts.inspect}' locally"
           scripts.each do |script|
             in_working_directory(base_dir) do
-              execute_command!('/bin/sh -x %s 2>&1' % Pathname.new(File.expand_path(script)))
+              execute_command!('/bin/sh -x %s 2>&1' % [ Pathname.new(File.expand_path(script)) ])
             end
           end
         end

data/lib/percheron/actions/purge.rb

@@ -1,7 +1,6 @@
 module Percheron
   module Actions
     class Purge
-
       include Base
 
       def initialize(unit, force: false)
@@ -12,8 +11,8 @@ module Percheron
       def execute!
         results = []
         results << stop!
-        results << delete_unit!
-        results << delete_image!
+        results << delete_unit!  if delete_unit?
+        results << delete_image! if delete_image?
         results.compact.empty? ? nil : unit
       end
 
@@ -25,26 +24,32 @@ module Percheron
           Stop.new(unit).execute!
         end
 
+        def delete_unit?
+          unit.exists?
+        end
+
         def delete_image?
           unit.image_exists? && unit.buildable?
         end
 
+        def opts
+          { force: force }
+        end
+
         def delete_unit!
-          return nil unless unit.exists?
-          $logger.info "Deleting '#{unit.display_name}' unit"
-          unit.container.remove(force: force)
-        rescue Docker::Error::ConflictError => e
-          $logger.error "Unable to delete '%s' unit - %s" % [ unit.name, e.inspect ]
+          delete!('unit', unit.display_name) { unit.container.remove(opts) }
         end
 
         def delete_image!
-          return nil unless delete_image?
-          $logger.info "Deleting '#{unit.image_name}' image"
-          unit.image.remove(force: force)
-        rescue Docker::Error::ConflictError => e
-          $logger.error "Unable to delete '%s' image - %s" % [ unit.image_name, e.inspect ]
+          delete!('image', unit.image_name) { unit.image.remove(opts) }
         end
 
+        def delete!(type, value)
+          $logger.info("Deleting '%s' %s" % [ value, type ])
+          yield
+        rescue Docker::Error::ConflictError => e
+          $logger.error("Unable to delete '%s' %s - %s" % [ value, type, e.inspect ])
+        end
     end
   end
 end

data/lib/percheron/actions/restart.rb

@@ -1,7 +1,6 @@
 module Percheron
   module Actions
     class Restart
-
       include Base
 
       def initialize(unit)
@@ -24,7 +23,7 @@ module Percheron
         end
 
         def start!
-          opts = { dependant_units: unit.startable_dependant_units.values }
+          opts = { needed_units: unit.startable_needed_units.values }
           Start.new(unit, opts).execute!
         end
 

data/lib/percheron/actions/shell.rb

@@ -6,9 +6,9 @@ module Percheron
       DEFAULT_COMMAND = '/bin/sh'
       DOCKER_CLIENT = 'docker'
 
-      def initialize(unit, command: DEFAULT_COMMAND)
+      def initialize(unit, raw_command: DEFAULT_COMMAND)
         @unit = unit
-        @command = command
+        @raw_command = raw_command
       end
 
       def execute!
@@ -17,14 +17,14 @@ module Percheron
 
       private
 
-        attr_reader :unit
+        attr_reader :unit, :raw_command
 
         def valid?
           Validators::DockerClient.new.valid?
         end
 
         def command
-          "sh -c '%s'" % @command
+          "sh -c '%s'" % [ raw_command ]
         end
 
         def exec!

data/lib/percheron/actions/start.rb

@@ -1,12 +1,11 @@
 module Percheron
   module Actions
     class Start
-
       include Base
 
-      def initialize(unit, dependant_units: [], cmd: false, exec_scripts: true)
+      def initialize(unit, needed_units: [], cmd: false, exec_scripts: true)
         @unit = unit
-        @dependant_units = dependant_units
+        @needed_units = needed_units
         @cmd = cmd
         @exec_scripts = exec_scripts
       end
@@ -23,7 +22,7 @@ module Percheron
 
       private
 
-        attr_reader :unit, :dependant_units, :cmd, :exec_scripts
+        attr_reader :unit, :needed_units, :cmd, :exec_scripts
 
         def exec_scripts?
           !unit.post_start_scripts.empty? && exec_scripts
@@ -31,7 +30,7 @@ module Percheron
 
         def create!
           return nil if unit.exists?
-          Create.new(unit, cmd: cmd, exec_scripts: exec_scripts).execute!
+          Create.new(unit, cmd: cmd).execute!
         end
 
         def start!
@@ -42,7 +41,7 @@ module Percheron
 
         def execute_post_start_scripts!
           scripts = unit.post_start_scripts
-          Exec.new(unit, dependant_units, scripts, 'POST start').execute! if exec_scripts?
+          Exec.new(unit, needed_units, scripts, 'POST start').execute! if exec_scripts?
         end
 
     end

data/lib/percheron/actions/stop.rb

@@ -1,7 +1,6 @@
 module Percheron
   module Actions
     class Stop
-
       include Base
 
       def initialize(unit)

data/lib/percheron/actions.rb

@@ -3,7 +3,6 @@ require 'percheron/actions/stop'
 require 'percheron/actions/start'
 require 'percheron/actions/restart'
 require 'percheron/actions/create'
-require 'percheron/actions/recreate'
 require 'percheron/actions/build'
 require 'percheron/actions/purge'
 require 'percheron/actions/exec'

data/lib/percheron/commands/abstract.rb

@@ -17,16 +17,24 @@ module Percheron
         end
       end
 
-      def self.default_create_parameters!
-        default_parameters!
-        option('--start', :flag, 'Start unit', default: false)
+      def runit
+        yield
+      rescue Docker::Error::UnexpectedResponseError => e
+        $logger.error('')
+        $logger.error('An exception occurred :(')
+        $logger.error('')
+        $logger.error(e.inspect)
       end
 
       def execute
         stack.valid?
+      rescue Errno::ENOENT, Errors::ConfigFileInvalid, Errors::StackInvalid => e
+        signal_usage_error(e.message)
+        exit(1)
       rescue => e
         puts "%s\n\n%s\n\n" % [ e.inspect, e.backtrace.join("\n") ]
         signal_usage_error(e.message)
+        exit(1)
       end
 
       def stack
@@ -40,9 +48,6 @@ module Percheron
             Percheron::Connection.load!(c)
           end
         end
-      rescue Errors::ConfigFileInvalid => e
-        $logger.error e.inspect
-        exit(1)
       end
     end
   end

data/lib/percheron/commands/build.rb

@@ -3,11 +3,12 @@ module Percheron
     class Build < Abstract
 
       default_parameters!
-      option('--forcerm', :flag, 'force removal of intermediate containers', default: false)
+      option('--usecache', :flag, 'Use image cache', default: true)
+      option('--forcerm', :flag, 'Force removal of intermediate containers', default: false)
 
       def execute
         super
-        stack.build!(unit_names: unit_names, forcerm: forcerm?)
+        runit { stack.build!(unit_names: unit_names, usecache: usecache?, forcerm: forcerm?) }
       end
     end
   end

data/lib/percheron/commands/console.rb

@@ -32,11 +32,6 @@ module Percheron
           nil
         end
 
-        def recreate(unit_names, start: false)
-          stack.create!(unit_names: [ *unit_names ], start: start)
-          nil
-        end
-
         def start(unit_names)
           stack.start!(unit_names: [ *unit_names ])
           nil

data/lib/percheron/commands/create.rb

@@ -2,11 +2,16 @@ module Percheron
   module Commands
     class Create < Abstract
 
-      default_create_parameters!
+      default_parameters!
+      option('--start', :flag, '(Re)start unit once created', default: true)
+      option('--build', :flag, '(Re)build image', default: true)
+      option('--deep', :flag, 'Include needed units', default: false)
+      option('--force', :flag, 'Force unit (re)creation', default: false)
 
       def execute
         super
-        stack.create!(unit_names: unit_names, start: start?)
+        opts = { unit_names: unit_names, build: build?, start: start?, deep: deep?, force: force? }
+        runit { stack.create!(opts) }
       end
     end
   end

data/lib/percheron/commands/logs.rb

@@ -4,7 +4,7 @@ module Percheron
 
       parameter('STACK_NAME', 'stack name', required: true)
       parameter('UNIT_NAME', 'unit name', required: true)
-      option('--follow', :flag, 'follow the logs', default: false)
+      option([ '-f', '-t', '--follow', '--tail' ], :flag, 'Follow the logs', default: false)
 
       def execute
         super

data/lib/percheron/commands/main.rb

@@ -2,13 +2,12 @@ module Percheron
   module Commands
     class Main < Abstract
       subcommand %w(list status), 'List stacks and its units', List
-      subcommand 'console', 'Start a pry console session', Console
+      subcommand 'console', '', Console
       subcommand 'start', 'Start a stack', Start
       subcommand 'stop', 'Stop a stack', Stop
       subcommand 'restart', 'Restart a stack', Restart
-      subcommand 'build', 'Build images for a stack', Build
-      subcommand 'create', 'Build images and create units for a stack', Create
-      subcommand 'recreate', 'Recreate a stack', Recreate
+      subcommand %w(build rebuild), '(Re)build image(s) for a stack', Build
+      subcommand %w(create recreate), '(Re)build image(s) and (re)create units for a stack', Create
       subcommand 'purge', 'Purge a stack', Purge
       subcommand 'shell', 'Shell into a unit', Shell
       subcommand 'logs', 'Show logs for a unit', Logs

data/lib/percheron/commands/purge.rb

@@ -3,12 +3,21 @@ module Percheron
     class Purge < Abstract
 
       default_parameters!
-      option([ '-f', '--force' ], :flag, 'Force unit/image removal', default: false)
+      option('--yes', :flag, 'Yes, purge image / unit', default: false)
+      option('--force', :flag, 'Force image / unit removal', default: false)
 
       def execute
         super
-        stack.purge!(unit_names: unit_names, force: force?)
+        runit { stack.purge!(unit_names: unit_names, force: force?) if yes? || confirm? }
       end
+
+      private
+
+        def confirm?
+          ask('Are you sure? (y|n) ') do |q|
+            q.validate = /y(es)?|n(o)?/i
+          end.match(/y(es)?/i)
+        end
     end
   end
 end

data/lib/percheron/commands/restart.rb

@@ -6,7 +6,7 @@ module Percheron
 
       def execute
         super
-        stack.restart!(unit_names: unit_names)
+        runit { stack.restart!(unit_names: unit_names) }
       end
     end
   end

data/lib/percheron/commands/shell.rb

@@ -8,7 +8,7 @@ module Percheron
 
       def execute
         super
-        stack.shell!(unit_name, command: command)
+        stack.shell!(unit_name, raw_command: command)
       rescue Errors::DockerClientInvalid => e
         signal_usage_error(e.message)
       end

data/lib/percheron/commands/start.rb

@@ -6,7 +6,7 @@ module Percheron
 
       def execute
         super
-        stack.start!(unit_names: unit_names)
+        runit { stack.start!(unit_names: unit_names) }
       end
     end
   end

data/lib/percheron/commands/stop.rb

@@ -6,7 +6,7 @@ module Percheron
 
       def execute
         super
-        stack.stop!(unit_names: unit_names)
+        runit { stack.stop!(unit_names: unit_names) }
       end
     end
   end

data/lib/percheron/commands.rb

@@ -9,7 +9,6 @@ require 'percheron/commands/purge'
 require 'percheron/commands/console'
 require 'percheron/commands/create'
 require 'percheron/commands/build'
-require 'percheron/commands/recreate'
 require 'percheron/commands/shell'
 require 'percheron/commands/logs'
 require 'percheron/commands/graph'

data/lib/percheron/config.rb

@@ -78,7 +78,8 @@ module Percheron
         @stacks = @yaml_contents = @raw_contents = @contents = nil
       end
 
-      def process_stacks!   # FIXME: bugs here :(
+      # FIXME: bugs here :(
+      def process_stacks!
         stacks_by_name = contents.stacks.to_hash_by_key(:name)
         scanned = scan_unit_configs(stacks_by_name)
         stacks_by_name.each do |_, stack|
@@ -103,14 +104,15 @@ module Percheron
       end
 
       def replace_scanned(all, config, scanned)
-        match = config.fetch(:dependant_unit_names, [])
+        match = config.fetch(:needed_unit_names, [])
         unless (match & scanned.keys).empty?
-          config.dependant_unit_names = match.map { |v| scanned[v] }.flatten
+          config.needed_unit_names = match.map { |v| scanned[v] }.flatten
         end
         all[config.name] = config
       end
 
-      def scan_unit_configs(stacks_by_name)  # FIXME
+      # FIXME
+      def scan_unit_configs(stacks_by_name)
         all = {}
         stacks_by_name.each do |_, stack|
           stack.fetch(:units, []).each do |unit_config|
@@ -123,7 +125,8 @@ module Percheron
         all
       end
 
-      def expand_unit_config(unit_config, new_unit_names)  # FIXME
+      # FIXME
+      def expand_unit_config(unit_config, new_unit_names)
         new_unit_names.each_with_object({}) do |new_name, all|
           temp_unit_config = unit_config.dup
           temp_unit_config.delete(:instances)

data/lib/percheron/errors.rb

@@ -5,5 +5,6 @@ module Percheron
     class UnitInvalid < StandardError; end
     class UnitDoesNotExist < StandardError; end
     class DockerClientInvalid < StandardError; end
+    class DockerContainerCannotDelete < StandardError; end
   end
 end

data/lib/percheron/graph.rb

@@ -87,7 +87,7 @@ module Percheron
         unit.ports.each do |ports|
           label << '<font point-size="11">p: %s, i: %s</font>' % ports.split(':')
         end
-        { shape: shape, label: '<%s>' % label.join('<br/>'), fontname: 'arial' }
+        { shape: shape, label: '<%s>' % [ label.join('<br/>') ], fontname: 'arial' }
       end
 
       def pseudo_node_opts(unit)
@@ -96,8 +96,8 @@ module Percheron
 
       def add_links
         units.each do |name, unit|
-          unit.dependant_units.each do |dependant_name, dependant_unit|
-            graph.add_edges(nodes[name], nodes[dependant_name], node_link_opts(dependant_unit))
+          unit.needed_units.each do |needed_name, needed_unit|
+            graph.add_edges(nodes[name], nodes[needed_name], node_link_opts(needed_unit))
           end
         end
       end
@@ -108,6 +108,5 @@ module Percheron
         color     = unit.startable? ? 'black' : 'gray'
         { dir: direction, style: style, color: color }
       end
-
   end
 end

data/lib/percheron/logger.rb

@@ -6,7 +6,7 @@ logger_level = Logger::INFO
 logger_level = Logger::WARN if ENV['QUIET'] == 'true'
 
 # :nocov:
-if ENV['DEBUG'] == 'true' || ENV['DOCKER_DEBUG'] == 'true'
+if [ ENV['DEBUG'], ENV['DOCKER_DEBUG'] ].include?('true')
   logger_level = Logger::DEBUG
   Docker.logger = $logger if ENV['DOCKER_DEBUG'] == 'true'
 end

data/lib/percheron/stack.rb

@@ -22,7 +22,7 @@ module Percheron
     end
 
     def metastore_key
-      @metastore_key ||= 'stacks.%s' % name
+      @metastore_key ||= 'stacks.%s' % [ name ]
     end
 
     def unit_configs
@@ -30,7 +30,7 @@ module Percheron
     end
 
     def units(unit_names = [])
-      unit_names = !unit_names.empty? ? unit_names : filter_unit_names
+      unit_names = unit_names.empty? ? stack_units.keys : unit_names
       unit_names.each_with_object({}) do |unit_name, all|
         all[unit_name] = unit_from_name(unit_name)
       end
@@ -38,11 +38,11 @@ module Percheron
 
     def graph!(file)
       Graph.new(self).save!(file)
-      $logger.info "Saved '%s'" % file
+      $logger.info "Saved '%s'" % [ file ]
     end
 
-    def shell!(unit_name, command: Percheron::Actions::Shell::DEFAULT_COMMAND)
-      Actions::Shell.new(unit_from_name(unit_name), command: command).execute!
+    def shell!(unit_name, raw_command: Percheron::Actions::Shell::DEFAULT_COMMAND)
+      Actions::Shell.new(unit_from_name(unit_name), raw_command: raw_command).execute!
     end
 
     def logs!(unit_name, follow: false)
@@ -50,50 +50,53 @@ module Percheron
     end
 
     def stop!(unit_names: [])
+      unit_names = stack_units.keys if unit_names.empty?
       execute!(Actions::Stop, filter_unit_names(unit_names).reverse)
     end
 
-    # FIXME: bug when non-startable unit specified, all units started
     def start!(unit_names: [])
-      unit_names = dependant_units_for(unit_names)
-      exec_on_dependant_units_for(unit_names) do |unit|
-        dependant_units = unit.startable_dependant_units.values
-        Actions::Start.new(unit, dependant_units: dependant_units).execute!
+      unit_names = stack_units.keys if unit_names.empty?
+      unit_names = needed_units_for(unit_names)
+      exec_on_needed_units_for(unit_names) do |unit|
+        needed_units = unit.startable_needed_units.values
+        Actions::Start.new(unit, needed_units: needed_units).execute!
       end
       nil
     end
 
     def restart!(unit_names: [])
+      unit_names = stack_units.keys if unit_names.empty?
       execute!(Actions::Restart, filter_unit_names(unit_names))
     end
 
-    def build!(unit_names: [], forcerm: false)
-      unit_names = dependant_units_for(unit_names)
-      exec_on_dependant_units_for(unit_names) do |unit|
-        Actions::Build.new(unit, forcerm: forcerm).execute!
+    def build!(unit_names: [], usecache: true, forcerm: false)
+      unit_names = stack_units.keys if unit_names.empty?
+      unit_names = needed_units_for(unit_names)
+      exec_on_needed_units_for(unit_names) do |unit|
+        Actions::Build.new(unit, usecache: usecache, forcerm: forcerm).execute!
       end
       nil
     end
 
-    def create!(unit_names: [],  start: false)
-      execute!(Actions::Create, dependant_units_for(unit_names), start: start)
-    end
-
-    def recreate!(unit_names: [], start: false, force: false)
-      execute!(Actions::Recreate, filter_unit_names(unit_names), start: start, force: force)
+    def create!(unit_names: [], build: true, start: false, deep: false, force: false)
+      opts = { build: build, start: start, force: force }
+      unit_names = if deep
+                     unit_names = stack_units.keys if unit_names.empty?
+                     needed_units_for(unit_names)
+                   else
+                     filter_unit_names(unit_names)
+                   end
+      execute!(Actions::Create, unit_names, opts)
     end
 
     def purge!(unit_names: [], force: false)
+      unit_names = stack_units.keys if unit_names.empty?
       execute!(Actions::Purge, filter_unit_names(unit_names).reverse, force: force)
     end
 
     def execute!(klass, unit_names, args=nil)
-      exec_on_dependant_units_for(unit_names) do |unit|
-        if args
-          klass.new(unit, args).execute!
-        else
-          klass.new(unit).execute!
-        end
+      exec_on_needed_units_for(unit_names) do |unit|
+        args ? klass.new(unit, args).execute! : klass.new(unit).execute!
       end
       nil
     end
@@ -110,20 +113,20 @@ module Percheron
         @stack_config ||= (config.stacks[stack_name] || Hashie::Mash.new({}))
       end
 
-      # FIXME: yuck
-      # rubocop:disable Style/Next
+      def stack_units
+        @stack_units ||= stack_config.fetch('units', {})
+      end
+
       def filter_unit_names(unit_names = [])
-        stack_config.fetch('units', {}).map do |unit_name, unit_config|
-          if unit_names.empty? || unit_names.include?(unit_name) ||
-             (unit_config.pseudo_name &&
-               unit_names.include?(unit_config.pseudo_name))
+        stack_units.map do |unit_name, unit_config|
+          if unit_names.include?(unit_name) ||
+             (unit_config.pseudo_name && unit_names.include?(unit_config.pseudo_name))
             unit_config.name
           end
-        end.compact
+        end.compact.uniq
       end
-      # rubocop:enable Style/Next
 
-      def exec_on_dependant_units_for(unit_names)
+      def exec_on_needed_units_for(unit_names)
         exec_on_units(unit_names) do |unit|
           $logger.debug "Processing '#{unit.display_name}' unit"
           yield(unit)
@@ -135,21 +138,21 @@ module Percheron
         units(unit_names).each { |_, unit| yield(unit) }
       end
 
-      def dependant_units_for(unit_names)
+      def needed_units_for(unit_names)
         list = []
         unit_names = filter_unit_names(unit_names)
-        units = all_units_and_dependants(unit_names)
-        units.each do |unit_name, dependant_unit_names|
-          list += dependant_unit_names unless dependant_unit_names.empty?
+        units = all_units_and_neededs(unit_names)
+        units.each do |unit_name, needed_unit_names|
+          list += needed_unit_names unless needed_unit_names.empty?
           list << unit_name
         end
         list.uniq
       end
 
-      def all_units_and_dependants(unit_names)
+      def all_units_and_neededs(unit_names)
         all_units = units
         units = unit_names.each_with_object({}) do |unit_name, all|
-          all[unit_name] = all_units[unit_name].dependant_unit_names
+          all[unit_name] = all_units[unit_name].needed_unit_names
         end
         units.sort { |x, y| x[1].length <=> y[1].length } # FIXME
       end

data/lib/percheron/unit/image_helper.rb

@@ -0,0 +1,33 @@
+module Percheron
+  class Unit
+    module ImageHelper
+      def image_name
+        '%s:%s' % [ image_repo, image_version.to_s ] if image_repo && image_version
+      end
+
+      def image_repo
+        if !buildable?
+          unit_config.docker_image.split(':')[0]
+        elsif pseudo?
+          pseudo_full_name
+        else
+          full_name
+        end
+      end
+
+      def image_version
+        if buildable?
+          unit_config.version
+        elsif !unit_config.docker_image.nil?
+          unit_config.docker_image.split(':')[1] || 'latest'
+        else
+          fail Errors::UnitInvalid, 'Cannot determine image version'
+        end
+      end
+
+      def image_exists?
+        image.nil? ? false : true
+      end
+    end
+  end
+end

data/lib/percheron/unit.rb

@@ -1,13 +1,15 @@
+require 'percheron/unit/image_helper'
+
 module Percheron
   class Unit
 
     extend Forwardable
     extend ConfigDelegator
+    include Unit::ImageHelper
 
     def_delegators :unit_config, :name, :pseudo_name, :docker_image
-    def_config_item_with_default :unit_config, [], :env, :ports, :volumes,
-                                 :dependant_unit_names, :pre_build_scripts,
-                                 :post_start_scripts, :start_args, :dns
+    def_config_item_with_default :unit_config, [], :env, :ports, :volumes, :needed_unit_names,
+                                 :pre_build_scripts, :post_start_scripts, :start_args, :dns
     def_config_item_with_default :unit_config, true, :startable
 
     def initialize(config, stack, unit_name)
@@ -18,14 +20,14 @@ module Percheron
       self
     end
 
-    def dependant_units
-      dependant_unit_names.each_with_object({}) do |unit_name, all|
+    def needed_units
+      needed_unit_names.each_with_object({}) do |unit_name, all|
         all[unit_name] = stack.units[unit_name]
       end
     end
 
-    def startable_dependant_units
-      dependant_units.select { |_, unit| unit.startable? }
+    def startable_needed_units
+      needed_units.select { |_, unit| unit.startable? }
     end
 
     def metastore_key
@@ -37,31 +39,19 @@ module Percheron
     end
 
     def hostname
-      unit_config.fetch('hostname', name)
-    end
-
-    def image_name
-      '%s:%s' % [ image_repo, image_version.to_s ] if image_repo && image_version
+      unit_config.fetch('hostname', full_name)
     end
 
-    def image_repo
-      if !buildable?
-        unit_config.docker_image.split(':')[0]
-      elsif pseudo?
-        pseudo_full_name
-      else
-        full_name
+    def restart_policy
+      @restart_policy ||= begin
+        name = unit_config.fetch('restart_policy', 'always')
+        max_retry_count = unit_config.fetch('restart_policy_retry_count', 0)
+        { 'Name' => name, 'MaximumRetryCount' => max_retry_count }
       end
     end
 
-    def image_version
-      if buildable?
-        unit_config.version
-      elsif !unit_config.docker_image.nil?
-        unit_config.docker_image.split(':')[1] || 'latest'
-      else
-        fail Errors::UnitInvalid, 'Cannot determine image version'
-      end
+    def privileged
+      unit_config.fetch('privileged', false)
     end
 
     def full_name
@@ -95,9 +85,7 @@ module Percheron
     end
 
     def links
-      startable_dependant_units.map do |_, unit|
-        '%s:%s' % [ unit.full_name, unit.full_name ]
-      end
+      startable_needed_units.map { |_, unit| '%s:%s' % [ unit.full_name, unit.full_name ] }
     end
 
     def container
@@ -141,10 +129,6 @@ module Percheron
       !info.empty?
     end
 
-    def image_exists?
-      image.nil? ? false : true
-    end
-
     def buildable?
       !dockerfile.nil? && unit_config.docker_image.nil?
     end
@@ -178,6 +162,5 @@ module Percheron
       def info
         Hashie::Mash.new(container.info)
       end
-
   end
 end

data/lib/percheron/version.rb

@@ -1,3 +1,3 @@
 module Percheron
-  VERSION = '0.7.16'
+  VERSION = '0.8.0'
 end

data/lib/percheron.rb

@@ -7,6 +7,7 @@ require 'semantic'
 require 'metastore'
 require 'liquid'
 require 'singleton'
+require 'securerandom'
 
 require 'percheron/oh_dear'
 require 'percheron/core_extensions'

data/percheron.gemspec

@@ -36,7 +36,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'pry-byebug', '~> 3.2.0'
   spec.add_development_dependency 'rake', '~> 10.4.0'
   spec.add_development_dependency 'rspec', '~> 3.3.0'
-  spec.add_development_dependency 'rubocop', '~> 0.32.0'
+  spec.add_development_dependency 'rubocop', '~> 0.33.0'
   spec.add_development_dependency 'simplecov', '~> 0.10.0'
   spec.add_development_dependency 'timecop', '~> 0.8.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: percheron
 version: !ruby/object:Gem::Version
-  version: 0.7.16
+  version: 0.8.0
 platform: ruby
 authors:
 - Ash McKenzie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-07 00:00:00.000000000 Z
+date: 2015-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clamp
@@ -254,14 +254,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.32.0
+        version: 0.33.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.32.0
+        version: 0.33.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -322,7 +322,6 @@ files:
 - lib/percheron/actions/exec_local.rb
 - lib/percheron/actions/logs.rb
 - lib/percheron/actions/purge.rb
-- lib/percheron/actions/recreate.rb
 - lib/percheron/actions/restart.rb
 - lib/percheron/actions/shell.rb
 - lib/percheron/actions/start.rb
@@ -337,7 +336,6 @@ files:
 - lib/percheron/commands/logs.rb
 - lib/percheron/commands/main.rb
 - lib/percheron/commands/purge.rb
-- lib/percheron/commands/recreate.rb
 - lib/percheron/commands/restart.rb
 - lib/percheron/commands/shell.rb
 - lib/percheron/commands/start.rb
@@ -358,6 +356,7 @@ files:
 - lib/percheron/oh_dear.rb
 - lib/percheron/stack.rb
 - lib/percheron/unit.rb
+- lib/percheron/unit/image_helper.rb
 - lib/percheron/validators.rb
 - lib/percheron/validators/config.rb
 - lib/percheron/validators/docker_client.rb

data/lib/percheron/actions/recreate.rb

@@ -1,51 +0,0 @@
-module Percheron
-  module Actions
-    class Recreate
-
-      include Base
-
-      def initialize(unit, start: false, force: false)
-        @unit = unit
-        @start = start
-        @force = force
-      end
-
-      def execute!
-        results = []
-        if recreate? || force?
-          results << recreate!
-          results << start!
-        else
-          inform!
-        end
-        results.compact.empty? ? nil : unit
-      end
-
-      private
-
-        attr_reader :unit, :start, :force
-        alias_method :start?, :start
-        alias_method :force?, :force
-
-        def recreate?
-          !unit.versions_match? || !unit.dockerfile_md5s_match?
-        end
-
-        def inform!
-          return nil unless unit.dockerfile_md5s_match?
-          $logger.info "Unit '#{unit.display_name}' - No Dockerfile changes or version bump"
-        end
-
-        def recreate!
-          $logger.debug "Unit '#{unit.display_name}' exists but will be recreated"
-          Purge.new(unit).execute!
-          Create.new(unit).execute!
-        end
-
-        def start!
-          Start.new(unit).execute! if start?
-        end
-
-    end
-  end
-end

data/lib/percheron/commands/recreate.rb

@@ -1,14 +0,0 @@
-module Percheron
-  module Commands
-    class Recreate < Abstract
-
-      default_create_parameters!
-      option([ '-f', '--force' ], :flag, 'Force purge and create', default: false)
-
-      def execute
-        super
-        stack.recreate!(unit_names: unit_names, start: start?, force: force?)
-      end
-    end
-  end
-end