rzo 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6974bf3026de895a982abdcd218564cfb9fadd87
-  data.tar.gz: c949443d5fff2c64a36033aad8af9f1b7412f1c3
+  metadata.gz: 57197ea4ec41e6e0b5ae935a754b415ee3ef7ebc
+  data.tar.gz: ae8140e57a89faf648963cb66f96f45f1fdfa8e5
 SHA512:
-  metadata.gz: 7c43d4433d78e5f0af754a9c3001a3303bf3013c8ed2388ada4f648ff89e0538e707cb60db37271bc34d827d156dab783bf1c1e0bbbbb503bf248a04ad480be9
-  data.tar.gz: 6447d475c5c42783b201f14ec9c6ed1102fa7511054c5316c53b22f71e1fe076c948e56930322e2bee5273a8445b9581829ebf186888e740e2c4b0f21043a165
+  metadata.gz: 627ff40899c739564bd9cd0a5a8bdb0d5995ab76a650e11293a51cf322c456e7310709940b016d539e66c8a23984c17b2ccd67eaef52aadc4a2a8777affde89b
+  data.tar.gz: eaecfbd7e222a971b4c1737b0451b30e24a8dbd0a402ff46ffca2ba0c11895a98914e3618f4b49a21dd6205a166d14d68c9f3e0741eeba900e07c743e0f63eb6

data/.rubocop.yml

@@ -7,8 +7,11 @@ AllCops:
     - pkg/**/*
     - spec/fixtures/**/*
     - lib/rzo/trollop.rb
+    - Vagrantfile
 
 # Cop's to ignore
+Style/RedundantReturn:
+  Enabled: false
 
 Lint/UnneededDisable:
   Enabled: false
@@ -16,7 +19,13 @@ Lint/UnneededDisable:
 Layout/MultilineOperationIndentation:
   Enabled: false
 
+# if / else / end is more clear than conditional assignment
+Style/ConditionalAssignment:
+  Enabled: false
+
 # With this enabled it suggests a change that will break the Gemfile
+# Also, if name = hsh['name'] is really useful to avoid Unknown method called on
+# nil object errors.
 Lint/AssignmentInCondition:
   Enabled: false
 

data/.travis.yml

@@ -12,3 +12,4 @@ rvm:
 script:
   - 'bundle exec rake validate rubocop'
   - 'bundle exec rspec'
+  - 'scripts/functional_gem_behavior.sh'

data/CHANGELOG.md

@@ -1,7 +1,24 @@
 # Change Log
 
-## [v0.3.0](https://github.com/ghoneycutt/rizzo/tree/v0.3.0)
+## [v0.4.0](https://github.com/ghoneycutt/rizzo/tree/v0.4.0)
 
+[Full Changelog](https://github.com/ghoneycutt/rizzo/compare/v0.3.0...v0.4.0)
+
+**Closed issues:**
+
+- Add Safety Checking [\#16](https://github.com/ghoneycutt/rizzo/issues/16)
+- Fix uninitialized constant Rzo::App::Subcommand::Pathname \(NameError\) [\#14](https://github.com/ghoneycutt/rizzo/issues/14)
+- Add `rzo roles' command to list the roles [\#10](https://github.com/ghoneycutt/rizzo/issues/10)
+- Convert into a ruby gem [\#5](https://github.com/ghoneycutt/rizzo/issues/5)
+
+**Merged pull requests:**
+
+- \(\#16\) Add Directory Safety Checks [\#20](https://github.com/ghoneycutt/rizzo/pull/20) ([jeffmccune](https://github.com/jeffmccune))
+- \(\#14\) Fix uninitialized constant Pathname \(NameError\) [\#15](https://github.com/ghoneycutt/rizzo/pull/15) ([jeffmccune](https://github.com/jeffmccune))
+- Add functional testing [\#13](https://github.com/ghoneycutt/rizzo/pull/13) ([jeffmccune](https://github.com/jeffmccune))
+- \(\#10\) Add roles subcommand [\#12](https://github.com/ghoneycutt/rizzo/pull/12) ([jeffmccune](https://github.com/jeffmccune))
+
+## [v0.3.0](https://github.com/ghoneycutt/rizzo/tree/v0.3.0) (2017-08-24)
 [Full Changelog](https://github.com/ghoneycutt/rizzo/compare/v0.2.0...v0.3.0)
 
 **Merged pull requests:**

data/Guardfile

@@ -1,18 +1,14 @@
-# Note: The cmd option is now required due to the increasing number of ways
-#       rspec may be run, below are examples of the most common uses.
-#  * bundler: 'bundle exec rspec'
-#  * bundler binstubs: 'bin/rspec'
-#  * spring: 'bin/rspec' (This will use spring if running and you have
-#                          installed the spring binstubs per the docs)
-#  * zeus: 'zeus rspec' (requires the server to be started separately)
-#  * 'just' rspec: 'rspec'
-rspec_results = File.expand_path('.rspec_status')
-guard 'yard', server: false do
-  watch(%r{app\/.+\.rb})
-  watch(%r{lib\/.+\.rb})
-  watch(%r{ext\/.+\.c})
+# Convert a lib path to a spec path
+def to_spec(path)
+  path.sub('lib/', 'spec/').sub(/\.rb$/, '_spec.rb')
 end
 
+# guard 'yard', server: false do
+#   watch(%r{app\/.+\.rb})
+#   watch(%r{lib\/.+\.rb})
+#   watch(%r{ext\/.+\.c})
+# end
+
 guard :rubocop do
   watch(/.+\.rb$/)
   watch('Gemfile')
@@ -22,20 +18,39 @@ guard :rubocop do
   watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
 end
 
-guard :rspec, cmd: 'bundle exec rspec', results_file: rspec_results do
+guard :shell do
   require 'guard/rspec/dsl'
+  require 'pathname'
   dsl = Guard::RSpec::Dsl.new(self)
 
+  runner = proc do |p|
+    if system("rspec -fd #{p}")
+      n 'Spec tests pass', 'rspec', :success
+    else
+      n 'Spec tests fail', 'rspec', :failed
+    end
+    nil
+  end
+
   # Feel free to open issues for suggestions and improvements
 
   # RSpec files
   rspec = dsl.rspec
-  watch(rspec.spec_helper) { rspec.spec_dir }
-  watch(rspec.spec_support) { rspec.spec_dir }
-  watch(rspec.spec_files)
+  watch(rspec.spec_helper) do |m|
+    runner.call(m[0])
+  end
+  watch(rspec.spec_support) do
+    runner.call(m[0])
+  end
+  watch rspec.spec_files do |m|
+    runner.call(m[0])
+  end
 
   # Ruby files
   ruby = dsl.ruby
-  dsl.watch_spec_files_for(ruby.lib_files)
+  watch(ruby.lib_files) do |m|
+    spec = Pathname.new(to_spec(m[0]))
+    runner.call(spec.to_s) if spec.readable?
+  end
 end
 # vim:ft=ruby

data/README.md

@@ -4,6 +4,12 @@ Rizzo is a heavily customized Vagrant configuration and work flow with a
 role based focus. It is meant to make working with Vagrant easier and
 purpose built for layered Puppet control repositories.
 
+Rizzo loads a personal configuration file, `~/.rizzo.json` by default, which
+lists one or more control repositories.  Rizzo then looks for a loads a
+`.rizzo.json` configuration file located at the root of the top level control
+repository.  The top level control repository is the first listed in
+the array of control repositories in the personal configuration file.
+
 There should be at least one node for every role that is managed by a
 control repo. This information is stored in `.rizzo.json` under the
 control repo. This makes it apparent what roles are available and aids
@@ -90,7 +96,11 @@ repo.
 
 ## `~/.rizzo.json`
 
-Change the paths to your git repos
+The personal configuration file is loaded first from `~/.rizzo.json` by default.
+The global `--config` option allows the end user to specific a different path to
+the personal configuration file.
+
+Using this example, change the paths to your git repos:
 
 ```json
 {
@@ -98,6 +108,7 @@ Change the paths to your git repos
     "bootstrap_repo_path": "/Users/gh/git/bootstrap"
   },
   "control_repos": [
+    "/Users/gh/git/puppet-control-myteam",
     "/Users/gh/git/puppetdata",
     "/Users/gh/git/puppet-modules"
   ],
@@ -124,11 +135,16 @@ Change the paths to your git repos
 }
 ```
 
-Once you have `~/.rizzo.json`, change to your top level control repository and generate your `Vagrantfile`.
+Once you have a personal config file, `~/.rizzo.json`, change directories to
+your top level control repository and generate your `Vagrantfile`:
 
 ```shell
+cd ~/git/puppet-control-myteam
 bundle exec rizzo generate
 ```
+
+Expected output:
+
 ```
 Wrote vagrant config to Vagrantfile
 ```
@@ -155,8 +171,8 @@ VM, run `vagrant status NAME`.
 ### defaults
 
 The defaults hash is merged with each node entries hash. Put user
-specific entries in `~/.rizzo.json` and project specific entries in
-`${PATH_TO_CONTROL_REPO}/.rizzo.json`.
+specific entries in the personal configuration file at `~/.rizzo.json` and
+control repo specific entries in `${PATH_TO_CONTROL_REPO}/.rizzo.json`.
 
 ### control_repos
 

data/lib/rzo/app.rb

@@ -3,6 +3,7 @@ require 'rzo/logging'
 require 'rzo/option_parsing'
 require 'rzo/app/config'
 require 'rzo/app/generate'
+require 'rzo/app/roles'
 require 'json'
 
 module Rzo
@@ -24,9 +25,11 @@ module Rzo
     # method in the app controller
     class ErrorAndExit < StandardError
       attr_accessor :exit_status
+      attr_accessor :log_fatal
       def initialize(message = nil, exit_status = 1)
         super(message)
         self.exit_status = exit_status
+        self.log_fatal = []
       end
     end
 
@@ -59,6 +62,12 @@ module Rzo
       @generate ||= Generate.new(opts, @stdout, @stderr)
     end
 
+    ##
+    # Accessor to Subcommand::Config
+    def config
+      @config ||= Config.new(opts, @stdout, @stderr)
+    end
+
     ##
     # Override this later to allow trollop to write to an intercepted file
     # descriptor for testing.  This will avoid trollop's behavior of calling
@@ -76,14 +85,17 @@ module Rzo
     def run
       case opts[:subcommand]
       when 'config'
-        Config.new(opts, @stdout, @stderr).run
+        config.run
       when 'generate'
         generate.run
+      when 'roles'
+        Roles.new(opts, @stdout, @stderr).run
       else
         educate
       end
     rescue ErrorAndExit => e
-      log.error e.message
+      log.fatal e.message
+      e.log_fatal.each { |m| log.fatal(m) }
       e.backtrace.each { |l| log.debug(l) }
       e.exit_status
     end

data/lib/rzo/app/config_validation.rb

@@ -0,0 +1,306 @@
+require 'rzo/app'
+require 'pathname'
+require 'json-schema'
+# rubocop:disable Style/GuardClause
+module Rzo
+  class App
+    ##
+    # Mix-in module providing configuration validation methods and safety
+    # checking.  The goal is to provide useful feedback to the end user in the
+    # situation where ~/.rizzo.json is configured to point at directories which
+    # do not exist, have missing keys, etc...
+    # rubocop:disable Metrics/ModuleLength
+    module ConfigValidation
+      ## Rizzo configuration schema for the personal configuration file at
+      # ~/.rizzo.json.  Minimum necessary to load the complete configuration from
+      # all control repositories.
+      RZO_PERSONAL_CONFIG_SCHEMA = {
+        '$schema' => 'http://json-schema.org/draft-06/schema#',
+        title: 'Personal Configuration',
+        description: 'Rizzo personal configuration file',
+        type: 'object',
+        properties: {
+          defaults: {
+            type: 'object',
+          },
+          control_repos: {
+            type: 'array',
+            items: { type: 'string' },
+            uniqueItems: true,
+          },
+        },
+        required: ['control_repos'],
+      }.freeze
+      ## Rizzo complete configuration schema.  This should move to a JSON file outside
+      # the code.
+      RZO_REPO_CONFIG_SCHEMA = {
+        type: 'object',
+        required: %w[defaults control_repos puppetmaster],
+        properties: {
+          defaults: {
+            type: 'object',
+            required: ['bootstrap_repo_path'],
+            properties: {
+              bootstrap_repo_path: {
+                type: 'string',
+                pattern: '^([a-zA-Z]:){0,1}(/[^/]+)+$',
+              },
+            },
+          },
+          puppetmaster: {
+            type: 'object',
+            required: %w[name modulepath synced_folders],
+            properties: {
+              name: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              modulepath: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              synced_folders: {
+                '$schema' => 'http://json-schema.org/draft-06/schema#',
+                type: 'object',
+                properties: {
+                  '/' => {},
+                  patternProperties: {
+                    '^(/[^/]+)+$' => {},
+                  },
+                  additionalProperties: false,
+                  required: ['/'],
+                }
+              },
+            },
+          },
+          control_repos: {
+            type: 'array',
+            items: { type: 'string' },
+            uniqueItems: true,
+          },
+          nodes: {
+            type: 'array',
+            items: {
+              type: 'object',
+              required: %w[name hostname ip],
+              properties: {
+                name: { type: 'string' },
+                hostname: { type: 'string' },
+                ip: { type: 'string' },
+                memory: {
+                  type: 'string',
+                  pattern: '^[0-9]+$'
+                },
+                forwarded_ports: {
+                  type: 'array',
+                  items: {
+                    type: 'object',
+                    required: %w[guest host],
+                    properties: {
+                      guest: {
+                        type: 'string',
+                        pattern: '^[0-9]+$',
+                      },
+                      host: {
+                        type: 'string',
+                        pattern: '^[0-9]+$',
+                      },
+                    },
+                  },
+                },
+              },
+            },
+            uniqueItems: true,
+          }
+        },
+      }.freeze
+      # The checks to execute, in order.  Each method must return nil if there
+      # are no issues found.  Otherwise, the check should return either one, or
+      # an array of Issue instances.
+      CHECKS_PERSONAL_CONFIG = %i[validate_personal_schema validate_control_repos].freeze
+      CHECKS_REPO_CONFIG = %i[validate_schema validate_defaults_key validate_control_repos].freeze
+
+      ##
+      # Class to model an issue found during validation
+      class Issue
+        attr_accessor :message
+
+        def initialize(msg)
+          self.message = msg
+        end
+
+        def to_s
+          message
+        end
+      end
+
+      ##
+      # Compute Issues given a config map (base or complete), and an Array of
+      # methods to execute.
+      #
+      # @param [Array<Symbol>] checks the method identifiers to execute, passing
+      #   config.  These methods must return nil (no issue found), an Issue
+      #   instance, or Array<Instance> for multiple issues found.
+      #
+      # @param [Hash] config the config hash, either a base configuration or a
+      #   fully merged configuration.
+      #
+      # @return [Array<Issue>] Array of issue instances, or an empty array if no
+      #   issues found with the config.
+      def compute_issues(checks, config)
+        ctx = self
+        checks.each_with_object([]) do |mth, ary|
+          debug "Checking config for #{mth} issues"
+          if issue = ctx.send(mth, config)
+            # May get back an Array<Issue> or one Issue
+            ary.concat([*issue])
+          end
+        end
+      end
+
+      ##
+      # Validate a personal configuration, typically originating from
+      # ~/.rizzo.json. This configuration is necessary to build a complete
+      # control repo configuration using the top level control repo. This
+      # validation focuses on the minimum necessary configuration to bootstrap
+      # the complete configuration, primarily the repo locations and existence.
+      def validate_personal_config!(config)
+        issues = compute_issues(CHECKS_PERSONAL_CONFIG, config)
+        if issues.empty?
+          debug 'No issues detected with the personal configuration.'
+        else
+          validate_inform!(issues)
+        end
+      end
+
+      ##
+      # Validate a complete loaded configuration.  This is distinct from a base
+      # configuration in that the JSON files in each control repository have
+      # already been merged, in order, on top of the base configuration
+      # originating at ~/.rizzo.json.  This implements safety checking.  These
+      # methods are expected to execute within the context of a
+      # Rzo::App::Subcommand instance, therefore log methods and the parsed
+      # configuration are assumed to be available.
+      #
+      # The approach is to collect an Array of Issue instances.  If issues are
+      # found, control is handed off to validate_inform! to inform the user of
+      # the issues and potentially abort the program.
+      #
+      # @param [Hash] config the config hash, fully merged by load_config!
+      def validate_complete_config!(config)
+        issues = compute_issues(CHECKS_REPO_CONFIG, config)
+        if issues.empty?
+          debug 'No issues detected with the complete, merged configuration.'
+        else
+          validate_inform!(issues)
+        end
+      end
+
+      ##
+      # Validate using
+      # [json-schema](https://github.com/ruby-json-schema/json-schema)
+      #
+      # @return [Issue,nil] Issue found, or nil if no issues found.
+      def validate_schema(config)
+        if JSON::Validator.validate(RZO_REPO_CONFIG_SCHEMA, config)
+          debug 'No schema violations found in loaded config.'
+          return nil
+        else
+          err_msgs = JSON::Validator.fully_validate(RZO_REPO_CONFIG_SCHEMA, config)
+          return err_msgs.map { |msg| Issue.new("Schema violation: #{msg}") }
+        end
+      end
+
+      ##
+      # Validate the configuration has a top level key named "defaults" and the
+      # value is a Hash map.
+      # rubocop:disable Metrics/MethodLength
+      #
+      # @return [Issue,nil] Issue found, or nil if no issues found.
+      def validate_defaults_key(config)
+        if defaults = config['defaults']
+          return Issue.new('Top level key "defaults" must have a Hash value') unless defaults.is_a? Hash
+        else
+          return Issue.new('Configuration does not contain top level "defaults" key')
+        end
+        if pth = defaults['bootstrap_repo_path']
+          return Issue.new('#/defaults/bootstrap_repo_path is not a String') unless pth.is_a? String
+        else
+          return Issue.new 'Configuration "defaults" value does not contain a '\
+            '"bootstrap_repo_path" key.  For example, '\
+            '{"defaults":{"bootstrap_repo_path":"/tmp/foo"}}'
+        end
+        validate_existence(pth, '#/defaults/bootstrap_repo_path value of ')
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      ##
+      # Validate the top level "control_repos" key, which should have a value of
+      # Array<String> where each string value is a fully qualified path.
+      #
+      # @return [Issue,nil] Issue found, or nil if no issues found.
+      def validate_control_repos(config)
+        if repos = config['control_repos']
+          return Issue.new('Top level key "control_repos" must have an Array value') unless repos.is_a? Array
+        else
+          return Issue.new('Top level key "control_repos" is not specified.  It must be an Array of paths to your control repos.')
+        end
+        repos.each_with_object([]) do |pth, ary|
+          if issue = validate_existence(pth, '#/control_repos')
+            ary << issue
+          end
+        end
+      end
+
+      ##
+      # Given a string, validate it's a fully qualified path, readable, and a
+      # git directory.
+      #
+      # @return [Issue,Array<Issue>,nil] nil if no issues found, or one or more
+      #   Issue instances.
+      def validate_existence(path, prefix = '')
+        pn = Pathname.new(path)
+        git = pn + '.git'
+        return Issue.new("#{prefix}#{pn} is not an absolute path.  It must be fully qualified, not relative") unless pn.absolute?
+        return Issue.new("#{prefix}#{pn} is not a directory.  Has it been cloned?") unless pn.directory?
+        return Issue.new("#{prefix}#{pn} is not readable.  Are permissions correct?") unless pn.readable?
+        return Issue.new("#{prefix}#{git} does not exist.  Has #{git.dirname} been cloned properly?") unless git.directory?
+      end
+
+      ##
+      # Validate the personal configuration, focus on ensuring the rest of the
+      # configuration can load properly.
+      #
+      # @return [Issue,Array<Issue>,nil] nil if no issues found, or one or more
+      #   Issue instances.
+      def validate_personal_schema(config)
+        if JSON::Validator.validate(RZO_PERSONAL_CONFIG_SCHEMA, config)
+          debug 'No schema violations found in personal configuration file.'
+          return nil
+        else
+          err_msgs = JSON::Validator.fully_validate(RZO_PERSONAL_CONFIG_SCHEMA, config)
+          return err_msgs.map { |msg| Issue.new("Personal config problem: #{msg}") }
+        end
+      end
+
+      # Inform the user about issues found and exit the program.  The top level
+      # exception handler is not expected to display much information on
+      # validation errors.  This method is expected to provide the helpful
+      # guidance.
+      #
+      # @param [Array<Issue>] issues Array of issues.  Each hash must have at
+      # least a key named `:message`
+      def validate_inform!(issues)
+        if opts[:validate]
+          msg = "Validation issues found with #{opts[:config]}"
+          exc = ErrorAndExit.new(msg, 2)
+          exc.log_fatal = issues.each_with_object([]) { |i, a| a << i.to_s }
+          raise exc
+        else
+          issues.each { |i| log.warn(i.to_s) }
+        end
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/rzo/app/roles.rb

@@ -0,0 +1,31 @@
+require 'rzo/app/subcommand'
+module Rzo
+  class App
+    ##
+    # Load all rizzo config files and print the roles
+    class Roles < Subcommand
+      attr_reader :config
+
+      ##
+      # Map the combined config to a list of roles.  No effort is made to sort
+      # them.
+      #
+      # @return [Array<String>] array of strings identifying each Puppet role
+      # name.  This is the same as the name of the VM.
+      def roles
+        return [] unless nodes = config['nodes']
+        nodes.each_with_object([]) do |node, a|
+          next unless node['name']
+          a << node['name']
+        end
+      end
+
+      def run
+        exit_status = 0
+        load_config!
+        write_file(opts[:output]) { |fd| fd.puts(roles) }
+        exit_status
+      end
+    end
+  end
+end

data/lib/rzo/app/subcommand.rb

@@ -1,9 +1,12 @@
+require 'pathname'
 require 'rzo/logging'
 require 'deep_merge'
+require 'rzo/app/config_validation'
 module Rzo
   class App
     # The base class for subcommands
     class Subcommand
+      include ConfigValidation
       include Logging
       extend Logging
       # The options hash injected from the application controller via the
@@ -55,12 +58,14 @@ module Rzo
       # at first match and merge on top of local, defaults (~/.rizzo.json)
       def load_config!
         config = load_rizzo_config(opts[:config])
-        validate_config(config)
+        validate_personal_config!(config)
         repos = config['control_repos']
         @config = load_repo_configs(config, repos)
         debug "Merged configuration: \n#{JSON.pretty_generate(@config)}"
-        validate_forwarded_ports(@config)
-        validate_ip_addresses(@config)
+        # TODO: Move these validations to an instance method?
+        validate_complete_config!(@config)
+        # validate_forwarded_ports(@config)
+        # validate_ip_addresses(@config)
         @config
       end
 
@@ -87,17 +92,6 @@ module Rzo
         end
       end
 
-      ##
-      # Basic validation of the configuration file content.
-      #
-      # @param [Hash] config the configuration map
-      def validate_config(config)
-        errors = []
-        errors.push 'control_repos key is not an Array' unless config['control_repos'].is_a?(Array)
-        errors.each { |l| log.error l }
-        raise ErrorAndExit, 'Errors found in config file.  Cannot proceed.' unless errors.empty?
-      end
-
       ##
       # Check for duplicate forwarded host ports across all hosts and exit
       # non-zero with an error message if found.

data/lib/rzo/option_parsing.rb

@@ -47,7 +47,7 @@ module Rzo
     # name.
     #
     # @return [Hash<Symbol, String>] Global options
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     def parse_global_options!(argv, env)
       semver = Rzo::VERSION
       prog_name = NAME
@@ -58,9 +58,13 @@ module Rzo
         log_msg = 'Log file to write to or keywords '\
           'STDOUT, STDERR {RZO_LOGTO}'
         opt :logto, log_msg, default: env['RZO_LOGTO'] || 'STDERR'
+        opt :validate, 'Check the configuration for common issues {RZO_VALIDATE="false"}',
+            default: env['RZO_VALIDATE'] == 'false' ? false : true
         opt :syslog, 'Log to syslog', default: false, conflicts: :logto
-        opt :verbose, 'Set log level to INFO'
-        opt :debug, 'Set log level to DEBUG'
+        opt :verbose, 'Set log level to INFO {RZO_VERBOSE="true"}',
+            default: env['RZO_VERBOSE'] == 'true'
+        opt :debug, 'Set log level to DEBUG {RZO_DEBUG="true"}',
+            default: env['RZO_DEBUG'] == 'true'
         opt :config, 'Rizzo config file {RZO_CONFIG}',
             default: env['RZO_CONFIG'] || '~/.rizzo.json'
       end
@@ -86,7 +90,7 @@ module Rzo
     # parsed.
     #
     # @return [Hash<Symbol, String>] Subcommand specific options hash
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
     def parse_subcommand_options!(subcommand, argv, env)
       prog_name = NAME
       case subcommand
@@ -100,11 +104,16 @@ module Rzo
           banner "#{prog_name} #{subcommand} options:"
           opt :vagrantfile, 'Output Vagrantfile', short: 'o', default: env['RZO_VAGRANTFILE'] || 'Vagrantfile'
         end
+      when 'roles'
+        Rzo::Trollop.options(argv) do
+          banner "#{prog_name} #{subcommand} options:"
+          opt :output, 'Roles output', short: 'o', default: env['RZO_OUTPUT'] || 'STDOUT'
+        end
       else
         Rzo::Trollop.die "Unknown subcommand: #{subcommand.inspect}"
       end
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
 
     # The name of the executable, could be `rizzo` or `rzo`
     NAME = File.basename($PROGRAM_NAME).freeze
@@ -116,6 +125,7 @@ Sub Commands:
 
   config       Print out the combined rizzo json config
   generate     Initialize Vagrantfile in top control repo
+  roles        Output all roles defined in the combined config
 
 Global options: (Note, command line arguments supersede ENV vars in {}'s)
     EOBANNER

data/lib/rzo/version.rb

@@ -5,7 +5,7 @@ module Rzo
   # The authoritative location of the rzo version.  It should be possible to
   # `require 'rizzo/version'` and access `Rizzo::VERSION` from third party
   # libraries and the gemspec.  The version is defined as a Semantic Version.
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 
   ##
   # Return the SemVer string, e.g. `"0.1.0"`

data/rzo.gemspec

@@ -42,5 +42,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'guard-shell', '~> 0.7'
   spec.add_development_dependency 'simplecov', '~> 0.14'
   spec.add_dependency 'json', '~> 2.1'
+  spec.add_dependency 'json-schema', '~> 2.8'
   spec.add_dependency 'deep_merge', '~> 1.1'
 end

data/scripts/functional_gem_behavior.sh

@@ -0,0 +1,343 @@
+#! /bin/bash
+#
+# Test to ensure the gem actually builds.  Pre-requisite step to verify the gem
+# installs.  Run this script from the repository root.
+# can
+
+# Turn off validation for testing purposes.  We'll turn it back on for explicit
+# testing of the validation behavior
+export RZO_VALIDATE='false'
+
+set -eu
+
+STAMP=$(date +%s)
+
+if [[ -z "${NO_COLOR:-}" ]]; then
+  NC='\033[0m' # No Color
+  RED='\033[0;31m'
+  GREEN='\033[0;32m'
+  YELLOW='\033[0;33m'
+  BLUE='\033[0;34m'
+else
+  NC=''
+  RED=''
+  GREEN=''
+  YELLOW=''
+  BLUE=''
+fi
+
+# Describe the test with a nice heading
+desc() {
+  msg="$1"
+  echo
+  echo -e "${GREEN}${msg}${NC}"
+  echo "${msg//?/=}"
+  return 0
+}
+
+testcase() {
+  msg="$1"
+  echo -en "  * ${NC}${msg}:${NC} "
+  return 0
+}
+
+# Look for a string in some output, e.g. stderr or stdout.
+match() {
+  msg="$1"      # descriptive message
+  expected="$2" # a file
+  actual="$3"   # extended regexp
+  testcase "$msg"
+  if grep -qE "$expected" "$actual"; then
+    pass "It does."
+    return 0
+  else
+    echo "Expected $actual to contain '${expected}', but it did not." >&2
+    echo "Expected:"
+    cat "$expected"
+    echo
+    echo "Actual:"
+    cat "$actual"
+    fail "Did not find '$expected' in $actual"
+    return 1
+  fi
+}
+
+pass() {
+  msg="$1"
+  echo -e "${GREEN}PASS:${NC} ${msg}" >&2
+  return 0
+}
+
+fail() {
+  msg="$1"
+  echo -e "${RED}FAIL:${NC} $msg" >&2
+  return 1
+}
+
+warn() {
+  msg="$1"
+  echo -e "${YELLOW}Warning:${NC} $msg" >&2
+}
+
+err() {
+  msg="$1"
+  echo -e "${RED}Error:${NC} $msg" >&2
+}
+
+debug() {
+  [[ -z "${DEBUG:-}" ]] && return 0
+  msg="$1"
+  echo -e "${BLUE}Debug:${NC} $msg" >&2
+}
+
+# Move ~/.rizzo.json out of the way if it exists
+if [[ -e ~/.rizzo.json ]]; then
+  debug "Moving ~/.rizzo.json to ~/.rizzo.json.$STAMP"
+  mv -f ~/.rizzo.json ~/.rizzo.json.$STAMP
+fi
+
+# Clean up our temp directory
+scratch=$(mktemp -d)
+export TMPDIR="$scratch"
+finish() {
+  if [[ -e ~/.rizzo.json.$STAMP ]]; then
+    mv -f ~/.rizzo.json.$STAMP ~/.rizzo.json
+    debug "Moved ~/.rizzo.json.$STAMP to ~/.rizzo.json"
+  fi
+  if [[ -d "$scratch" ]]; then
+    rm -rf "$scratch"
+    debug "Removed $scratch"
+  fi
+}
+trap finish EXIT
+
+[ -d pkg ] && rm -rf pkg
+mkdir pkg
+bundle exec rake build
+
+# Load RVM into a shell session *as a function*.  This is necessary to switch
+# gemsets.  This script should still operate without rvm, but it would pollute
+# GEM_HOME, so must be explicitly enabled by the user using RZO_GEM_INSTALL
+for i in "$HOME/.rvm/scripts/rvm" "/usr/local/rvm/scripts/rvm"; do
+  if [[ -s "$i" ]]; then
+    set +u # RVM uses unbound variables, which makes me very sad. :(
+    source "$i"
+    RZO_GEM_INSTALL=yes
+    break
+  fi
+done
+
+# We use a custom gemset to ensure the build dependency bundle is isolated from
+# the functional testing phase.
+if [[ -z ${RZO_GEM_INSTALL:-} ]]; then
+  warn "rvm not found, GEM_HOME will be tainted by the tests."
+  warn "To proceed anyway, run: INSTALL_TO_GEM_HOME=true $0"
+  [[ -z ${INSTALL_TO_GEM_HOME:-} ]] && exit 1
+else
+  rvm gemset create cleanroom
+  rvm gemset use cleanroom
+fi
+
+desc "The gem environment used for functional testing"
+gem env
+
+desc "There should be minimal gems installed initially"
+gem list
+
+desc "Install the gem"
+gem install pkg/*.gem
+
+desc "The gem and dependencies should be installed"
+gem list
+
+desc "The executable should be in the path"
+which rzo
+
+desc "rzo --help should contain usage"
+stdout=$(mktemp -t XXXXXX.stdout)
+rzo --help | tee $stdout
+expected='usage: .*GLOBAL OPTIONS.*SUBCOMMAND.*ARGS'
+if ! grep -qE "$expected" $stdout; then
+  fail "rzo --help STDOUT does not contain '$expected'"
+fi
+
+desc "rzo --version should output a semantic version string"
+stdout=$(mktemp -t XXXXXX.stdout)
+rzo --version | tee $stdout
+grep -qE '[0-9]+\.[0-9]+\.[0-9]' $stdout
+
+desc "rzo bare (no arguments) should match --help"
+bare_output=$(mktemp -t XXXXXX.rzo_bare)
+help_output=$(mktemp -t XXXXXX.rzo_help)
+rzo > $bare_output
+rzo --help > $help_output
+if diff -U2 $help_output $bare_output; then
+  pass "It does."
+else
+  fail "rzo is not the same as rzo --help"
+fi
+
+desc "rzo config with no config should be helpful"
+stdout=$(mktemp -t XXXXXX.stdout)
+stderr=$(mktemp -t XXXXXX.stderr)
+rzo config 2> $stderr | tee $stdout
+expected="Cannot read config file"
+if ! grep -E "$expected" $stderr; then
+  echo "STDERR:"
+  cat $stderr >&2
+  fail "rzo config STDERR does not contain '$expected'"
+else
+  pass "Looks good."
+fi
+
+# Puppet data repositories used by rizzo
+PUPPETDATA="${TMPDIR}/git/puppetdata"
+
+desc "With a valid ~/.rizzo.json file looking like:"
+cat > ~/.rizzo.json <<EOCONFIG
+{
+  "defaults": { "bootstrap_repo_path": "${HOME}/git/bootstrap" },
+  "control_repos": [ "${PUPPETDATA}", "${HOME}/git/ghoneycutt-modules" ],
+  "puppetmaster": {
+    "name": [ "puppetca", "puppet" ],
+    "modulepath": [ "./modules", "./puppetdata/modules", "./ghoneycutt/modules" ],
+    "synced_folders": {
+      "/repos/puppetdata": { "local": "${PUPPETDATA}", "owner": "root", "group": "root" },
+      "/repos/ghoneycutt": { "local": "${HOME}/git/ghoneycutt-modules", "owner": "root", "group": "root" }
+    }
+  }
+}
+EOCONFIG
+# Print out the config
+expected=$(mktemp -t XXXXXX.rizzo.json)
+ruby -rjson -e 'puts JSON.pretty_generate(JSON.parse(ARGF.read))' ~/.rizzo.json | tee $expected
+
+desc "rzo config is expected to pretty generate the JSON config"
+stdout=$(mktemp -t XXXXXX.stdout)
+stderr=$(mktemp -t XXXXXX.stderr)
+rzo config > $stdout 2> $stderr
+if diff -U2 $expected $stdout; then
+  pass "It does."
+else
+  fail "rzo config STDOUT differs from expected pretty generated config"
+fi
+
+desc "rzo generate produces a minimal Vagrantfile"
+
+expected=$(mktemp -t XXXXXXX.vagrantfile)
+actual=$(mktemp -t XXXXXXX.vagrantfile)
+# NOTE: The first line is omitted because it contains a timestamp
+cat > $expected <<VAGRANTFILE
+# https://github.com/ghoneycutt/rizzo
+Vagrant.configure(2) do |config|
+  # use 'vagrant plugin install vagrant-proxyconf' to install
+  if Vagrant.has_plugin?('vagrant-proxyconf')
+    config.proxy.http  = ENV['HTTP_PROXY']  if ENV['HTTP_PROXY']
+    config.proxy.https = ENV['HTTPS_PROXY'] if ENV['HTTPS_PROXY']
+  end
+end
+# -*- mode: ruby -*-
+# vim:ft=ruby
+VAGRANTFILE
+
+stdout=$(mktemp -t XXXXXX.stdout)
+stderr=$(mktemp -t XXXXXX.stderr)
+rzo generate 2> $stderr
+tail -n+2 Vagrantfile > $actual
+if diff -U2 $expected $actual; then
+  pass "It does."
+else
+  fail "rzo generate produced a Vagrantfile different than expected"
+fi
+
+expected="Wrote vagrant config to Vagrantfile"
+desc "rzo generate STDERR is expected to match '$expected'"
+if ! grep -qE "$expected" $stderr; then
+  echo "Expected:"
+  echo "$expected"
+  echo
+  echo "Actual:"
+  cat $stderr
+  echo
+  fail "Expected STDOUT of rzo generate does not match actual output"
+else
+  pass "It does."
+fi
+
+desc "rzo roles with no personal .rizzo.json is expected to warn"
+stdout=$(mktemp -t XXXXXX.stdout)
+stderr=$(mktemp -t XXXXXX.stderr)
+rzo roles 2> $stderr > $stdout
+
+match "warns about puppetdata not being a directory" 'WARN .*puppetdata is not a directory' $stderr
+match "warns about ghoneycutt-modules not being a directory" 'WARN .*ghoneycutt-modules is not a directory' $stderr
+match "warns about bootstrap not being a directory" 'WARN .*bootstrap is not a directory' $stderr
+
+desc "with a single puppetca role, rzo roles outputs the role name"
+if ! [[ -d "$PUPPETDATA" ]]; then
+  mkdir -p "$PUPPETDATA"
+  debug "Created $PUPPETDATA"
+fi
+echo '{"nodes":[{"name":"puppetca"}]}' > ${PUPPETDATA}/.rizzo.json
+
+stdout=$(mktemp -t XXXXXX.stdout)
+stderr=$(mktemp -t XXXXXX.stderr)
+rzo roles 2> $stderr > $stdout
+expected='puppetca'
+if grep -qxE "$expected" $stdout; then
+  pass "rzo roles STDOUT, expected: '$expected' got: '$(cat $stdout)'"
+else
+  fail "rzo roles STDOUT, expected: '$expected' got: '$(cat $stdout)'"
+fi
+
+desc "rzo generate is expected to produce a Vagrantfile with one VM defined"
+expected=$(mktemp -t XXXXXX.vagrantfile.expected)
+stdout=$(mktemp -t XXXXXX.stdout)
+stderr=$(mktemp -t XXXXXX.stderr)
+cat <<VAGRANTFILE > $expected
+# https://github.com/ghoneycutt/rizzo
+Vagrant.configure(2) do |config|
+  # use 'vagrant plugin install vagrant-proxyconf' to install
+  if Vagrant.has_plugin?('vagrant-proxyconf')
+    config.proxy.http  = ENV['HTTP_PROXY']  if ENV['HTTP_PROXY']
+    config.proxy.https = ENV['HTTPS_PROXY'] if ENV['HTTPS_PROXY']
+  end
+
+  config.vm.define "puppetca", autostart: false do |cfg|
+    cfg.vm.box = nil
+    cfg.vm.box_url = nil
+    cfg.vm.box_download_checksum = nil
+    cfg.vm.box_download_checksum_type = nil
+    cfg.vm.provider :virtualbox do |vb|
+      vb.customize ['modifyvm', :id, '--memory', nil]
+    end
+    cfg.vm.hostname = nil
+    cfg.vm.network 'private_network',
+      ip: nil,
+      netmask: nil
+    cfg.vm.synced_folder "${PUPPETDATA}", "/repos/puppetdata",
+      owner: "root", group: "root"
+    cfg.vm.synced_folder "${HOME}/git/ghoneycutt-modules", "/repos/ghoneycutt",
+      owner: "root", group: "root"
+    config.vm.synced_folder "${HOME}/git/bootstrap",
+      nil,
+      owner: 'vagrant', group: 'root'
+    config.vm.provision 'shell', inline: "echo 'modulepath = ./modules:./puppetdata/modules:./ghoneycutt/modules' > /environment.conf"
+    config.vm.provision 'shell', inline: "/bin/bash / "
+  end
+end
+# -*- mode: ruby -*-
+# vim:ft=ruby
+VAGRANTFILE
+rzo generate 2> $stderr > $stdout
+actual=$(mktemp -t XXXXXX.vagrantfile.actual)
+tail -n+2 Vagrantfile > $actual
+if diff -U2 $expected $actual; then
+  cat Vagrantfile
+  pass "It does."
+else
+  fail "actual Vagrantfile does not match expected file"
+fi
+
+desc "END of functional testing"
+pass "Functional testing completed successfully."

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rzo
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Garrett Honeycutt
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-08-24 00:00:00.000000000 Z
+date: 2017-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -193,6 +193,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: deep_merge
   requirement: !ruby/object:Gem::Requirement
@@ -237,7 +251,9 @@ files:
 - lib/rzo.rb
 - lib/rzo/app.rb
 - lib/rzo/app/config.rb
+- lib/rzo/app/config_validation.rb
 - lib/rzo/app/generate.rb
+- lib/rzo/app/roles.rb
 - lib/rzo/app/subcommand.rb
 - lib/rzo/app/templates/Vagrantfile.erb
 - lib/rzo/logging.rb
@@ -245,6 +261,7 @@ files:
 - lib/rzo/trollop.rb
 - lib/rzo/version.rb
 - rzo.gemspec
+- scripts/functional_gem_behavior.sh
 homepage: https://github.com/ghoneycutt/rizzo
 licenses:
 - Apache-2.0