puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/tasks/benchmark.rake

@@ -0,0 +1,144 @@
+require 'benchmark'
+require 'tmpdir'
+require 'csv'
+
+namespace :benchmark do
+  def generate_scenario_tasks(location, name)
+    desc File.read(File.join(location, 'description'))
+    task name => "#{name}:run"
+    # Load a BenchmarkerTask to handle config of the benchmark
+    task_handler_file = File.expand_path(File.join(location, 'benchmarker_task.rb'))
+    if File.exist?(task_handler_file)
+      require task_handler_file
+      run_args = BenchmarkerTask.run_args
+    else
+      run_args = []
+    end
+
+    namespace name do
+      task :setup do
+        ENV['ITERATIONS'] ||= '10'
+        ENV['SIZE'] ||= '100'
+        ENV['TARGET'] ||= Dir.mktmpdir(name)
+        ENV['TARGET'] = File.expand_path(ENV['TARGET'])
+
+        mkdir_p(ENV['TARGET'])
+
+        require File.expand_path(File.join(location, 'benchmarker.rb'))
+
+        @benchmark = Benchmarker.new(ENV['TARGET'], ENV['SIZE'].to_i)
+      end
+
+      task :generate => :setup do
+        @benchmark.generate
+        @benchmark.setup
+      end
+
+      desc "Run the #{name} scenario."
+      task :run, [*run_args] =>  :generate do |_, args|
+        format = if RUBY_VERSION =~ /^1\.8/
+                   Benchmark::FMTSTR
+                 else
+                   Benchmark::FORMAT
+                 end
+        report = []
+        details = []
+        Benchmark.benchmark(Benchmark::CAPTION, 10, format, "> total:", "> avg:") do |b|
+          times = []
+          ENV['ITERATIONS'].to_i.times do |i|
+            start_time = Time.now.to_i
+            times << b.report("Run #{i + 1}") do
+              details << @benchmark.run(args)
+            end
+            report << [to_millis(start_time), to_millis(times.last.real), 200, true, name]
+          end
+
+          sum = times.inject(Benchmark::Tms.new, &:+)
+
+          [sum, sum / times.length]
+        end
+
+        write_csv("#{name}.samples",
+                  %w{timestamp elapsed responsecode success name},
+                  report)
+
+        # report details, if any were produced
+        if details[0].is_a?(Array) && details[0][0].is_a?(Benchmark::Tms)
+          # assume all entries are Tms if the first is
+          # turn each into a hash of label => tms (since labels are lost when doing arithmetic on Tms)
+          hashed = details.reduce([]) do |memo, measures|
+            memo << measures.reduce({}) {|memo2, measure| memo2[measure.label] = measure; memo2}
+            memo
+          end
+          # sum across all hashes
+          result = {}
+
+          hashed_totals = hashed.reduce {|memo, h| memo.merge(h) {|k, old, new| old + new }}
+          # average the totals
+          hashed_totals.keys.each {|k| hashed_totals[k] /= details.length }
+          min_width = 14
+          max_width = (hashed_totals.keys.map(&:length) << min_width).max
+          puts "\n"
+          puts sprintf("%2$*1$s %3$s", -max_width, 'Details (avg)', "      user     system      total        real")
+          puts "-" * (46 + max_width)
+          hashed_totals.sort.each {|k,v| puts sprintf("%2$*1$s %3$s", -max_width, k, v.format) }
+        end
+      end
+
+      desc "Profile a single run of the #{name} scenario."
+      task :profile, [:warm_up_runs, *run_args] => :generate do |_, args|
+        warm_up_runs = (args[:warm_up_runs] || '0').to_i
+        warm_up_runs.times do
+          @benchmark.run(args)
+        end
+
+        require 'ruby-prof'
+
+        result = RubyProf.profile do
+          @benchmark.run(args)
+        end
+
+        printer = RubyProf::CallTreePrinter.new(result)
+        File.open(File.join("callgrind.#{name}.#{Time.now.to_i}.trace"), "w") do |f|
+          printer.print(f)
+        end
+      end
+
+      def to_millis(seconds)
+        (seconds * 1000).round
+      end
+
+      def write_csv(file, header, data)
+        CSV.open(file, 'w') do |csv|
+          csv << header
+          data.each do |line|
+            csv << line
+          end
+        end
+      end
+    end
+  end
+
+  scenarios = []
+  Dir.glob('benchmarks/*') do |location|
+    name = File.basename(location)
+    scenarios << name
+    generate_scenario_tasks(location, File.basename(location))
+  end
+
+  namespace :all do
+    desc "Profile all of the scenarios. (#{scenarios.join(', ')})"
+    task :profile do
+      scenarios.each do |name|
+        sh "rake benchmark:#{name}:profile"
+      end
+    end
+
+    desc "Run all of the scenarios. (#{scenarios.join(', ')})"
+    task :run do
+      scenarios.each do |name|
+        sh "rake benchmark:#{name}:run"
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/tasks/ci.rake

@@ -0,0 +1,29 @@
+require 'yaml'
+require 'time'
+
+namespace "ci" do
+  task :spec do
+    ENV["LOG_SPEC_ORDER"] = "true"
+    sh %{rspec -r yarjuf -f JUnit -o result.xml -fp spec}
+  end
+
+  desc "Tar up the acceptance/ directory so that package test runs have tests to run against."
+  task :acceptance_artifacts => :tag_creator do
+    Dir.chdir("acceptance") do
+      rm_f "acceptance-artifacts.tar.gz"
+      sh "tar -czv --exclude .bundle -f acceptance-artifacts.tar.gz *"
+    end
+  end
+
+  task :tag_creator do
+    Dir.chdir("acceptance") do
+      File.open('creator.txt', 'w') do |fh|
+        YAML.dump({
+          'creator_id' => ENV['CREATOR'] || ENV['BUILD_URL'] || 'unknown',
+          'created_on' => Time.now.iso8601,
+          'commit' => (`git log -1 --oneline` rescue "unknown: #{$!}")
+        }, fh)
+      end
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/tasks/manpages.rake

@@ -0,0 +1,84 @@
+# require 'fileutils'
+
+desc "Build Puppet manpages"
+task :gen_manpages do
+  require 'puppet/face'
+  require 'fileutils'
+
+  # TODO: this line is unfortunate.  In an ideal world, faces would serve
+  #  as a clear, well-defined entry-point into the code and could be
+  #  responsible for state management all on their own; this really should
+  #  not be necessary.  When we can, we should get rid of it.
+  #  --cprice 2012-05-16
+  Puppet.initialize_settings()
+
+  helpface = Puppet::Face[:help, '0.0.1']
+  manface  = Puppet::Face[:man, '0.0.1']
+
+  # TODO: This line is terrible.  The reason we need this here is because we
+  #  handle state initialization differently when we run via command line
+  #  (application.rb) than we do when we try to use Faces as library code.
+  #  This is bad, we need to come up with an official stance on what our
+  #  API is and what the entry points, so that we can make sure that
+  #  state initialization is consistent.  See:
+  # http://projects.puppetlabs.com/issues/14441
+  Puppet::Util::Instrumentation.init()
+
+  sbins = Dir.glob(%w{sbin/*})
+  bins  = Dir.glob(%w{bin/*})
+  non_face_applications = helpface.legacy_applications
+  faces = Puppet::Face.faces
+  ronn_args = '--manual="Puppet manual" --organization="Puppet Labs, LLC" -r'
+
+  # Locate ronn
+  ronn = %x{which ronn}.chomp
+  unless File.executable?(ronn) then fail("Ronn does not appear to be installed.") end
+
+#   def write_manpage(text, filename)
+#     IO.popen("#{ronn} #{ronn_args} -r > #{filename}") do |fh| fh.write text end
+#   end
+
+  # Create puppet.conf.5 man page
+#   IO.popen("#{ronn} #{ronn_args} > ./man/man5/puppet.conf.5", 'w') do |fh|
+#     fh.write %x{RUBYLIB=./lib:$RUBYLIB bin/puppetdoc --reference configuration}
+#   end
+  %x{RUBYLIB=./lib:$RUBYLIB bin/puppet doc --reference configuration > ./man/man5/puppetconf.5.ronn}
+  %x{#{ronn} #{ronn_args} ./man/man5/puppetconf.5.ronn}
+  FileUtils.mv("./man/man5/puppetconf.5", "./man/man5/puppet.conf.5")
+  FileUtils.rm("./man/man5/puppetconf.5.ronn")
+
+  # Create LEGACY binary man pages (i.e. delete me for 2.8.0)
+  binary = bins + sbins
+  binary.each do |bin|
+    b = bin.gsub( /^s?bin\//, "")
+    %x{RUBYLIB=./lib:$RUBYLIB #{bin} --help > ./man/man8/#{b}.8.ronn}
+    %x{#{ronn} #{ronn_args} ./man/man8/#{b}.8.ronn}
+    FileUtils.rm("./man/man8/#{b}.8.ronn")
+  end
+
+  # Create regular non-face man pages
+  non_face_applications.each do |app|
+    %x{RUBYLIB=./lib:$RUBYLIB bin/puppet #{app} --help > ./man/man8/puppet-#{app}.8.ronn}
+    %x{#{ronn} #{ronn_args} ./man/man8/puppet-#{app}.8.ronn}
+    FileUtils.rm("./man/man8/puppet-#{app}.8.ronn")
+  end
+
+  # Create face man pages
+  faces.each do |face|
+    File.open("./man/man8/puppet-#{face}.8.ronn", 'w') do |fh|
+      fh.write manface.man("#{face}")
+    end
+
+    %x{#{ronn} #{ronn_args} ./man/man8/puppet-#{face}.8.ronn}
+    FileUtils.rm("./man/man8/puppet-#{face}.8.ronn")
+  end
+
+  # Vile hack: create puppet resource man page
+  # Currently, the useless resource face wins against puppet resource in puppet
+  # man. (And actually, it even gets removed from the list of legacy
+  # applications.) So we overwrite it with the correct man page at the end.
+  %x{RUBYLIB=./lib:$RUBYLIB bin/puppet resource --help > ./man/man8/puppet-resource.8.ronn}
+  %x{#{ronn} #{ronn_args} ./man/man8/puppet-resource.8.ronn}
+  FileUtils.rm("./man/man8/puppet-resource.8.ronn")
+
+end

data/vendor/gems/puppet-3.7.3/tasks/memwalk.rake

@@ -0,0 +1,195 @@
+# Walks the memory dumped into heap.json, and produces a graph of the memory dumped in diff.json
+# If a single argument (a hex address to one object) is given, the graph is limited to this object and what references it
+# The heap dumps should be in the format produced by Ruby ObjectSpace in Ruby version 2.1.0 or later.
+#
+# The command produces a .dot file that can be rendered with graphwiz dot into SVG. If a memwalk is performed for all
+# objects in the diff.json, the output file name is memwalk.dot. If it is produced for a single address, the name of the
+# output file is memwalk-<address>.dot
+#
+# The dot file can be rendered with something like: dot -Tsvg -omemwalk.svg memwalk.dot
+#
+desc "Process a diff.json of object ids, and a heap.json of a Ruby 2.1.0 ObjectSpace dump and produce a graph"
+task :memwalk, [:id] do |t, args|
+  puts "Memwalk"
+  puts "Computing for #{args[:id] ? args[:id] : 'all'}"
+  @single_id = args[:id] ? args[:id].to_i(16) : nil
+
+  require 'json'
+  #require 'debug'
+
+  TYPE = "type".freeze
+  ROOT = "root".freeze
+  ROOT_UC = "ROOT".freeze
+  ADDR = "address".freeze
+  NODE = "NODE".freeze
+  STRING = "STRING".freeze
+  DATA = "DATA".freeze
+  HASH = "HASH".freeze
+  ARRAY = "ARRAY".freeze
+  OBJECT = "OBJECT".freeze
+  CLASS = "CLASS".freeze
+
+  allocations = {}
+  # An array of integer addresses of the objects to trace bindings for
+  diff_index = {}
+  puts "Reading data"
+  begin
+    puts "Reading diff"
+    lines = 0;
+    File.readlines("diff.json").each do | line |
+      lines += 1
+      diff = JSON.parse(line)
+      case diff[ TYPE ]
+      when STRING, DATA, HASH, ARRAY
+        # skip the strings
+      else
+        diff_index[ diff[ ADDR ].to_i(16) ] = diff
+      end
+    end
+    puts "Read #{lines} number of diffs"
+  rescue => e
+    raise "ERROR READING DIFF at line #{lines} #{e.message[0, 200]}"
+  end
+
+  begin
+    puts "Reading heap"
+    lines = 0
+    allocation = nil
+    File.readlines("heap.json").each do | line |
+      lines += 1
+      allocation = JSON.parse(line)
+      case allocation[ TYPE ]
+      when ROOT_UC
+        # Graph for single id must include roots, as it may be a root that holds on to the reference
+        # a global variable, thread, etc.
+        #
+        if @single_id
+          allocations[ allocation[ ROOT ] ] = allocation
+        end
+      when NODE
+        # skip the NODE objects - they represent the loaded ruby code
+      when STRING
+        # skip all strings - they are everywhere
+      else
+        allocations[ allocation[ ADDR ].to_i(16) ] = allocation
+      end
+    end
+    puts "Read #{lines} number of entries"
+  rescue => e
+    require 'debug'
+    puts "ERROR READING HEAP #{e.message[0, 200]}"
+    raise e
+  end
+  @heap = allocations
+
+  puts "Building reference index"
+  # References is an index from a referenced object to an array with addresses to the objects that references it
+  @references = Hash.new { |h, k| h[k] = [] }
+  REFERENCES = "references".freeze
+  allocations.each do |k,v|
+    refs = v[ REFERENCES ]
+    if refs.is_a?(Array)
+      refs.each {|addr| @references[ addr.to_i(16) ] << k }
+    end
+  end
+
+  @printed = Set.new()
+
+  def print_object(addr, entry)
+    # only print each node once
+    return unless @printed.add?(addr)
+    begin
+    if addr.is_a?(String)
+      @output.write( "x#{node_name(addr)} [label=\"#{node_label(addr, entry)}\\n#{addr}\"];\n")
+    else
+      @output.write( "x#{node_name(addr)} [label=\"#{node_label(addr, entry)}\\n#{addr.to_s(16)}\"];\n")
+    end
+    rescue => e
+      require 'debug'
+      raise e
+    end
+  end
+
+  def node_label(addr, entry)
+    if entry[ TYPE ] == OBJECT
+      class_ref = entry[ "class" ].to_i(16)
+      @heap[ class_ref ][ "name" ]
+    elsif entry[ TYPE ] == CLASS
+      "CLASS #{entry[ "name"]}"
+    else
+      entry[TYPE]
+    end
+  end
+
+  def node_name(addr)
+    return addr if addr.is_a? String
+    addr.to_s(16)
+  end
+
+  def print_edge(from_addr, to_addr)
+    @output.write("x#{node_name(from_addr)}->x#{node_name(to_addr)};\n")
+  end
+
+  def closure_and_edges(diff)
+    edges = Set.new()
+    walked = Set.new()
+    puts "Number of diffs referenced = #{diff.count {|k,_| @references[k].is_a?(Array) && @references[k].size() > 0 }}"
+    diff.each {|k,_| walk(k, edges, walked) }
+    edges.each {|e| print_edge(*e) }
+  end
+
+  def walk(addr, edges, walked)
+    if !@heap[ addr ].nil?
+      print_object(addr, @heap[addr])
+
+      @references [ addr ].each do |r|
+        walk_to_object(addr, r, edges, walked)
+      end
+    end
+  end
+
+  def walk_to_object(to_addr, cursor, edges, walked)
+    return unless walked
+    # if walked to an object, or everything if a single_id is the target
+    if @heap[ cursor ][ TYPE ] == OBJECT || (@single_id && @heap[ cursor ][ TYPE ] == ROOT_UC || @heap[ cursor ][ TYPE ] == CLASS )
+      # and the edge is unique
+      if edges.add?( [ cursor, to_addr ] )
+        # then we may not have visited objects this objects is being referred from
+        print_object(cursor, @heap[ cursor ])
+        # Do not follow what binds a class
+        if @heap[ cursor ][ TYPE ] != CLASS
+          @references[ cursor ].each do |r|
+            walk_to_object(cursor, r, edges, walked.add?(r))
+            walked.delete(r)
+          end
+        end
+      end
+    else
+      # continue search until Object
+      @references[cursor].each do |r|
+        walk_to_object(to_addr, r, edges, walked.add?(r))
+      end
+    end
+  end
+
+  def single_closure_and_edges(the_target)
+    edges = Set.new()
+    walked = Set.new()
+    walk(the_target, edges, walked)
+    edges.each {|e| print_edge(*e) }
+  end
+
+  puts "creating graph"
+  if @single_id
+    @output = File.open("memwalk-#{@single_id.to_s(16)}.dot", "w")
+    @output.write("digraph root {\n")
+    single_closure_and_edges(@single_id)
+  else
+    @output = File.open("memwalk.dot", "w")
+    @output.write("digraph root {\n")
+    closure_and_edges(diff_index)
+  end
+  @output.write("}\n")
+  @output.close
+  puts "done"
+end