puppetbox 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ad288284d9a66b09a591260219ab1c3ad31c9562
-  data.tar.gz: 810ebf10d5f24b32eb3ba98d01b45db454805bb8
+  metadata.gz: f0b4270e3681f985ebb627e7126987337345963f
+  data.tar.gz: aa5f16dd84a2f10e25abe4e23c73a03082316fb6
 SHA512:
-  metadata.gz: 35b2473e845e2aa9ad67d4012434a81ecaff79266d1a11823e29333eab3cb7cb78ffb8322f9e112b523967b142f7a19a29608c0e52d070fa8f5bb64558695745
-  data.tar.gz: 84b43a030638aad37d350bd7179882e1860f9bcd59ca324380ad7d45d2652cdb0df46276fd1384c77436bb90cf5a24aa43f69c8c6222c1e091ff8602a9c80968
+  metadata.gz: af4ca9d3108b2d81150d53ea25473f4a5ddb722e14a76814f37e433c698c073919d3fbcaf228044740040651342de8fcc7146a912dafa7e5387864c61d29df1e
+  data.tar.gz: fa61ab2481c0fb6d49681168eb44b9917c5320f244b0d130123a6a140d0e1916c795bd986f6e1e8fbc5cf23179b8f7f4ddbb97dfe8c785f7e5e5b1f2f72477b8

data/Gemfile

@@ -2,5 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in puppetbox.gemspec
 gem 'derelict', :git => 'https://github.com/GeoffWilliams/derelict', :ref => 'preserve_real_status'
+#gem 'vagrantomatic', :path => '/home/geoff/github/vagrantomatic'
 
 gemspec

data/lib/puppetbox/driver/vagrant.rb

@@ -7,20 +7,47 @@ module PuppetBox
   module Driver
     class Vagrant
       # fixme - seems abandoned, might need to make my own :(
-      DEFAULT_VAGRANT_BOX = "puppetlabs/centos-7.2-64-puppet"
+      # DEFAULT_VAGRANT_BOX = "puppetlabs/centos-7.2-64-puppet"
       PUPPET_CODE_MOUNT   = "/etc/puppetlabs/code/environments/production"
 
-      def initialize(name, codedir, keep_vm:true, working_dir:nil, config:{'box'=> DEFAULT_VAGRANT_BOX}, logger: nil)
+      def node_name
+        @name
+      end
+
+#      def initialize(name, codedir, keep_vm:true, working_dir:nil, config:{'box'=> DEFAULT_VAGRANT_BOX}, logger: nil)
+      def initialize(name, codedir, config, keep_vm:false, working_dir:nil, logger: nil)
+
         @name         = name
         @keep_vm      = keep_vm
         @working_dir  = working_dir || File.join(Dir.home, '.puppetbox')
         @config       = config
-        @result       = PuppetBox::Result.new
-        @logger       = PuppetBox::Logger.new(logger).logger
+        @result       = Result.new
+        @logger       = Logger.new(logger).logger
+
+        if ! @config.has_key?("box")
+          raise "Node #{node_name} must specify box"
+        end
 
         # Add the code dir to the config has so that it will automatically become
         # a shared folder when the VM boots
-        @config["folders"] = "#{codedir}:#{PUPPET_CODE_MOUNT}"
+
+        # can't use dig() might not be ruby 2.3
+        if @config.has_key?("folders")
+          @config["folders"] = Array(@config["folders"])
+
+          # all paths must be fully qualified.  If we were asked to do a relative path, change
+          # it to the current directory since that's probably what the user wanted.  Not right?
+          # user supply correct path!
+          @config["folders"] = @config["folders"].map { |folder|
+            if ! folder.start_with? '/'
+              folder = "#{Dir.pwd}/#{folder}"
+            end
+            folder
+          }
+        else
+          @config["folders"] = []
+        end
+        @config["folders"] << "#{codedir}:#{PUPPET_CODE_MOUNT}"
         @logger.debug "instance #{name} initialised"
       end
 
@@ -38,15 +65,19 @@ module PuppetBox
       #   4: The run succeeded, and some resources failed.
       #   6: The run succeeded, and included both changes and failures.
       def run_puppet(puppet_class)
-        run_hash = @vm.run("sudo -i puppet apply --detailed-exitcodes -e 'include #{puppet_class}'")
-        @result.report(run_hash[:status], run_hash[:messages])
+        status_code, messages = @vm.run(
+          "sudo -i puppet apply --detailed-exitcodes -e 'include #{puppet_class}'"
+        )
+        @result.save(status_code, messages)
+        @result.passed?
       end
 
       # Open a connection to a box (eg start a vm, ssh to a host etc)
       def open()
         # make sure working dir exists...
         FileUtils.mkdir_p(@working_dir)
-        vom = Vagrantomatic::Vagrantomatic.new(vagrant_vm_dir: @working_dir)
+
+        vom = Vagrantomatic::Vagrantomatic.new(vagrant_vm_dir: @working_dir, logger: @logger)
 
         @logger.debug("reading instance metadata for #{@name}")
         @vm = vom.instance(@name)
@@ -56,26 +87,42 @@ module PuppetBox
         @vm.config=(@config)
         @vm.save
         @logger.debug("Instance saved and ready for starting")
-        @vm.start
+        started = @vm.start
       end
 
       # Close a connection to a box (eg stop a vm, probaly doesn't need to do
       # anything on SSH...)
       def close()
         if ! @keep_vm
+          @logger.info("Closing #{@node_name}")
           @vm.purge
         end
       end
 
+      def reset()
+        @vm.reset
+      end
+
       # Test that a VM is operational and able to run puppet
       def self_test()
-        @vm.run("sudo -i puppet --version")[:status] == 0
+        status_code, messages = @vm.run("sudo -i puppet --version")
+        self_test = (status_code == 0)
+        if self_test
+          @logger.info("Running under Puppet version: #{messages[0].strip}")
+        else
+          @logger.error("Error #{status_code} running puppet: #{messages}")
+        end
+        self_test
       end
 
       def run_puppet_x2(puppet_class)
-        # fixme - link module
-        run_puppet(puppet_class)
-        run_puppet(puppet_class)
+        # if you need to link a module into puppet's modulepath either do it
+        # before running puppet (yet to be supported) or use the @config hash
+        # for vagrant to mount what you need as a shared folder
+        if run_puppet(puppet_class)
+          # Only do the second run if the first run passes
+          run_puppet(puppet_class)
+        end
       end
 
     end

data/lib/puppetbox/logger.rb

@@ -10,7 +10,11 @@ module PuppetBox
       else
         @logger = ::Logger.new(STDOUT)
         @logger.formatter = proc do |severity, datetime, progname, msg|
-          "#{severity}: #{msg}"
+          # depending on the source, some messages come in with new lines and
+          # some do not so strip off any exiting and then add our own for
+          # consistency
+          msg = msg.strip
+          "#{severity}: #{msg}\n"
         end
       end
     end

data/lib/puppetbox/nodeset.rb

@@ -0,0 +1,81 @@
+require 'yaml'
+
+module PuppetBox
+  class NodeSet
+    NODESET_FILE = "spec/acceptance/nodesets/puppetbox.yaml"
+    VERSION_KEY = "puppetbox_nodeset"
+    UNDERSTANDS_VERSION = [1]
+    REQUIRED_KEYS = ["config", "driver"]
+    NODE_ELEMENT = "nodes"
+
+    def initialize(nodeset_file=nil)
+      @nodeset_file = nodeset_file || NODESET_FILE
+
+      # parse the yaml file and simplify to human readable errors
+      begin
+        @nodeset = YAML.load(IO.read(@nodeset_file))
+      rescue Errno::ENOENT
+        raise "File not found: #{@nodeset_file}"
+      rescue Psych::SyntaxError
+        raise "Syntax error reading #{@nodeset_file}"
+      end
+      if @nodeset.has_key?(VERSION_KEY)
+        if UNDERSTANDS_VERSION.include?(@nodeset[VERSION_KEY])
+          if @nodeset.has_key?(NODE_ELEMENT)
+            hosts = @nodeset[NODE_ELEMENT]
+            hosts.each { |node_name, data|
+              # check each node has required keys
+              REQUIRED_KEYS.each { |required_key|
+                if ! data.has_key?(required_key)
+                  raise "Nodeset file #{@nodeset_file} missing required key #{required_key} for node #{node_name}"
+                end
+              }
+            }
+          else
+            raise "Nodeset file #{@nodeset_file} missing root element `nodes`"
+          end
+        else
+          raise "Nodeset file format is #{@nodeset[VERSION_KEY]} but PuppetBox only supports versions #{UNDERSTANDS_VERSION}"
+        end
+      else
+        raise "Nodeset file #{@nodeset_file} does not contain #{VERSION_KEY} - check syntax"
+      end
+
+    end
+
+    def has_node?(node_name)
+      @nodeset[NODE_ELEMENT].has_key?(node_name)
+    end
+
+    def get_node(node_name)
+      if has_node?(node_name)
+        @nodeset[NODE_ELEMENT][node_name]
+      else
+        raise "Node #{node_name} is not defined in nodset file: #{@nodeset_file}"
+      end
+    end
+
+    #
+    #
+    #   if nodeset["hosts"][node.name].has_key?('config') and nodeset_yaml["HOSTS"][node.name].has_key?('driver')
+    #     test.classes.each { |puppet_class|
+    #       logger.info "Acceptance testing #{node.name} #{puppet_class.name}"
+    #       summary[node.name][puppet_class.name] = pb.provision_and_test(
+    #         nodeset_yaml["HOSTS"][node.name]["driver"],
+    #         node.name,
+    #         puppet_class.name,
+    #         nodeset_yaml["HOSTS"][node.name]['config'],
+    #         @repo,
+    #       )
+    #
+    #       overall &= ! summary[node.name][puppet_class.name]
+    #     }
+    #   else
+    #     message = "onceover-nodes.yaml missing `config` or `driver` element for #{node.name} (tests skipped)"
+    #     summary[node.name] = message
+    #     overall = false
+    #   end
+    # end
+
+  end
+end

data/lib/puppetbox/puppetbox.rb

@@ -0,0 +1,185 @@
+require "puppetbox/result_set"
+require "puppetbox/logger"
+require "puppetbox/nodeset"
+require "puppetbox/driver/vagrant"
+
+module PuppetBox
+  class PuppetBox
+
+    def initialize(logger:nil, nodeset_file: nil)
+      # The results of all tests on all driver instances
+      @result_set = ResultSet.new
+
+      # A complete test suite of tests to run - includes driver instance, host
+      # and classes
+      @testsuite = {}
+      @logger = Logger.new(logger).logger
+
+      # the nodesets file contains a YAML representation of a hash containing
+      # the node name, config options, driver to use etc - so external tools can
+      # talk to use about nodes of particular name and puppetbox will sort out
+      # the how and why of what this exactly should involve
+      @nodeset = NodeSet.new(nodeset_file)
+    end
+
+
+    # Enqueue a test into the `testsuite` for
+    def enqueue_test(node_name, run_from, puppet_class)
+      instantiate_driver(node_name, run_from)
+      @testsuite[node_name]["classes"] << puppet_class
+      #  get_driver_instance(driver_name, host)
+      # node_name
+      # puppet_class.name,
+      # nodeset_yaml["HOSTS"][node.name]['config'],
+      # @repo,
+    end
+
+    def run_testsuite
+      @testsuite.each { |id, tests|
+        run_puppet(tests["instance"], tests["classes"], logger:@logger, reset_after_run:true)
+      }
+    end
+
+    def instantiate_driver(node_name, run_from)
+      node    = @nodeset.get_node(node_name)
+      config  = node["config"]
+      driver  = node["driver"]
+      if @testsuite.has_key?(node_name)
+        @logger.debug("#{node_name} already registered")
+      else
+        @logger.debug("Creating new driver instance for #{node_name}")
+
+        # for now just support the vagrant driver
+        case driver
+        when "vagrant"
+
+          # For the moment, just use the checked out production environment inside
+          # onceover's working directory.  The full path resolves to something like
+          # .onceover/etc/puppetlabs/code/environments/production -- in the
+          # directory your running onceover from
+          #
+          # we pass in our pre-configured logger instance for separation and to
+          # reduce the amount of log output.  We only print puppet apply output for
+          # failed runs, however, if user runs in onceover's --debug mode, then we
+          # will print the customary ton of messages, including those from vagrant
+          # itself.
+          puts config["box"]
+          di = Driver::Vagrant.new(
+            node_name,
+            run_from,
+            config,
+            # "#{repo.tempdir}/etc/puppetlabs/code/environments/production",
+            logger: @logger,
+
+          )
+        else
+          raise "PuppetBox only supports driver: 'vagrant' at the moment (requested: #{driver})"
+        end
+
+        @testsuite[node_name] = {
+          "instance" => di,
+          "classes"  => [],
+        }
+      end
+
+      # di
+      # result = ::PuppetBox.run_puppet(di, puppet_class)
+
+      # indent = "  "
+      # if result.passed
+      #   logger.info("#{indent}#{host}:#{puppet_class} --> PASSED")
+      # else
+      #   logger.error("#{indent}#{host}:#{puppet_class} --> FAILED")
+      #   # since we stop running on failure, the error messages will be in the
+      #   # last element of the result.messages array (tada!)
+      #   messages = result.messages
+      #   messages[-1].each { |line|
+      #     # puts "XXXXXXX #{line}"
+      #     logger.error "#{indent}#{host} - #{line}"
+      #   }
+      #   #   puts "size of result messages #{result.messages.size}"
+      #   #   puts "size of result messages #{result.messages[0].size}"
+      #   #   run.each { |message_arr|
+      #   #     puts message_arr
+      #   #     #message_arr.each { |line|
+      #   #   #    puts line
+      #   #   #  }
+      #   #     # require 'pry'
+      #   #     # binding.pry
+      #   #     #puts "messages size"
+      #   #     #puts messages.size
+      #   #   #  messages.each { |message|
+      #   #       # messages from the puppet run are avaiable in a nested array of run
+      #   #       # and then lines so lets print each one out indended from the host so
+      #   #       # we can see what's what
+      #   #   #    logger.error("#{host}       #{message}")
+      #   #   #  }
+      #   #   }
+      #   # }
+      # end
+      # result.passed
+    end
+
+
+    # Print all results to STDOUT
+    def print_results
+      # print the report summary
+      indent = "  "
+      puts "\n\n\nSummary\n======="
+      summary.each { |node, class_results|
+        puts node
+        if class_results.class == String
+          puts "#{indent}#{class_results}"
+        else
+          class_results.each { |puppet_class, passed|
+            line = "#{indent}#{puppet_class}: #{passed ? "OK": "FAILED"}"
+            if passed
+              puts line.green
+            else
+              puts line.red
+            end
+          }
+        end
+      }
+
+      puts "Overall acceptance testing result #{overall}"
+    end
+
+
+
+    # Run puppet using `driver_instance` to execute
+    def run_puppet(driver_instance, puppet_classes, logger:nil, reset_after_run:true)
+      # use supplied logger in preference to the default puppetbox logger instance
+      logger = logger || @logger
+      logger.debug("#{driver_instance.node_name} running test for #{puppet_classes}")
+      puppet_classes = Array(puppet_classes)
+      results = ResultSet.new
+      if driver_instance.open
+        logger.debug("#{driver_instance.node_name} started")
+        if driver_instance.self_test
+          logger.debug("#{driver_instance.node_name} self_test OK, running puppet")
+          puppet_classes.each{ |puppet_class|
+            if results.class_size(driver_instance.node_name) > 0 and reset_after_run
+              # purge and reboot the vm - this will save approximately 1 second
+              # per class on the self-test which we now know will succeed
+              driver_instance.reset
+            end
+            driver_instance.run_puppet_x2(puppet_class)
+            results.save(driver_instance.node_name, puppet_class, driver_instance.result)
+          }
+          logger.debug("#{driver_instance.node_name} test completed, closing instance")
+          driver_instance.close
+        else
+          driver_instance.close
+          raise "#{driver_instance.node_name} self test failed, unable to continue"
+        end
+      else
+        driver_instance.close
+        raise "#{driver_instance.node_name} failed to start, unable to continue"
+      end
+
+      results
+    end
+
+  end
+end

data/lib/puppetbox/report.rb

@@ -0,0 +1,27 @@
+module PuppetBox
+  module Report
+    def self.printstuff(stream=$STDOUT)
+      # print the report summary
+      indent = "  "
+      stream.puts "\n\n\nSummary\n======="
+      summary.each { |node, class_results|
+        puts node
+        if class_results.class == String
+          stream.puts "#{indent}#{class_results}"
+        else
+          class_results.each { |puppet_class, passed|
+            line = "#{indent}#{puppet_class}: #{passed ? "OK": "FAILED"}"
+            if passed
+              stream.puts line.green
+            else
+              stream.puts line.red
+            end
+          }
+        end
+      }
+
+      stream.puts "OVERALL STATUS #{overall}"
+      overall
+    end
+  end
+end

data/lib/puppetbox/result.rb

@@ -23,7 +23,7 @@ module PuppetBox
     # 2: The run succeeded, and some resources were changed.
     # 4: The run succeeded, and some resources failed.
     # 6: The run succeeded, and included both changes and failures.
-    def report(status_code, messages)
+    def save(status_code, messages)
       status = PS_ERROR
       if @report.empty?
         # first run
@@ -40,19 +40,37 @@ module PuppetBox
       @report.push({:status => status, :messages => messages})
     end
 
-    def passed
-      passed = true
+    # Test whether this set of results passed or not
+    # @return true if tests were executed and passed, nil if no tests were
+    #   executed, false if tests were exectued and there were failures
+    def passed?
+      passed = nil
       @report.each { |r|
-        passed &= r[:status] == PS_OK
+        puts "...REPORT"
+        if passed == nil
+          passed = (r[:status] == PS_OK)
+        else
+          passed &= (r[:status] == PS_OK)
+        end
       }
 
       passed
     end
 
+    def report_count
+      @report.size
+    end
+
+    def report_message_count(report)
+      @report[report].messages.size
+    end
+
+
+
     def messages(run=-1)
       messages = []
       if run < 0
-        # all runs concatenated
+        # all NESTED in order of report
         @report.each { |r|
           messages << r[:messages]
         }

data/lib/puppetbox/result_set.rb

@@ -0,0 +1,67 @@
+module PuppetBox
+  class ResultSet
+    def initialize
+      @results = {}
+    end
+
+    def save(node_name, class_name, result)
+      # check we didn't make a stupid programming error
+      if result.class != ::PuppetBox::Result
+        raise "result to save must be instance of PuppetBox::Result"
+      end
+
+      # if this is the first set of results for this node then we need to make
+      # a hash to contain the results
+      if ! @results.has_key?(node_name)
+        @results[node_name] = {}
+      end
+
+      # We can only run the same class on each node once, if we attempt to do so
+      # again,
+      if @results[node_name].has_key?(class_name)
+        raise "Duplicate results for class #{class_name} detected, You can " \
+        "only test the same class once per node.  Check your test configuration"
+      else
+        @results[node_name][class_name] = result
+      end
+    end
+
+    def passed?
+      @results.map { |node_name, class_results_hash|
+        class_results_hash.map { |class_name, class_results|
+          class_results.passed?
+        }.all?
+      }.all?
+    end
+
+    def data
+      @results
+    end
+
+    # The count of how many nodes we presently have saved
+    def node_size
+      @results.size
+    end
+
+    # The count of how many classes we presently have saved for a given node
+    def class_size(node_name)
+      if @results.has_key?(node_name)
+        size = @results[node_name].size
+      else
+        size = 0
+      end
+
+      size
+    end
+
+    # The count of how many tests this result_set contains for all nodes and
+    # classes
+    def test_size
+      @results.map {|node_name, classes|
+        classes.size
+      }.reduce(:+)
+    end
+
+
+  end
+end

data/lib/puppetbox/version.rb

@@ -1,3 +1,3 @@
 module PuppetBox
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/puppetbox.rb

@@ -2,14 +2,5 @@ require "puppetbox/version"
 
 module PuppetBox
 
-  def self.run_puppet(driver_instance, puppet_class)
-    if driver_instance.open
-      if driver_instance.self_test
-        driver_instance.run_puppet_x2(puppet_class)
-        driver_instance.close
-      end
-    end
-    driver_instance.result
-  end
 
 end

data/puppetbox.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
 
-  spec.add_dependency "vagrantomatic"
+  spec.add_dependency "vagrantomatic", "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppetbox
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Geoff Williams
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-11 00:00:00.000000000 Z
+date: 2017-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -56,16 +56,16 @@ dependencies:
   name: vagrantomatic
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.1
 description: 
 email:
 - geoff@geoffwilliams.me.uk
@@ -86,7 +86,11 @@ files:
 - lib/puppetbox/driver.rb
 - lib/puppetbox/driver/vagrant.rb
 - lib/puppetbox/logger.rb
+- lib/puppetbox/nodeset.rb
+- lib/puppetbox/puppetbox.rb
+- lib/puppetbox/report.rb
 - lib/puppetbox/result.rb
+- lib/puppetbox/result_set.rb
 - lib/puppetbox/version.rb
 - puppetbox.gemspec
 homepage: https://github.com/GeoffWilliams/puppetbox