navo 0.1.0 → 0.2.0

data/lib/navo/configuration.rb

@@ -78,11 +78,20 @@ module Navo
     # Access the configuration as if it were a hash.
     #
     # @param key [String, Symbol]
-    # @return [Array, Hash, Number, String]
+    # @return [Array, Hash, Number, String, Symbol]
     def [](key)
       @options[key.to_s]
     end
 
+    # Set the configuration as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @param value [Array, Hash, Number, String, Symbol]
+    # @return [Array, Hash, Number, String]
+    def []=(key, value)
+      @options[key.to_s] = value
+    end
+
     # Access the configuration as if it were a hash.
     #
     # @param key [String, Symbol]

data/lib/navo/logger.rb

@@ -0,0 +1,121 @@
+require 'digest'
+require 'fileutils'
+require 'logger'
+
+module Navo
+  # Manages the display of output and writing of log files.
+  #
+  # The goal is to make the tool easier to read when running from the command
+  # line, but preserving all useful information in log files as well so in-depth
+  # debugging can be performed.
+  #
+  # Each test suite creates its own {Output} instance to write to so individual
+  # log lines go to their own files, but they all share a common destination
+  # that is synchronized when writing to stdout/stderr for the application as a
+  # whole.
+  class Logger
+    UI_COLORS = {
+      unknown: 35, # purple
+      fatal: 31,   # red
+      error: 31,   # red
+      warn: 33,    # yellow
+      info: nil,   # normal
+      debug: 90,   # gray
+    }
+
+    class << self
+      attr_reader :logger
+
+      attr_reader :level
+
+      attr_reader :mutex
+
+      def output=(out)
+        @logger = ::Logger.new(out)
+        @mutex = Mutex.new
+      end
+
+      def level=(level)
+        level = level ? ::Logger.const_get(level.upcase) : ::Logger::INFO
+        @level = level
+        @logger.level = level
+      end
+    end
+
+    def initialize(suite: nil)
+      @suite = suite
+
+      if suite
+        log_file = File.open(suite.log_file, File::CREAT | File::WRONLY | File::APPEND)
+        @logger = ::Logger.new(log_file)
+        @logger.level = self.class.level
+      end
+
+      @color_hash = {}
+    end
+
+    def console(message, severity: :info, flush: true)
+      # In order to improve the output displayed, we don't want to print a line
+      # for every chunk of log received--only logs which have newlines.
+      # Thus we buffer the output and flush it once we have the full amount.
+      @buffer_severity ||= severity
+      @buffer_level ||= ::Logger.const_get(severity.upcase)
+      @buffer ||= ''
+      @buffer += message
+
+      flush_buffer if flush
+    end
+
+    def log(severity, message, flush: true)
+      level = ::Logger.const_get(severity.upcase)
+      @logger.add(level, message) if @logger
+      console(message, severity: severity, flush: flush)
+    end
+
+    %i[unknown fatal error warn info debug].each do |severity|
+      define_method severity do |msg|
+        log(severity, msg, flush: true)
+      end
+    end
+
+    def flush_buffer
+      if @buffer
+        # This is shared amongst potentially many threads, so serialize access
+        if @buffer_level >= self.class.level
+          self.class.mutex.synchronize do
+            self.class.logger << pretty_message(@buffer_severity, @buffer)
+          end
+        end
+
+        @buffer = nil
+        @buffer_severity = nil
+        @buffer_level = nil
+      end
+    end
+
+    private
+
+    def pretty_message(severity, message)
+      color_code = UI_COLORS[severity]
+
+      prefix = "[#{@suite.name}] " if @suite
+      colored_prefix = "\e[#{color_for_string(@suite.name)}m#{prefix}\e[0m" if prefix
+      message = message.to_s
+      message = "\e[#{color_code}m#{message}\e[0m" if color_code
+
+      message = indent_output(prefix, colored_prefix, "#{colored_prefix}#{message}")
+      message += "\n" unless message.end_with?("\n")
+      message
+    end
+
+    # Returns a deterministic color code for the given string.
+    def color_for_string(string)
+      @color_hash[string] ||= (Digest::MD5.hexdigest(string)[0..8].to_i(16) % 6) + 31
+    end
+
+    def indent_output(prefix, colored_prefix, message)
+      return message unless prefix
+      message.gsub(/\n(?!$)/, "\n#{colored_prefix}")
+    end
+  end
+end

data/lib/navo/sandbox.rb

@@ -1,4 +1,3 @@
-require 'berkshelf'
 require 'fileutils'
 require 'pathname'
 
@@ -9,13 +8,13 @@ module Navo
   # needed to run a test within the suite's container. A temporary directory on
   # the host is maintained
   class Sandbox
-    def initialize(suite:)
+    def initialize(suite:, logger:)
       @suite = suite
+      @logger = logger
     end
 
     def update_chef_config
       install_cookbooks
-      install_chef_directories
       install_chef_config
     end
 
@@ -23,6 +22,11 @@ module Navo
       test_files_dir = File.join(@suite.repo_root, %w[test integration])
       suite_dir = File.join(test_files_dir, @suite.name)
 
+      unless File.exist?(suite_dir)
+        @logger.warn "No test files found at #{suite_dir} for #{@suite.name} suite"
+        return
+      end
+
       # serverspec, bats, etc.
       frameworks = Pathname.new(suite_dir).children
                                           .select(&:directory?)
@@ -44,12 +48,12 @@ module Navo
         # between host and container (test-kitchen does the same thing).
         helpers_directory = File.join(test_files_dir, 'helpers', framework)
         if File.directory?(helpers_directory)
-          puts "Transferring #{framework} test suite helpers..."
+          @logger.info "Transferring #{framework} test suite helpers..."
           @suite.copy(from: File.join(helpers_directory, '.'),
                       to: container_framework_dir)
         end
 
-        puts "Transferring #{framework} tests..."
+        @logger.info "Transferring #{framework} tests..."
         @suite.copy(from: File.join(host_framework_dir, '.'),
                     to: container_framework_dir)
       end
@@ -61,45 +65,53 @@ module Navo
     def install_cookbooks
       @suite.exec!(%w[mkdir -p] + [@suite.chef_config_dir, @suite.chef_run_dir])
 
-      vendored_cookbooks_dir = File.join(storage_directory, 'cookbooks')
-      berksfile = File.expand_path(@suite['chef']['berksfile'], @suite.repo_root)
+      host_cookbooks_dir = File.join(@suite.repo_root, 'cookbooks')
+      container_cookbooks_dir = File.join(@suite.chef_run_dir, 'cookbooks')
 
-      puts 'Resolving Berksfile...'
-      @suite.exec!(%w[rm -rf] + [vendored_cookbooks_dir])
-      Berkshelf::Berksfile.from_file(berksfile).vendor(vendored_cookbooks_dir)
+      Navo.synchronize do
+        Berksfile.load
 
-      @suite.copy(from: File.join(storage_directory, 'cookbooks', '.'),
-                  to: File.join(@suite.chef_run_dir, 'cookbooks'))
-    end
+        # Check all files first so we calculate the hashes
+        berksfile_changed = @suite.path_changed?(Berksfile.path)
+        lockfile_changed = @suite.path_changed?(Berksfile.lockfile_path)
+        cookbooks_changed = @suite.path_changed?(host_cookbooks_dir)
 
-    def install_chef_directories
-      %w[data_bags environments roles].each do |dir|
-        puts "Preparing #{dir} directory..."
-        host_dir = File.join(@suite.repo_root, dir)
-        container_dir = File.join(@suite.chef_run_dir, dir)
+        if (berksfile_changed || lockfile_changed || cookbooks_changed) ||
+           @suite.path_changed?(Berksfile.vendor_directory)
 
-        @suite.exec(%w[rm -rf] + [container_dir])
-        @suite.copy(from: host_dir, to: container_dir)
+          @logger.info 'Vendoring cookbooks...'
+          Berksfile.vendor(logger: @logger)
+          # Recalculate new hash
+          @suite.path_changed?(Berksfile.vendor_directory)
+        else
+          @logger.info 'No cookbooks changed; nothing new to install'
+        end
       end
     end
 
     def install_chef_config
       secret_file = File.expand_path(@suite['chef']['secret'], @suite.repo_root)
       secret_file_basename = File.basename(secret_file)
-      @suite.copy(from: secret_file,
-                  to: File.join(@suite.chef_config_dir, secret_file_basename))
+      @logger.info "Preparing #{secret_file_basename}"
+      @suite.copy_if_changed(from: secret_file,
+                             to: File.join(@suite.chef_config_dir, secret_file_basename))
 
-      puts 'Preparing solo.rb'
+      @logger.info 'Preparing solo.rb'
       @suite.write(file: File.join(@suite.chef_config_dir, 'solo.rb'),
                    content: @suite.chef_solo_config)
-      puts 'Preparing first-boot.json'
+      @logger.info 'Preparing first-boot.json'
       @suite.write(file: File.join(@suite.chef_config_dir, 'first-boot.json'),
                    content: @suite.node_attributes.to_json)
+
+      @logger.debug 'Installing custom formatter'
+      formatter_file = File.expand_path('chef_formatter.rb', File.dirname(__FILE__))
+      @suite.copy(from: formatter_file, to: @suite.chef_config_dir)
     end
 
     def storage_directory
       @storage_directory ||=
         @suite.storage_directory.tap do |path|
+          @logger.debug("Ensuring storage directory #{path} exists")
           FileUtils.mkdir_p(path)
         end
     end

data/lib/navo/state_file.rb

@@ -0,0 +1,78 @@
+require 'fileutils'
+require 'monitor'
+require 'yaml'
+
+module Navo
+  # Stores persisted state.
+  #
+  # This allows information to carry forward between different invocations of
+  # the tool, e.g. remembering a previously-started Docker container.
+  class StateFile
+    def initialize(file:, logger:)
+      @file = file
+      @logger = logger
+      @mutex = Monitor.new
+    end
+
+    # Access the state as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @return [Array, Hash, Number, String]
+    def [](key)
+      @mutex.synchronize do
+        @hash[key.to_s]
+      end
+    end
+
+    # Set the state as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @param value [Array, Hash, Number, String]
+    def []=(key, value)
+      @mutex.synchronize do
+        @logger.debug "Updating state '#{key}' to #{value.inspect}"
+        @hash[key.to_s] = value
+        save unless @modifying
+        value
+      end
+    end
+
+    def modify(&block)
+      @mutex.synchronize do
+        @modifying = true
+        begin
+          result = block.call(self)
+          save
+          result
+        ensure
+          @modifying = false
+        end
+      end
+    end
+
+    # Loads persisted state.
+    def load
+      @hash =
+        if File.exist?(@file) && yaml = YAML.load_file(@file)
+          @logger.debug "Loading state from #{@file}"
+          yaml.to_hash
+        else
+          @logger.debug "No state file #{@file} exists; assuming empty state"
+          {} # Handle empty files
+        end
+    end
+
+    # Persists state to disk.
+    def save
+      @logger.debug "Saving state to #{@file}"
+      File.open(@file, 'w') { |f| f.write(@hash.to_yaml) }
+    end
+
+    # Destroy persisted state.
+    def destroy
+      @logger.debug "Removing state from #{@file}"
+      @hash = {}
+      FileUtils.rm_f(@file)
+    end
+  end
+end

data/lib/navo/suite.rb

@@ -8,9 +8,15 @@ module Navo
   class Suite
     attr_reader :name
 
-    def initialize(name:, config:)
+    def initialize(name:, config:, global_state:)
       @name = name
       @config = config
+      @logger = Navo::Logger.new(suite: self)
+      @global_state = global_state
+
+      state.modify do |local|
+        local['files'] ||= {}
+      end
     end
 
     def repo_root
@@ -35,35 +41,89 @@ module Navo
 
     # Copy file/directory from host to container.
     def copy(from:, to:)
+      @logger.debug("Copying file #{from} on host to file #{to} in container")
       system("docker cp #{from} #{container.id}:#{to}")
     end
 
+    def copy_if_changed(from:, to:, replace: false)
+      if File.directory?(from)
+        exec(%w[mkdir -p] + [to])
+      else
+        exec(%w[mkdir -p] + [File.dirname(to)])
+      end
+
+      current_hash = Utils.path_hash(from)
+      state['files'] ||= {}
+      old_hash = state['files'][from.to_s]
+
+      if !old_hash || current_hash != old_hash
+        if old_hash
+          @logger.debug "Previous hash recorded for #{from} (#{old_hash}) " \
+                        "does not match current hash (#{current_hash})"
+        else
+          @logger.debug "No previous hash recorded for #{from}"
+        end
+
+        state.modify do |local|
+          local['files'][from.to_s] = current_hash
+        end
+
+        exec(%w[rm -rf] + [to]) if replace
+        copy(from: from, to: to)
+        return true
+      end
+
+      false
+    end
+
+    # TODO: Move to a separate class, since this isn't really suite-specific,
+    # but global to the entire repository.
+    def path_changed?(path)
+      current_hash = Utils.path_hash(path)
+      @global_state['files'] ||= {}
+      old_hash = @global_state['files'][path.to_s]
+
+      @logger.debug("Old hash of #{path.to_s}: #{old_hash}")
+      @logger.debug("Current hash of #{path.to_s}: #{current_hash}")
+
+      @global_state.modify do |local|
+        local['files'][path.to_s] = current_hash
+      end
+
+      !old_hash || current_hash != old_hash
+    end
+
     # Write contents to a file on the container.
     def write(file:, content:)
+      @logger.debug("Writing content #{content.inspect} to file #{file} in container")
       container.exec(%w[bash -c] + ["cat > #{file}"], stdin: StringIO.new(content))
     end
 
     # Execte a command on the container.
-    def exec(args)
+    def exec(args, severity: :debug)
       container.exec(args) do |_stream, chunk|
-        STDOUT.print chunk
+        @logger.log(severity, chunk, flush: chunk.to_s.end_with?("\n"))
       end
     end
 
-    # Execute a command on the container, raising an error if it exists
+    # Execute a command on the container, raising an error if it exits
     # unsuccessfully.
-    def exec!(args)
-      out, err, status = exec(args)
+    def exec!(args, severity: :debug)
+      out, err, status = exec(args, severity: severity)
       raise Error::ExecutionError, "STDOUT:#{out}\nSTDERR:#{err}" unless status == 0
       [out, err, status]
     end
 
     def login
-      Kernel.exec('docker', 'exec', '-it', container.id, *@config['docker']['shell-command'])
+      Kernel.exec('docker', 'exec', '-it', container.id,
+                  *@config['docker'].fetch('shell_command', ['/bin/bash']))
     end
 
     def chef_solo_config
       return <<-CONF
+      load '/etc/chef/chef_formatter.rb'
+      formatter :navo
+
       node_name #{name.inspect}
       environment #{@config['chef']['environment'].inspect}
       file_cache_path #{File.join(chef_run_dir, 'cache').inspect}
@@ -78,59 +138,100 @@ module Navo
 
     def node_attributes
       suite_config = @config['suites'][name]
+
+      unless (run_list = Array(suite_config['run_list'])).any?
+        raise Navo::Errors::ConfigurationError,
+              "No `run_list` specified for suite #{name}!"
+      end
+
       @config['chef']['attributes']
         .merge(suite_config.fetch('attributes', {}))
-        .merge(run_list: suite_config['run-list'])
+        .merge(run_list: suite_config['run_list'])
     end
 
     def create
+      @logger.info "=====> Creating #{name}"
+      container
+      @logger.info "=====> Created #{name} in container #{container.id}"
       container
     end
 
     def converge
       create
 
+      @logger.info "=====> Converging #{name}"
       sandbox.update_chef_config
 
       _, _, status = exec(%W[
         /opt/chef/embedded/bin/chef-solo
         --config=#{File.join(chef_config_dir, 'solo.rb')}
         --json-attributes=#{File.join(chef_config_dir, 'first-boot.json')}
+        --format=navo
         --force-formatter
-      ])
+      ], severity: :info)
 
-      state['converged'] = status == 0
-      state.save
-      state['converged']
+      status == 0
     end
 
     def verify
       create
 
+      @logger.info "=====> Verifying #{name}"
       sandbox.update_test_config
 
-      _, _, status = exec(['/usr/bin/env'] + busser_env + %W[#{busser_bin} test])
+      _, _, status = exec(['/usr/bin/env'] + busser_env + %W[#{busser_bin} test],
+                          severity: :info)
       status == 0
     end
 
     def test
-      return false unless converge
-      verify
+      return false unless destroy
+      passed = converge && verify
+
+      should_destroy =
+        case @config['destroy']
+        when 'passing'
+          passed
+        when 'always'
+          true
+        when 'never'
+          false
+        end
+
+      should_destroy ? destroy : passed
     end
 
     def destroy
-      if @config['docker']['stop-command']
-        exec(@config['docker']['stop-command'])
-        container.wait(@config['docker'].fetch('stop-timeout', 10))
-      else
-        container.stop
+      @logger.info "=====> Destroying #{name}"
+
+      if state['container']
+        begin
+          if @config['docker']['stop_command']
+            @logger.info "Stopping container #{container.id} via command #{@config['docker']['stop_command']}"
+            exec(@config['docker']['stop_command'])
+            container.wait(@config['docker'].fetch('stop_timeout', 10))
+          else
+            @logger.info "Stopping container #{container.id}..."
+            container.stop
+          end
+        rescue Docker::Error::TimeoutError => ex
+          @logger.warn ex.message
+        ensure
+          begin
+            @logger.info("Removing container #{container.id}")
+            container.remove(force: true)
+          rescue Docker::Error::ServerError => ex
+            @logger.warn ex.message
+          end
+        end
       end
 
-      container.remove(force: true)
+      true
+    ensure
+      @container = nil
+      state.destroy
 
-      state['converged'] = false
-      state['container'] = nil
-      state.save
+      @logger.info "=====> Destroyed #{name}"
     end
 
     # Returns the {Docker::Image} used by this test suite, building it if
@@ -140,25 +241,35 @@ module Navo
     def image
      @image ||=
        begin
-         state['images'] ||= {}
+         @global_state.modify do |global|
+           global['images'] ||= {}
+         end
 
          # Build directory is wherever the Dockerfile is located
          dockerfile = File.expand_path(@config['docker']['dockerfile'], repo_root)
          build_dir = File.dirname(dockerfile)
 
          dockerfile_hash = Digest::SHA256.new.hexdigest(File.read(dockerfile))
-         image_id = state['images'][dockerfile_hash]
+         @logger.debug "Dockerfile hash is #{dockerfile_hash}"
+         image_id = @global_state['images'][dockerfile_hash]
 
          if image_id && Docker::Image.exist?(image_id)
+           @logger.debug "Previous image #{image_id} matching Dockerfile already exists"
+           @logger.debug "Using image #{image_id} instead of building new image"
            Docker::Image.get(image_id)
          else
+           @logger.debug "No image exists for #{dockerfile}"
+           @logger.debug "Building a new image with #{dockerfile} " \
+                         "using #{build_dir} as build context directory"
+
            Docker::Image.build_from_dir(build_dir) do |chunk|
              if (log = JSON.parse(chunk)) && log.has_key?('stream')
-               STDOUT.print log['stream']
+               @logger.info log['stream']
              end
            end.tap do |image|
-             state['images'][dockerfile_hash] = image.id
-             state.save
+             @global_state.modify do |global|
+               global['images'][dockerfile_hash] = image.id
+             end
            end
          end
        end
@@ -171,39 +282,68 @@ module Navo
     def container
       @container ||=
         begin
+          # Dummy reference so we build the image first (ensuring its log output
+          # appears before the container creation log output)
+          image
+
           if state['container']
             begin
               container = Docker::Container.get(state['container'])
+              @logger.debug "Loaded existing container #{container.id}"
             rescue Docker::Error::NotFoundError
-              # Continue creating the container since it doesn't exist
+              @logger.debug "Container #{state['container']} no longer exists"
             end
           end
 
           if !container
+            @logger.info "Building a new container from image #{image.id}"
+
             container = Docker::Container.create(
               'Image' => image.id,
               'OpenStdin' => true,
               'StdinOnce' => true,
               'HostConfig' => {
                 'Privileged' => @config['docker']['privileged'],
-                'Binds' => @config['docker']['volumes'],
+                'Binds' => @config['docker']['volumes'] + %W[
+                  #{Berksfile.vendor_directory}:#{File.join(chef_run_dir, 'cookbooks')}
+                  #{File.join(repo_root, 'data_bags')}:#{File.join(chef_run_dir, 'data_bags')}
+                  #{File.join(repo_root, 'environments')}:#{File.join(chef_run_dir, 'environments')}
+                  #{File.join(repo_root, 'roles')}:#{File.join(chef_run_dir, 'roles')}
+                ],
               },
             )
 
             state['container'] = container.id
-            state.save
           end
 
-          container.start
+          unless started?(container.id)
+            @logger.info "Starting container #{container.id}"
+            container.start
+          else
+            @logger.debug "Container #{container.id} already running"
+          end
+
+          container
         end
     end
 
+    def started?(container_id)
+      # There does not appear to be a simple "status" API we can use for an
+      # individual container
+      Docker::Container.all(all: true,
+                            filters: { id: [container_id],
+                            status: ['running'] }.to_json).any?
+    end
+
     def sandbox
-      @sandbox ||= Sandbox.new(suite: self)
+      @sandbox ||= Sandbox.new(suite: self, logger: @logger)
     end
 
     def storage_directory
-      File.join(repo_root, '.navo', 'suites', name)
+      @storage_directory ||=
+        File.join(repo_root, '.navo', 'suites', name).tap do |path|
+          FileUtils.mkdir_p(path)
+        end
     end
 
     def busser_directory
@@ -224,7 +364,12 @@ module Navo
     end
 
     def state
-      @state ||= SuiteState.new(suite: self).tap(&:load)
+      @state ||= StateFile.new(file: File.join(storage_directory, 'state.yaml'),
+                               logger: @logger).tap(&:load)
+    end
+
+    def log_file
+      @log_file ||= File.join(storage_directory, 'log.log')
     end
   end
 end