percheron 0.6.4 → 0.7.0

data/lib/percheron/container.rb

@@ -4,27 +4,78 @@ module Percheron
     extend Forwardable
     extend ConfigDelegator
 
-    def_delegators :container_config, :name
+    def_delegators :container_config, :name, :pseudo_name, :docker_image
+    def_config_item_with_default :container_config, [], :env, :ports, :volumes,
+                                 :dependant_container_names, :pre_build_scripts,
+                                 :post_start_scripts, :start_args
+    def_config_item_with_default :container_config, %w(127.0.0.1 8.8.8.8), :dns
+    def_config_item_with_default :container_config, true, :startable
 
-    def_config_item_with_default :container_config, false, :auto_recreate
-    def_config_item_with_default :container_config, [], :env, :ports, :volumes, :dependant_container_names, :pre_build_scripts, :post_create_scripts, :post_start_scripts
+    attr_reader :config_file_base_path
 
-    alias_method :auto_recreate?, :auto_recreate
-
-    def initialize(config, stack, container_name)
-      @config = config
+    def initialize(stack, container_name, config_file_base_path)
       @stack = stack
       @container_name = container_name
-      valid?
+      @config_file_base_path = config_file_base_path
       self
     end
 
+    def dependant_containers
+      dependant_container_names.each_with_object({}) do |container_name, all|
+        all[container_name] = stack.containers[container_name]
+      end
+    end
+
+    def startable_dependant_containers
+      dependant_containers.select { |_, container| container.startable? }
+    end
+
+    def metastore_key
+      @metastore_key ||= 'stacks.%s.containers.%s' % [ stack.name, name ]
+    end
+
+    def container_config
+      @container_config ||= stack.container_configs[container_name] || Hashie::Mash.new({})
+    end
+
     def id
-      exists? ? info.id[0...12] : 'N/A'
+      exists? ? info.id[0...12] : nil
+    end
+
+    def hostname
+      container_config.fetch('hostname', name)
     end
 
     def image_name
-      '%s:%s' % [ name, version.to_s ]
+      '%s:%s' % [ image_repo, image_version.to_s ] if image_repo && image_version
+    end
+
+    def image_repo  # FIXME
+      if pseudo?
+        pseudo_full_name
+      elsif !buildable?
+        container_config.docker_image.split(':')[0]
+      else
+        full_name
+      end
+    end
+
+    def image_version
+      if buildable?
+        version
+      elsif !container_config.docker_image.nil?
+        container_config.docker_image.split(':')[1]
+      else
+        fail Errors::ContainerInvalid, 'Cannot determine image version'
+      end
+    end
+
+    def full_name
+      '%s_%s' % [ stack.name, name ]
+    end
+
+    def pseudo_full_name
+      '%s_%s' % [ stack.name, pseudo_name ]
     end
 
     def image
@@ -38,49 +89,46 @@ module Percheron
     end
 
     def built_version
-      Semantic::Version.new(exists? ? built_image_version : '0.0.0')
+      Semantic::Version.new(built_image_version)
     end
 
     def dockerfile
-      container_config.dockerfile ? Pathname.new(File.expand_path(container_config.dockerfile, config.file_base_path)): nil
+      return nil unless container_config.dockerfile
+      Pathname.new(File.expand_path(container_config.dockerfile, config_file_base_path))
     end
 
     def exposed_ports
-      ports.inject({}) do |all, p|
-        all[p.split(':')[1]] = {}
-        all
-      end
+      ports.each_with_object({}) { |p, all| all[p.split(':')[1]] = {} }
     end
 
     def links
-      dependant_container_names.map do |container_name|
-        '%s:%s' % [ container_name, container_name ]
+      startable_dependant_containers.map do |_, container|
+        '%s:%s' % [ container.full_name, container.name ]
       end
     end
 
     def docker_container
-      Docker::Container.get(name)
+      Docker::Container.get(full_name)
     rescue Docker::Error::NotFoundError, Excon::Errors::SocketError
       NullContainer.new
     end
 
-    def dependant_containers
-      dependant_container_names.inject({}) do |all, container_name|
-        all[container_name] = stack.filter_containers[container_name]
-        all
-      end
+    def labels
+      { version: version.to_s, created_by: "Percheron #{Percheron::VERSION}" }
     end
 
-    def metastore_key
-      @metastore_key ||= 'stacks.%s.containers.%s' % [ stack.name, name ]
+    def update_dockerfile_md5!
+      md5 = current_dockerfile_md5
+      $logger.info "Setting MD5 for '#{name}' container to #{md5}"
+      $metastore.set("#{metastore_key}.dockerfile_md5", md5)
     end
 
-    def current_dockerfile_md5
-      Digest::MD5.file(dockerfile).hexdigest
+    def dockerfile_md5s_match?
+      dockerfile_md5 == current_dockerfile_md5
     end
 
-    def dockerfile_md5
-      $metastore.get("#{metastore_key}.dockerfile_md5")
+    def versions_match?
+      version == built_version
     end
 
     def running?
@@ -92,32 +140,41 @@ module Percheron
     end
 
     def image_exists?
-      !!image
+      image.nil? ? false : true
     end
 
-    def dependant_containers?
-      !dependant_container_names.empty?
+    def buildable?
+      !dockerfile.nil? && container_config.docker_image.nil?
     end
 
     def valid?
       Validators::Container.new(self).valid?
     end
 
+    alias_method :startable?, :startable
+
     private
 
-      attr_reader :config, :stack, :container_name
+      attr_reader :stack, :container_name
+
+      def current_dockerfile_md5
+        dockerfile ? Digest::MD5.file(dockerfile).hexdigest : Digest::MD5.hexdigest(image_name)
+      end
+
+      def dockerfile_md5
+        $metastore.get("#{metastore_key}.dockerfile_md5") || current_dockerfile_md5
+      end
 
       def built_image_version
-        info.Config.Image.split(':')[1]
+        (exists? && info.Config.Labels) ? info.Config.Labels.version : '0.0.0'
       end
 
       def info
         Hashie::Mash.new(docker_container.info)
       end
 
-      def container_config
-        @container_config ||= stack.container_configs[container_name] || Hashie::Mash.new({})
+      def pseudo?
+        !pseudo_name.nil?
       end
-
   end
 end

data/lib/percheron/core_extensions.rb

@@ -2,7 +2,6 @@ module Percheron
   module CoreExtensions
     module Array
       module Extras
-
         def return
           result = nil
           each do |x|
@@ -16,12 +15,10 @@ module Percheron
         end
 
         def to_hash_by_key(key_attr)
-          inject({}) do |all, e|
+          each_with_object({}) do |e, all|
             all[e.send(key_attr)] = e unless all[e.send(key_attr)]
-            all
           end
         end
-
       end
     end
   end

data/lib/percheron/docker_connection.rb

@@ -23,6 +23,7 @@ module Percheron
       end
 
       def set_options!
+        Excon.defaults[:ssl_verify_peer] = config.docker.fetch('ssl_verify_peer', true)
         Docker.options = docker_options
       end
 
@@ -31,7 +32,10 @@ module Percheron
       end
 
       def base_docker_options
-        { connect_timeout: config.docker.timeout }
+        {
+          connect_timeout: config.docker.connect_timeout || 5,
+          read_timeout:    config.docker.read_timeout || 300
+        }
       end
 
       def extra_docker_opts

data/lib/percheron/formatters/stack/table.rb

@@ -8,36 +8,48 @@ module Percheron
         end
 
         def generate
-          Terminal::Table.new(
-            title:    stack.name,
-            headings: headings,
-            rows:     rows
-          )
+          Terminal::Table.new(title: title, headings: headings, rows: rows)
         end
 
         private
 
           attr_reader :stack
 
+          def title
+            stack.name
+          end
+
           def headings
             [
-              'Container name',
+              'Container',
               'ID',
-              'Version',
-              'Running?'
+              'Running?',
+              'Ports',
+              'Volumes',
+              'Version'
             ]
           end
 
           def rows
-            stack.filter_containers.map do |container_name, container|
+            stack.containers.map do |_, container|
               [
-                container_name,
+                container.name,
                 container.id,
-                container.built_version,
-                container.running?
+                startable(container),
+                container.ports.join(', '),
+                container.volumes.join(', '),
+                (container.built_version == '0.0.0') ? '' : container.built_version
               ]
             end
           end
+
+          def startable(container)
+            if container.startable?
+              container.running? ? 'yes' : '-'
+            else
+              'n/a'
+            end
+          end
       end
     end
   end

data/lib/percheron/logger.rb

@@ -0,0 +1,21 @@
+require 'logger'
+
+$logger = Logger.new(STDOUT)
+
+logger_level = Logger::INFO
+logger_level = Logger::WARN if ENV['QUIET'] == 'true'
+
+if ENV['DEBUG'] == 'true' || ENV['DOCKER_DEBUG'] == 'true'
+  begin
+    require 'pry-byebug'
+    require 'awesome_print'
+  rescue LoadError
+    $logger.warn 'Debugging gems are not installed'
+  end
+
+  logger_level = Logger::DEBUG
+
+  Docker.logger = $logger if ENV['DOCKER_DEBUG'] == 'true'
+end
+
+$logger.level = logger_level

data/lib/percheron/metastore.rb

@@ -0,0 +1 @@
+$metastore = Metastore::Cabinet.new(File.join(ENV['HOME'], '.percheron', 'metastore.yaml'))

data/lib/percheron/null_stack.rb

@@ -0,0 +1,5 @@
+module Percheron
+  NullStack = Naught.build do |config|
+    config.mimic Stack
+  end
+end

data/lib/percheron/oh_dear.rb

@@ -6,7 +6,16 @@ module Percheron
     end
 
     def generate
-      <<-EOS
+      template
+    end
+
+    private
+
+      attr_reader :exception
+
+      # rubocop:disable Metrics/MethodLength
+      def template
+        <<-EOS
 
 OH DEAR, we are terribly sorry.. something unexpected occurred :(
 
@@ -25,14 +34,13 @@ Trace
 
 --snip--
 
-Please copy the detail between the --snip--'s above and raise a ticket - https://github.com/ashmckenzie/percheron/issues/new?labels=bug
+Please copy the detail between the --snip--'s above and raise a ticket please :)
 
-      EOS
-    end
-
-    private
+https://github.com/ashmckenzie/percheron/issues/new?labels=bug
 
-      attr_reader :exception
+EOS
+      end
+      # rubocop:enable Metrics/MethodLength
 
       def exception_message
         exception.inspect

data/lib/percheron/stack.rb

@@ -1,6 +1,7 @@
+require 'highline/import'
+
 module Percheron
   class Stack
-
     extend Forwardable
 
     def_delegators :stack_config, :name, :description
@@ -8,73 +9,84 @@ module Percheron
     def initialize(config, stack_name)
       @config = config
       @stack_name = stack_name
-      valid?
       self
     end
 
-    def self.get(config, stack_name=nil)
-      if stack_name
+    def self.get(config, name = nil)
+      stacks = name.nil? ? config.stacks : { name => config.stacks[name] }
+      stacks.each_with_object({}) do |stack_config, all|
+        stack_name, _ = stack_config
         stack = new(config, stack_name)
-        stack ? { stack.name => stack } : {}
-      else
-        all = {}
-        config.stacks.each do |stack_name, _|
-          stack = new(config, stack_name)
-          all[stack.name] = stack
-        end
-        all
+        all[stack.name] = stack
       end
     end
 
     def container_configs
-      stack_config.containers.to_hash_by_key(:name)
+      stack_config.containers
     end
 
-    # FIXME: YUCK
-    def filter_containers(container_names=[])
+    def containers(container_names = [])
       container_names = !container_names.empty? ? container_names : filter_container_names
-      container_names.inject({}) do |all, container_name|
-        all[container_name] = Container.new(config, self, container_name)
-        all
+      container_names.each_with_object({}) do |container_name, all|
+        all[container_name] = container_from_name(container_name)
       end
     end
 
+    def shell!(container_name, shell: Percheron::Actions::Shell::DEFAULT_SHELL)
+      Actions::Shell.new(container_from_name(container_name), shell: shell).execute!
+    end
+
+    def logs!(container_name, follow: false)
+      Actions::Logs.new(container_from_name(container_name), follow: follow).execute!
+    end
+
     def stop!(container_names: [])
-      container_names = dependant_containers_for(container_names).reverse
-      exec_on_dependant_containers_for(container_names) { |container| Actions::Stop.new(container).execute! }
+      execute!(Actions::Stop, filter_container_names(container_names).reverse)
     end
 
+    # FIXME: bug when non-startable container specified, all containers started
     def start!(container_names: [])
       container_names = dependant_containers_for(container_names)
-      exec_on_dependant_containers_for(container_names) { |container| Actions::Start.new(container, dependant_containers: container.dependant_containers.values).execute! }
+      exec_on_dependant_containers_for(container_names) do |container|
+        dependant_containers = container.startable_dependant_containers.values
+        Actions::Start.new(container, dependant_containers: dependant_containers).execute!
+      end
+      nil
     end
 
     def restart!(container_names: [])
-      container_names = dependant_containers_for(container_names)
-      exec_on_dependant_containers_for(container_names) { |container| Actions::Restart.new(container).execute! }
+      execute!(Actions::Restart, filter_container_names(container_names))
     end
 
-    def create!(container_names: [])
+    def build!(container_names: [])
       container_names = dependant_containers_for(container_names)
-      exec_on_dependant_containers_for(container_names) { |container| Actions::Create.new(container).execute! }
+      exec_on_dependant_containers_for(container_names) do |container|
+        Actions::Build.new(container).execute!
+      end
+      nil
     end
 
-    def recreate!(container_names: [], force_recreate: false, delete: false)
-      current = container_names_final = filter_container_names(container_names)
-
-      # FIXME: make this suck less
-      while true
-        current = deps = containers_affected(current).uniq
-        break if deps.empty?
-        container_names_final += deps
-      end
+    def create!(container_names: [],  start: false)
+      execute!(Actions::Create, dependant_containers_for(container_names), start: start)
+    end
 
-      exec_on_dependant_containers_for(container_names_final.uniq) { |container| Actions::Recreate.new(container, force_recreate: force_recreate, delete: delete).execute! }
+    def recreate!(container_names: [], start: false)
+      execute!(Actions::Recreate, filter_container_names(container_names), start: start)
     end
 
     def purge!(container_names: [])
-      container_names = filter_container_names(container_names)
-      exec_on_dependant_containers_for(container_names) { |container| Actions::Purge.new(container).execute! }
+      execute!(Actions::Purge, filter_container_names(container_names).reverse)
+    end
+
+    def execute!(klass, container_names, args=nil)
+      exec_on_dependant_containers_for(container_names) do |container|
+        if args
+          klass.new(container, args).execute!
+        else
+          klass.new(container).execute!
+        end
+      end
+      nil
     end
 
     def valid?
@@ -89,59 +101,52 @@ module Percheron
         @stack_config ||= (config.stacks[stack_name] || Hashie::Mash.new({}))
       end
 
-      def filter_container_names(container_names=[])
-        stack_config.containers.map do |container_config|
-          if container_names.empty? || container_names.include?(container_config.name)
+      # FIXME: yuck
+      # rubocop:disable Style/Next
+      def filter_container_names(container_names = [])
+        stack_config.fetch('containers', {}).map do |container_name, container_config|
+          if container_names.empty? || container_names.include?(container_name) ||
+             (container_config.pseudo_name &&
+               container_names.include?(container_config.pseudo_name))
             container_config.name
           end
         end.compact
       end
-
-      def exec_on_containers(container_names)
-        filter_containers(container_names).each { |_, container| yield(container) }
-      end
+      # rubocop:enable Style/Next
 
       def exec_on_dependant_containers_for(container_names)
-        serial_processor(container_names) do |container|
-          $logger.info '' if yield(container)
-        end
-      end
-
-      def serial_processor(container_names)
         exec_on_containers(container_names) do |container|
+          $logger.debug "Processing '#{container.name}' container"
           yield(container)
-          container_names.delete(container.name)
+          container_names.delete(container.full_name)
         end
       end
 
-      def containers_affected(container_names)
-        deps = []
-        container_names.each do |container_name|
-          filter_containers.each do |_, container|
-            deps << container.name if container.dependant_container_names.include?(container_name)
-          end
-        end
-        deps
-      end
-
-      def containers_and_their_dependants(container_names)
-        all_containers = filter_containers
-         container_names.inject({}) do |all, container_name|
-          all[container_name] = all_containers[container_name].dependant_container_names
-          all
-        end
+      def exec_on_containers(container_names)
+        containers(container_names).each { |_, container| yield(container) }
       end
 
       def dependant_containers_for(container_names)
+        list = []
         container_names = filter_container_names(container_names)
+        containers = all_containers_and_dependants(container_names)
+        containers.each do |container_name, dependant_container_names|
+          list += dependant_container_names unless dependant_container_names.empty?
+          list << container_name
+        end
+        list.uniq
+      end
 
-        wip_list = []
-        containers_and_their_dependants(container_names).each do |container_name, dependant_container_names|
-          wip_list += dependant_container_names unless dependant_container_names.empty?
-          wip_list << container_name
+      def all_containers_and_dependants(container_names)
+        all_containers = containers
+        containers = container_names.each_with_object({}) do |container_name, all|
+          all[container_name] = all_containers[container_name].dependant_container_names
         end
-        wip_list.uniq
+        containers.sort { |x, y| x[1].length <=> y[1].length } # FIXME
       end
 
+      def container_from_name(container_name)
+        Container.new(self, container_name, config.file_base_path)
+      end
   end
 end

data/lib/percheron/validators/config.rb

@@ -10,7 +10,7 @@ module Percheron
         message = rules.return { |rule| send(rule) }
 
         if message
-          raise Errors::ConfigFileInvalid.new(message)
+          fail Errors::ConfigFileInvalid, message
         else
           true
         end

data/lib/percheron/validators/container.rb

@@ -10,7 +10,7 @@ module Percheron
         message = rules.return { |rule| send(rule) }
 
         if message
-          raise Errors::ContainerInvalid.new(formatted_message(message))
+          fail Errors::ContainerInvalid, formatted_message(message)
         else
           true
         end
@@ -24,32 +24,52 @@ module Percheron
           if container.name
             "Container config for '%s' is invalid: %s" % [ container.name, message ]
           else
-            "Container config is invalid: %s" % [ message ]
+            "Container config is invalid: #{message}"
           end
         end
 
         def rules
           [
             :validate_name,
-            :validate_version,
-            :validate_dockerfile
+            :validate_dockerfile_and_image_name,
+            :validate_dockerfile,
+            :validate_image,
+            :validate_version
           ]
         end
 
+        # rubocop:disable Style/GuardClause
         def validate_name
-          'Name is invalid' if container.name.nil? || !container.name.to_s.match(/[\w\d]{3,}/)
+          if container.name.nil? || !container.name.to_s.match(/[\w]{3,}/)
+            'Container name is invalid'
+          end
         end
 
-        def validate_version
-          container.version
-          nil
-        rescue ArgumentError
-          'Version is invalid'
+        def validate_dockerfile_and_image_name
+          if container.dockerfile.nil? && container.docker_image.nil?
+            'Container Dockerfile OR image name not provided'
+          end
         end
 
         def validate_dockerfile
-          'Dockerfile is invalid' if container.dockerfile.nil? || !File.exist?(container.dockerfile)
+          if !container.dockerfile.nil? && !File.exist?(container.dockerfile)
+            'Container Dockerfile is invalid'
+          end
         end
+
+        def validate_image
+          if !container.docker_image.nil? && !container.docker_image.match(/^.+:.+$/)
+            'Container Docker image is invalid'
+          end
+        end
+        # rubocop:enable Style/GuardClause
+
+        def validate_version
+          container.version ? nil : fail(ArgumentError)
+        rescue ArgumentError
+          'Container version is invalid'
+        end
+
     end
   end
 end