navo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3adda44205c06f6444cdc4969561ce867498cc6f
+  data.tar.gz: a8261f98b2e072aab9451df37b558c4b2376308a
+SHA512:
+  metadata.gz: ec8ecc5aee52a8c00aeaab4ffed1062f613f71a85b808327d1c0dd62e9d0326793a5e1cbe4f49a1628d46038b0b050e8ddc7884b90a1d9c9cc6dae39a4fa02a3
+  data.tar.gz: 940a3980f2acae81e2353e7c57d2a79d523bb7fa2d572f6b28a9c28bc8bdc1d96e02339aa55e0e5e0b97fca54387c1ee2bcffd793a2b2e4f5175bad72cc178e4

data/bin/navo

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'navo/cli'
+
+Navo::CLI.start(ARGV)

data/lib/navo.rb

@@ -0,0 +1,8 @@
+require 'navo/constants'
+require 'navo/errors'
+require 'navo/configuration'
+require 'navo/sandbox'
+require 'navo/suite'
+require 'navo/suite_state'
+require 'navo/utils'
+require 'navo/version'

data/lib/navo/cli.rb

@@ -0,0 +1,59 @@
+require 'berkshelf'
+require 'navo'
+require 'thor'
+
+module Navo
+  # Command line application interface.
+  class CLI < Thor
+    desc 'create', 'create a container for test suite(s) to run within'
+    def create(pattern = nil)
+      exit suites_for(pattern).map(&:create).all? ? 0 : 1
+    end
+
+    desc 'converge', 'run Chef for test suite(s)'
+    def converge(pattern = nil)
+      exit suites_for(pattern).map(&:converge).all? ? 0 : 1
+    end
+
+    desc 'verify', 'run test suite(s)'
+    def verify(pattern = nil)
+      exit suites_for(pattern).map(&:verify).all? ? 0 : 1
+    end
+
+    desc 'test', 'converge and run test suite(s)'
+    def test(pattern = nil)
+      exit suites_for(pattern).map(&:test).all? ? 0 : 1
+    end
+
+    desc 'destroy', 'clean up test suite(s)'
+    def destroy(pattern = nil)
+      exit suites_for(pattern).map(&:destroy).all? ? 0 : 1
+    end
+
+    desc 'login', "open a shell inside a suite's container"
+    def login(pattern)
+      suites = suites_for(pattern)
+      if suites.size > 1
+        puts 'Pattern matched more than one test suite'
+        exit 1
+      else
+        suites.first.login
+      end
+    end
+
+    private
+
+    def config
+      @config ||= Configuration.load_applicable
+    end
+
+    def suites_for(pattern)
+      suite_names = config['suites'].keys
+      suite_names.select! { |name| name =~ /#{pattern}/ } if pattern
+
+      suite_names.map do |suite_name|
+        Suite.new(name: suite_name, config: config)
+      end
+    end
+  end
+end

data/lib/navo/configuration.rb

@@ -0,0 +1,102 @@
+require 'pathname'
+require 'yaml'
+
+module Navo
+  # Stores runtime configuration for the application.
+  #
+  # This is intended to define helper methods for accessing configuration so
+  # this logic can be shared amongst the various components of the system.
+  class Configuration
+    # Name of the configuration file.
+    FILE_NAME = '.navo.yaml'
+
+    class << self
+      # Loads appropriate configuration file given the current working
+      # directory.
+      #
+      # @return [Navo::Configuration]
+      def load_applicable
+        current_directory = File.expand_path(Dir.pwd)
+        config_file = applicable_config_file(current_directory)
+
+        if config_file
+          from_file(config_file)
+        else
+          raise Errors::ConfigurationMissingError,
+                "No configuration file '#{FILE_NAME}' was found in the " \
+                "current directory or any ancestor directory.\n\n" \
+                "See #{REPO_URL}#configuration for instructions on setting up."
+        end
+      end
+
+      # Loads a configuration from a file.
+      #
+      # @return [Navo::Configuration]
+      def from_file(config_file)
+        options =
+          if yaml = YAML.load_file(config_file)
+            yaml.to_hash
+          else
+            {}
+          end
+
+        new(options: options, path: config_file)
+      end
+
+      private
+
+      # Returns the first valid configuration file found, starting from the
+      # current working directory and ascending to ancestor directories.
+      #
+      # @param directory [String]
+      # @return [String, nil]
+      def applicable_config_file(directory)
+        Pathname.new(directory)
+                .enum_for(:ascend)
+                .map { |dir| dir + FILE_NAME }
+                .find do |config_file|
+          config_file if config_file.exist?
+        end
+      end
+    end
+
+    # Creates a configuration from the given options hash.
+    #
+    # @param options [Hash]
+    def initialize(options:, path:)
+      @options = options
+      @path = path
+    end
+
+    # Returns the root of the repository to which this configuration applies.
+    #
+    # @return [String]
+    def repo_root
+      File.dirname(@path)
+    end
+
+    # Access the configuration as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @return [Array, Hash, Number, String]
+    def [](key)
+      @options[key.to_s]
+    end
+
+    # Access the configuration as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @return [Array, Hash, Number, String]
+    def fetch(key, *args)
+      @options.fetch(key.to_s, *args)
+    end
+
+    # Compares this configuration with another.
+    #
+    # @param other [HamlLint::Configuration]
+    # @return [true,false] whether the given configuration is equivalent
+    def ==(other)
+      super || @options == other.instance_variable_get('@options')
+    end
+  end
+end

data/lib/navo/constants.rb

@@ -0,0 +1,7 @@
+# Global application constants.
+module Navo
+  EXECUTABLE_NAME = 'navo'
+
+  REPO_URL = 'https://github.com/sds/navo'
+  BUG_REPORT_URL = "#{REPO_URL}/issues"
+end

data/lib/navo/errors.rb

@@ -0,0 +1,14 @@
+# Collection of errors that can be thrown by the application.
+module Navo::Errors
+  # Base class for all errors reported by this tool.
+  class NavoError < StandardError; end
+
+  # Raised when a command on a container fails.
+  class ExecutionError < NavoError; end
+
+  # Base class for all configuration-related errors.
+  class ConfigurationError < NavoError; end
+
+  # Raised when a configuration file is not present.
+  class ConfigurationMissingError < ConfigurationError; end
+end

data/lib/navo/sandbox.rb

@@ -0,0 +1,107 @@
+require 'berkshelf'
+require 'fileutils'
+require 'pathname'
+
+module Navo
+  # Manages the creation and maintenance of the test suite sandbox.
+  #
+  # The sandbox is just a directory that contains the files and configuration
+  # needed to run a test within the suite's container. A temporary directory on
+  # the host is maintained
+  class Sandbox
+    def initialize(suite:)
+      @suite = suite
+    end
+
+    def update_chef_config
+      install_cookbooks
+      install_chef_directories
+      install_chef_config
+    end
+
+    def update_test_config
+      test_files_dir = File.join(@suite.repo_root, %w[test integration])
+      suite_dir = File.join(test_files_dir, @suite.name)
+
+      # serverspec, bats, etc.
+      frameworks = Pathname.new(suite_dir).children
+                                          .select(&:directory?)
+                                          .map(&:basename)
+                                          .map(&:to_s)
+
+      suites_directory = File.join(@suite.busser_directory, 'suites')
+      @suite.exec!(%w[mkdir -p] + [suites_directory])
+
+      frameworks.each do |framework|
+        host_framework_dir = File.join(suite_dir, framework)
+        container_framework_dir = File.join(suites_directory, framework)
+
+        @suite.exec!(%w[rm -rf] + [container_framework_dir])
+
+        # In order to work with Busser, we need to copy the helper files into
+        # the same directory as the suite's spec files. This avoids issues with
+        # symlinks not matching up due to differences in directory structure
+        # 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..."
+          @suite.copy(from: File.join(helpers_directory, '.'),
+                      to: container_framework_dir)
+        end
+
+        puts "Transferring #{framework} tests..."
+        @suite.copy(from: File.join(host_framework_dir, '.'),
+                    to: container_framework_dir)
+      end
+
+    end
+
+    private
+
+    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)
+
+      puts 'Resolving Berksfile...'
+      @suite.exec!(%w[rm -rf] + [vendored_cookbooks_dir])
+      Berkshelf::Berksfile.from_file(berksfile).vendor(vendored_cookbooks_dir)
+
+      @suite.copy(from: File.join(storage_directory, 'cookbooks', '.'),
+                  to: File.join(@suite.chef_run_dir, 'cookbooks'))
+    end
+
+    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)
+
+        @suite.exec(%w[rm -rf] + [container_dir])
+        @suite.copy(from: host_dir, to: container_dir)
+      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))
+
+      puts 'Preparing solo.rb'
+      @suite.write(file: File.join(@suite.chef_config_dir, 'solo.rb'),
+                   content: @suite.chef_solo_config)
+      puts 'Preparing first-boot.json'
+      @suite.write(file: File.join(@suite.chef_config_dir, 'first-boot.json'),
+                   content: @suite.node_attributes.to_json)
+    end
+
+    def storage_directory
+      @storage_directory ||=
+        @suite.storage_directory.tap do |path|
+          FileUtils.mkdir_p(path)
+        end
+    end
+  end
+end

data/lib/navo/suite.rb

@@ -0,0 +1,230 @@
+require 'docker'
+require 'digest'
+require 'json'
+require 'shellwords'
+
+module Navo
+  # A test suite.
+  class Suite
+    attr_reader :name
+
+    def initialize(name:, config:)
+      @name = name
+      @config = config
+    end
+
+    def repo_root
+      @config.repo_root
+    end
+
+    def [](key)
+      @config[key.to_s]
+    end
+
+    def fetch(key, *args)
+      @config.fetch(key.to_s, *args)
+    end
+
+    def chef_config_dir
+      '/etc/chef'
+    end
+
+    def chef_run_dir
+      '/var/chef'
+    end
+
+    # Copy file/directory from host to container.
+    def copy(from:, to:)
+      system("docker cp #{from} #{container.id}:#{to}")
+    end
+
+    # Write contents to a file on the container.
+    def write(file:, content:)
+      container.exec(%w[bash -c] + ["cat > #{file}"], stdin: StringIO.new(content))
+    end
+
+    # Execte a command on the container.
+    def exec(args)
+      container.exec(args) do |_stream, chunk|
+        STDOUT.print chunk
+      end
+    end
+
+    # Execute a command on the container, raising an error if it exists
+    # unsuccessfully.
+    def exec!(args)
+      out, err, status = exec(args)
+      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'])
+    end
+
+    def chef_solo_config
+      return <<-CONF
+      node_name #{name.inspect}
+      environment #{@config['chef']['environment'].inspect}
+      file_cache_path #{File.join(chef_run_dir, 'cache').inspect}
+      file_backup_path #{File.join(chef_run_dir, 'backup').inspect}
+      cookbook_path #{File.join(chef_run_dir, 'cookbooks').inspect}
+      data_bag_path #{File.join(chef_run_dir, 'data_bags').inspect}
+      environment_path #{File.join(chef_run_dir, 'environments').inspect}
+      role_path #{File.join(chef_run_dir, 'roles').inspect}
+      encrypted_data_bag_secret #{File.join(chef_config_dir, 'encrypted_data_bag_secret').inspect}
+      CONF
+    end
+
+    def node_attributes
+      suite_config = @config['suites'][name]
+      @config['chef']['attributes']
+        .merge(suite_config.fetch('attributes', {}))
+        .merge(run_list: suite_config['run-list'])
+    end
+
+    def create
+      container
+    end
+
+    def converge
+      create
+
+      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')}
+        --force-formatter
+      ])
+
+      state['converged'] = status == 0
+      state.save
+      state['converged']
+    end
+
+    def verify
+      create
+
+      sandbox.update_test_config
+
+      _, _, status = exec(['/usr/bin/env'] + busser_env + %W[#{busser_bin} test])
+      status == 0
+    end
+
+    def test
+      return false unless converge
+      verify
+    end
+
+    def destroy
+      if @config['docker']['stop-command']
+        exec(@config['docker']['stop-command'])
+        container.wait(@config['docker'].fetch('stop-timeout', 10))
+      else
+        container.stop
+      end
+
+      container.remove(force: true)
+
+      state['converged'] = false
+      state['container'] = nil
+      state.save
+    end
+
+    # Returns the {Docker::Image} used by this test suite, building it if
+    # necessary.
+    #
+    # @return [Docker::Image]
+    def image
+     @image ||=
+       begin
+         state['images'] ||= {}
+
+         # 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]
+
+         if image_id && Docker::Image.exist?(image_id)
+           Docker::Image.get(image_id)
+         else
+           Docker::Image.build_from_dir(build_dir) do |chunk|
+             if (log = JSON.parse(chunk)) && log.has_key?('stream')
+               STDOUT.print log['stream']
+             end
+           end.tap do |image|
+             state['images'][dockerfile_hash] = image.id
+             state.save
+           end
+         end
+       end
+    end
+
+    # Returns the {Docker::Container} used by this test suite, starting it if
+    # necessary.
+    #
+    # @return [Docker::Container]
+    def container
+      @container ||=
+        begin
+          if state['container']
+            begin
+              container = Docker::Container.get(state['container'])
+            rescue Docker::Error::NotFoundError
+              # Continue creating the container since it doesn't exist
+            end
+          end
+
+          if !container
+            container = Docker::Container.create(
+              'Image' => image.id,
+              'OpenStdin' => true,
+              'StdinOnce' => true,
+              'HostConfig' => {
+                'Privileged' => @config['docker']['privileged'],
+                'Binds' => @config['docker']['volumes'],
+              },
+            )
+
+            state['container'] = container.id
+            state.save
+          end
+
+          container.start
+        end
+    end
+
+    def sandbox
+      @sandbox ||= Sandbox.new(suite: self)
+    end
+
+    def storage_directory
+      File.join(repo_root, '.navo', 'suites', name)
+    end
+
+    def busser_directory
+      '/tmp/busser'
+    end
+
+    def busser_bin
+      File.join(busser_directory, %w[gems bin busser])
+    end
+
+    def busser_env
+      %W[
+        BUSSER_ROOT=#{busser_directory}
+        GEM_HOME=#{File.join(busser_directory, 'gems')}
+        GEM_PATH=#{File.join(busser_directory, 'gems')}
+        GEM_CACHE=#{File.join(busser_directory, %w[gems cache])}
+      ]
+    end
+
+    def state
+      @state ||= SuiteState.new(suite: self).tap(&:load)
+    end
+  end
+end

data/lib/navo/suite_state.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+require 'yaml'
+
+module Navo
+  # Stores persisted state about a test suite.
+  #
+  # This allows information to carry forward between different invocations of
+  # the tool, e.g. remembering a previously-started Docker container.
+  class SuiteState
+    FILE_NAME = 'state.yaml'
+
+    def initialize(suite:)
+      @suite = suite
+    end
+
+    # Access the state as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @return [Array, Hash, Number, String]
+    def [](key)
+      @hash[key.to_s]
+    end
+
+    # Set the state as if it were a hash.
+    #
+    # @param key [String, Symbol]
+    # @param value [Array, Hash, Number, String]
+    def []=(key, value)
+      @hash[key.to_s] = value
+    end
+
+    # Loads persisted state.
+    def load
+      @hash =
+        if File.exist?(file_path) && yaml = YAML.load_file(file_path)
+          yaml.to_hash
+        else
+          {} # Handle empty files
+        end
+    end
+
+    # Persists state to disk.
+    def save
+      File.open(file_path, 'w') { |f| f.write(@hash.to_yaml) }
+    end
+
+    # Destroy persisted state.
+    def destroy
+      @hash = {}
+      FileUtils.rm_f(file_path)
+    end
+
+    private
+
+    def file_path
+      File.join(@suite.storage_directory, FILE_NAME)
+    end
+  end
+end

data/lib/navo/utils.rb

@@ -0,0 +1,54 @@
+require 'digest'
+require 'pathname'
+
+module Navo
+  # A miscellaneous set of utility functions.
+  module Utils
+    module_function
+
+    # Converts a string containing underscores/hyphens/spaces into CamelCase.
+    #
+    # @param [String] string
+    # @return [String]
+    def camel_case(string)
+      string.split(/_|-| /)
+            .map { |part| part.sub(/^\w/) { |c| c.upcase } }
+            .join
+    end
+
+    # Returns the given {Time} as a human-readable string based on that time
+    # relative to the current time.
+    #
+    # @param time [Time]
+    # @return [String]
+    def human_time(time)
+      date = time.to_date
+
+      if date == Date.today
+        time.strftime('%l:%M %p')
+      elsif date == Date.today - 1
+        'Yesterday'
+      elsif date > Date.today - 7
+        time.strftime('%A') # Sunday
+      elsif date.year == Date.today.year
+        time.strftime('%b %e') # Jun 22
+      else
+        time.strftime('%b %e, %Y') # Jun 22, 2015
+      end
+    end
+
+    # Convert string containing camel case or spaces into snake case.
+    #
+    # @see stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+    #
+    # @param [String] string
+    # @return [String]
+    def snake_case(string)
+      string.gsub(/::/, '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+    end
+  end
+end

data/lib/navo/version.rb

@@ -0,0 +1,4 @@
+# Defines the gem version.
+module Navo
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: navo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shane da Silva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.22'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Test Chef cookbooks in Docker containers
+email:
+- shane@dasilva.io
+executables:
+- navo
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/navo
+- lib/navo.rb
+- lib/navo/cli.rb
+- lib/navo/configuration.rb
+- lib/navo/constants.rb
+- lib/navo/errors.rb
+- lib/navo/sandbox.rb
+- lib/navo/suite.rb
+- lib/navo/suite_state.rb
+- lib/navo/utils.rb
+- lib/navo/version.rb
+homepage: https://github.com/sds/navo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Test Chef cookbooks in Docker containers
+test_files: []
+has_rdoc: