percheron 0.6.4 → 0.7.0

data/lib/percheron/actions/recreate.rb

@@ -4,94 +4,44 @@ module Percheron
 
       include Base
 
-      def initialize(container, force_recreate: false, delete: false)
+      def initialize(container, start: false)
         @container = container
-        @force_recreate = force_recreate
-        @delete = delete
+        @start = start
       end
 
       def execute!
         results = []
         if recreate?
           results << recreate!
+          results << start!
         else
-          unless dockerfile_md5s_match?
-            $logger.warn "Container '#{container.name}' MD5's do not match, consider recreating (bump the version!)"
-          else
-            $logger.info "Container '#{container.name}' does not need to be recreated"
-          end
+          inform!
         end
         results.compact.empty? ? nil : container
       end
 
       private
 
-        attr_reader :container, :force_recreate, :delete
-
-        alias_method :force_recreate?, :force_recreate
-        alias_method :delete?, :delete
-
-        def temporary_name
-          '%s_wip' % container.name
-        end
-
-        def stored_dockerfile_md5
-          container.dockerfile_md5 || container.current_dockerfile_md5
-        end
-
-        def temporary_container_exists?
-          !!Docker::Container.get(temporary_name)
-        rescue Docker::Error::NotFoundError
-          false
-        end
+        attr_reader :container, :start
+        alias_method :start?, :start
 
         def recreate?
-          force_recreate? || (!dockerfile_md5s_match? && versions_mismatch? && container.auto_recreate?)
-        end
-
-        def versions_mismatch?
-          container.version > container.built_version
+          !container.versions_match? || !container.dockerfile_md5s_match?
         end
 
-        def dockerfile_md5s_match?
-          stored_dockerfile_md5 == container.current_dockerfile_md5
+        def inform!
+          return nil unless container.dockerfile_md5s_match?
+          $logger.info "Container '#{container.name}' - No Dockerfile changes or version bump"
         end
 
         def recreate!
-          $logger.debug "Container '#{container.name}' exists and will be recreated"
-
-          unless temporary_container_exists?
-            delete_container_and_image! if delete?
-            create_container!
-            rename_container!
-          else
-            $logger.debug "Not recreating '#{container.name}' container because temporary container '#{temporary_name}' already exists"
-          end
-        end
-
-        def delete_container_and_image!
-          delete_container!
-          delete_image!
-        end
-
-        def delete_container!
-          $logger.info "Deleting '#{container.name}' container"
-          stop_containers!([ container ])
-          container.docker_container.remove
-        end
-
-        def delete_image!
-          $logger.info "Deleting '#{container.name}' image"
-          container.image.remove
-        end
-
-        def create_container!
-          opts = { create: { 'name' => temporary_name } }
-          Create.new(container, recreate: true).execute!(opts)
+          $logger.debug "Container '#{container.name}' exists but will be recreated"
+          Purge.new(container).execute!
+          Create.new(container).execute!
         end
 
-        def rename_container!
-          Rename.new(container, temporary_name, container.name).execute!
+        def start!
+          Start.new(container).execute! if start?
         end
 
     end

data/lib/percheron/actions/restart.rb

@@ -24,7 +24,8 @@ module Percheron
         end
 
         def start!
-          Start.new(container, dependant_containers: container.dependant_containers.values).execute!
+          opts = { dependant_containers: container.startable_dependant_containers.values }
+          Start.new(container, opts).execute!
         end
 
     end

data/lib/percheron/actions/shell.rb

@@ -0,0 +1,27 @@
+module Percheron
+  module Actions
+    class Shell
+      include Base
+
+      DEFAULT_SHELL = '/bin/sh'
+
+      def initialize(container, shell: DEFAULT_SHELL)
+        @container = container
+        @shell = shell
+      end
+
+      def execute!
+        $logger.debug "Executing a bash shell on '#{container.name}' container"
+        exec!
+      end
+
+      private
+
+        attr_reader :container, :shell
+
+        def exec!
+          system('docker exec -ti %s %s' % [ container.full_name, shell ])
+        end
+    end
+  end
+end

data/lib/percheron/actions/start.rb

@@ -4,42 +4,45 @@ module Percheron
 
       include Base
 
-      def initialize(container, dependant_containers: [], exec_scripts: true)
+      def initialize(container, dependant_containers: [], cmd: false, exec_scripts: true)
         @container = container
         @dependant_containers = dependant_containers
+        @cmd = cmd
         @exec_scripts = exec_scripts
       end
 
       def execute!
         results = []
-        results << create! unless container.exists?
+        results << create!
         unless container.running?
           results << start!
-          results << execute_post_start_scripts! if exec_scripts?
+          results << execute_post_start_scripts!
         end
         results.compact.empty? ? nil : container
       end
 
       private
 
-        attr_reader :container, :dependant_containers, :exec_scripts
+        attr_reader :container, :dependant_containers, :cmd, :exec_scripts
 
         def exec_scripts?
           !container.post_start_scripts.empty? && exec_scripts
         end
 
         def create!
-          $logger.info "Creating '#{container.name}' container as it doesn't exist"
-          Create.new(container).execute!
+          return nil if container.exists?
+          Create.new(container, cmd: cmd, exec_scripts: exec_scripts).execute!
         end
 
         def start!
+          return nil if !container.startable? || container.running?
           $logger.info "Starting '#{container.name}' container"
           container.docker_container.start!
         end
 
         def execute_post_start_scripts!
-          Exec.new(container, dependant_containers, container.post_start_scripts, 'POST start').execute!
+          scripts = container.post_start_scripts
+          Exec.new(container, dependant_containers, scripts, 'POST start').execute! if exec_scripts?
         end
 
     end

data/lib/percheron/actions.rb

@@ -4,11 +4,12 @@ require 'percheron/actions/start'
 require 'percheron/actions/restart'
 require 'percheron/actions/create'
 require 'percheron/actions/recreate'
-require 'percheron/actions/rename'
 require 'percheron/actions/build'
 require 'percheron/actions/purge'
 require 'percheron/actions/exec'
 require 'percheron/actions/exec_local'
+require 'percheron/actions/shell'
+require 'percheron/actions/logs'
 
 module Percheron
   module Actions

data/lib/percheron/commands/abstract.rb

@@ -2,32 +2,44 @@ module Percheron
   module Commands
     class Abstract < Clamp::Command
 
-      DEFAULT_CONFIG_FILE = '.percheron.yml'
+      option([ '-c', '--config_file' ], 'CONFIG', 'Config file',
+             default: Config::DEFAULT_CONFIG_FILE)
 
-      option [ '-c', '--config_file' ], 'CONFIG', 'Configuration file', default: DEFAULT_CONFIG_FILE
-
-      option '--version', :flag, 'show version' do
+      option('--version', :flag, 'show version') do
         puts Percheron::VERSION
         exit(0)
       end
 
       def self.default_parameters!
-        parameter('STACK_NAME', 'stack name', required: false)
-        parameter('CONTAINER_NAMES', 'container names', required: false, default: []) do |container_names|
+        parameter('STACK_NAME', 'stack name', required: true)
+        parameter('CONTAINER_NAMES', 'container names', default: [],
+                                                        required: false) do |container_names|
           container_names.split(/,/)
         end
       end
 
+      def self.default_create_parameters!
+        default_parameters!
+        option('--start', :flag, 'Start container', default: false)
+      end
+
+      def execute
+        stack.valid?
+      rescue => e
+        signal_usage_error(e.message)
+      end
+
       def stack
+        return NullStack.new if stack_name.nil?
         Percheron::Stack.new(config, stack_name)
       end
 
       def default_config_file
-        ENV.fetch('PERCHERON_CONFIG', DEFAULT_CONFIG_FILE)
+        ENV.fetch('PERCHERON_CONFIG', Config::DEFAULT_CONFIG_FILE)
       end
 
       def config
-        @config ||= Percheron::Config.new(config_file)
+        @config ||= Percheron::Config.load!(config_file)
       rescue Errors::ConfigFileInvalid => e
         $logger.error e.message
         exit(1)

data/lib/percheron/commands/build.rb

@@ -0,0 +1,13 @@
+module Percheron
+  module Commands
+    class Build < Abstract
+
+      default_parameters!
+
+      def execute
+        super
+        stack.build!(container_names: container_names)
+      end
+    end
+  end
+end

data/lib/percheron/commands/console.rb

@@ -2,9 +2,62 @@ module Percheron
   module Commands
     class Console < Abstract
 
+      parameter('STACK_NAME', 'stack name', required: false)
+
       def execute
+        super
+        require 'pry-byebug'
         pry
       end
+
+      private
+
+        def list
+          Stack.get(config, stack_name).each do |_, stack|
+            puts("\n", Percheron::Formatters::Stack::Table.new(stack).generate)
+          end
+          nil
+        end
+
+        def logs(container_name, follow: false)
+          stack.logs!(container_name, follow: follow)
+          nil
+        end
+
+        def shell(container_name)
+          stack.shell!(container_name)
+          nil
+        end
+
+        def purge(container_names)
+          stack.purge!(container_names: [ *container_names ])
+          nil
+        end
+
+        def create(container_names, start: false)
+          stack.create!(container_names: [ *container_names ], start: start)
+          nil
+        end
+
+        def recreate(container_names, start: false)
+          stack.create!(container_names: [ *container_names ], start: start)
+          nil
+        end
+
+        def start(container_names)
+          stack.start!(container_names: [ *container_names ])
+          nil
+        end
+
+        def stop(container_names)
+          stack.stop!(container_names: [ *container_names ])
+          nil
+        end
+
+        def restart(container_names)
+          stack.restart!(container_names: [ *container_names ])
+          nil
+        end
     end
   end
 end

data/lib/percheron/commands/create.rb

@@ -2,11 +2,11 @@ module Percheron
   module Commands
     class Create < Abstract
 
-      default_parameters!
+      default_create_parameters!
 
       def execute
-        opts = { container_names: container_names }
-        stack.create!(opts)
+        super
+        stack.create!(container_names: container_names, start: start?)
       end
     end
   end

data/lib/percheron/commands/list.rb

@@ -5,9 +5,13 @@ module Percheron
       parameter('STACK_NAME', 'stack name', required: false)
 
       def execute
-        Stack.get(config, stack_name).each do |stack_name, stack|
-          puts
-          puts Percheron::Formatters::Stack::Table.new(stack).generate
+        Stack.get(config, stack_name).each do |_, stack|
+          begin
+            stack.valid?
+            puts("\n", Percheron::Formatters::Stack::Table.new(stack).generate)
+          rescue Percheron::Errors::StackInvalid => e
+            signal_usage_error(e.message)
+          end
         end
       end
     end

data/lib/percheron/commands/logs.rb

@@ -0,0 +1,16 @@
+module Percheron
+  module Commands
+    class Logs < Abstract
+
+      parameter('STACK_NAME', 'stack name', required: true)
+      parameter('CONTAINER_NAME', 'container name', required: true)
+
+      option('--follow', :flag, 'follow the logs', default: false)
+
+      def execute
+        super
+        stack.logs!(container_name, follow: follow?)
+      end
+    end
+  end
+end

data/lib/percheron/commands/main.rb

@@ -1,14 +1,17 @@
 module Percheron
   module Commands
     class Main < Abstract
-      subcommand 'list', "List stacks and it's containers", List
+      subcommand %w(list status), "List stacks and it's containers", List
       subcommand 'console', 'Start a pry console session', Console
       subcommand 'start', 'Start a stack', Start
       subcommand 'stop', 'Stop a stack', Stop
       subcommand 'restart', 'Restart a stack', Restart
-      subcommand 'create', 'Create a stack', Create
+      subcommand 'build', 'Build images for a stack', Build
+      subcommand 'create', 'Build images and create containers for a stack', Create
       subcommand 'recreate', 'Recreate a stack', Recreate
       subcommand 'purge', 'Purge a stack', Purge
+      subcommand 'shell', 'Shell into a container', Shell
+      subcommand 'logs', 'Show logs for a container', Logs
     end
   end
 end

data/lib/percheron/commands/purge.rb

@@ -5,8 +5,8 @@ module Percheron
       default_parameters!
 
       def execute
-        opts = { container_names: container_names }
-        stack.purge!(opts)
+        super
+        stack.purge!(container_names: container_names)
       end
     end
   end

data/lib/percheron/commands/recreate.rb

@@ -2,19 +2,11 @@ module Percheron
   module Commands
     class Recreate < Abstract
 
-      default_parameters!
-
-      option "--force", :flag, 'Force recreation', default: false
-      option "--delete", :flag, 'Delete container + image before recreation', default: false
+      default_create_parameters!
 
       def execute
-        opts = {
-          container_names: container_names,
-          force_recreate: force?,
-          delete: delete?
-        }
-
-        stack.recreate!(opts)
+        super
+        stack.recreate!(container_names: container_names, start: start?)
       end
     end
   end

data/lib/percheron/commands/restart.rb

@@ -5,8 +5,8 @@ module Percheron
       default_parameters!
 
       def execute
-        opts = { container_names: container_names }
-        stack.restart!(opts)
+        super
+        stack.restart!(container_names: container_names)
       end
     end
   end

data/lib/percheron/commands/shell.rb

@@ -0,0 +1,16 @@
+module Percheron
+  module Commands
+    class Shell < Abstract
+
+      parameter('STACK_NAME', 'stack name', required: true)
+      parameter('CONTAINER_NAME', 'container name', required: true)
+
+      option('--shell', 'SHELL', 'Shell to use', default: Percheron::Actions::Shell::DEFAULT_SHELL)
+
+      def execute
+        super
+        stack.shell!(container_name, shell: shell)
+      end
+    end
+  end
+end

data/lib/percheron/commands/start.rb

@@ -5,8 +5,8 @@ module Percheron
       default_parameters!
 
       def execute
-        opts = { container_names: container_names }
-        stack.start!(opts)
+        super
+        stack.start!(container_names: container_names)
       end
     end
   end

data/lib/percheron/commands/stop.rb

@@ -5,8 +5,8 @@ module Percheron
       default_parameters!
 
       def execute
-        opts = { container_names: container_names }
-        stack.stop!(opts)
+        super
+        stack.stop!(container_names: container_names)
       end
     end
   end

data/lib/percheron/commands.rb

@@ -8,7 +8,10 @@ require 'percheron/commands/stop'
 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/main'
 
 module Percheron

data/lib/percheron/config.rb

@@ -3,19 +3,20 @@ require 'yaml'
 module Percheron
   class Config
 
+    DEFAULT_CONFIG_FILE = '.percheron.yml'
+
     extend Forwardable
 
     def_delegators :contents, :docker
 
     def initialize(file)
       @file = Pathname.new(file).expand_path
-      valid?
       docker_setup!
       self
     end
 
     def stacks
-      contents.stacks.to_hash_by_key(:name)
+      process_stacks!
     end
 
     def file_base_path
@@ -26,10 +27,71 @@ module Percheron
       Validators::Config.new(file).valid?
     end
 
+    def self.load!(config_file = DEFAULT_CONFIG_FILE)
+      new(config_file)
+    end
+
     private
 
       attr_reader :file
 
+      # rubocop:disable Metrics/MethodLength
+      def process_stacks!   # FIXME: bugs here :(
+        stacks_by_name = contents.stacks.to_hash_by_key(:name)
+        scanned = scan_container_configs(stacks_by_name)
+        stacks_by_name.each do |_, stack|
+          stack_containers = stack.containers.each_with_object({}) do |container_config, all|
+            if scanned[container_config.name]
+              merge(all, container_config, scanned)
+            else
+              replace_scanned(all, container_config, scanned)
+            end
+          end
+          stack.containers = stack_containers
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def merge(all, container_config, scanned)  # FIXME: poor name
+        all.merge!(expand_container_config(container_config, scanned[container_config.name]))
+      end
+
+      def replace_scanned(all, container_config, scanned)  # FIXME: poor name
+        match = container_config.fetch(:dependant_container_names, [])
+        unless (match & scanned.keys).empty?
+          container_config.dependant_container_names = match.map { |v| scanned[v] }.flatten
+        end
+        all[container_config.name] = container_config
+      end
+
+      def scan_container_configs(stacks_by_name)  # FIXME
+        all = {}
+        stacks_by_name.each do |_, stack|
+          stack.containers.each do |container_config|
+            next if container_config.fetch(:instances, 1) == 1
+            all[container_config.name] = 1.upto(container_config.instances).map do |number|
+              "#{container_config.name}#{number}"
+            end
+          end
+        end
+        all
+      end
+
+      def expand_container_config(container_config, new_container_names)  # FIXME
+        new_container_names.each_with_object({}) do |new_name, all|
+          temp_container_config = container_config.dup
+          temp_container_config.delete(:instances)
+          temp_container_config.pseudo_name = container_config.name
+          temp_container_config.name = new_name
+          all[new_name] = eval_container_config(temp_container_config)
+        end
+      end
+
+      def eval_container_config(container_config)
+        template = Liquid::Template.parse(container_config.to_h.to_yaml.to_s)
+        YAML.load(template.render(container_config))
+      end
+
       def contents
         Hashie::Mash.new(YAML.load_file(file))
       end
@@ -37,6 +99,5 @@ module Percheron
       def docker_setup!
         Percheron::DockerConnection.new(self).setup!
       end
-
   end
 end

data/lib/percheron/config_delegator.rb

@@ -1,6 +1,5 @@
 module Percheron
   module ConfigDelegator
-
     def def_config_item_with_default(config, default, *symbols)
       symbols.each do |symbol|
         define_method(symbol) do