puppet-debugger 0.4.0

data/lib/puppet-debugger/support/input_responders.rb

@@ -0,0 +1,136 @@
+module PuppetDebugger
+  module Support
+    module InputResponders
+
+      def static_responder_list
+        ["exit", "functions", "classification","vars", 'facterdb_filter', "krt", "facts",
+         "resources", "classes", "whereami", "play","reset", "help"
+        ]
+      end
+
+      # @source_file and @source_line_num instance variables must be set for this
+      # method to show the surrounding code
+      # @return [String] - string output of the code surrounded by the breakpoint or nil if file or line_num do not exist
+      def whereami(command=nil, args=nil)
+        file=@source_file
+        line_num=@source_line_num
+        if file and line_num
+          if file == :code
+            source_code = Puppet[:code]
+            code = DebuggerCode.from_string(source_code, :puppet)
+          else
+            code = DebuggerCode.from_file(file, :puppet)
+          end
+          return code.with_marker(line_num).around(line_num, 5).with_line_numbers.with_indentation(5).to_s
+        end
+      end
+
+      # displays the facterdb filter
+      # @param [Array] - args is not used
+      def facterdb_filter(args=[])
+        dynamic_facterdb_filter.ai
+      end
+
+      def help(args=[])
+        PuppetDebugger::Cli.print_repl_desc
+      end
+
+      def handle_set(input)
+        output = ''
+        args = input.split(' ')
+        args.shift # throw away the set
+        case args.shift
+        when /node/
+          if name = args.shift
+            output = "Resetting to use node #{name}"
+            reset
+            set_remote_node_name(name)
+          else
+            out_buffer.puts "Must supply a valid node name"
+          end
+        when /loglevel/
+          if level = args.shift
+            @log_level = level
+            set_log_level(level)
+            output = "loglevel #{Puppet::Util::Log.level} is set"
+          end
+        end
+        output
+      end
+
+      def facts(args=[])
+        variables = node.facts.values
+        variables.ai({:sort_keys => true, :indent => -1})
+      end
+
+      def functions(args=[])
+        filter = args.first || ''
+        function_map.keys.sort.grep(/^#{Regexp.escape(filter)}/)
+      end
+
+      def vars(args=[])
+        # remove duplicate variables that are also in the facts hash
+        variables = scope.to_hash.delete_if {| key, value | node.facts.values.key?(key) }
+        variables['facts'] = 'removed by the puppet-debugger' if variables.key?('facts')
+        output = "Facts were removed for easier viewing".ai + "\n"
+        output += variables.ai({:sort_keys => true, :indent => -1})
+      end
+
+      def environment(args=[])
+        "Puppet Environment: #{puppet_env_name}"
+      end
+
+      def reset(args=[])
+        set_scope(nil)
+        set_remote_node_name(nil)
+        set_node(nil)
+        set_facts(nil)
+        set_environment(nil)
+        set_log_level(log_level)
+      end
+
+      def set_log_level(level)
+        Puppet::Util::Log.level = level.to_sym
+        buffer_log = Puppet::Util::Log.newdestination(:buffer)
+        if buffer_log
+          # if this is already set the buffer_log is nil
+          buffer_log.out_buffer = out_buffer
+          buffer_log.err_buffer = out_buffer
+        end
+        nil
+      end
+
+      def krt(args=[])
+        known_resource_types.ai({:sort_keys => true, :indent => -1})
+      end
+
+      def play(args=[])
+        config = {}
+        config[:play] = args.first
+        play_back(config)
+        return nil  # we don't want to return anything
+      end
+
+      def classification(args=[])
+        node.classes.ai
+      end
+
+      def resources(args=[])
+        res = scope.compiler.catalog.resources.map do |res|
+          res.to_s.gsub(/\[/, "['").gsub(/\]/, "']") # ensure the title has quotes
+        end
+        if !args.first.nil?
+          res[args.first.to_i].ai
+        else
+          output = "Resources not shown in any specific order\n".warning
+          output += res.ai
+        end
+      end
+
+      def classes(args=[])
+        scope.compiler.catalog.classes.ai
+      end
+
+    end
+  end
+end

data/lib/puppet-debugger/support/node.rb

@@ -0,0 +1,90 @@
+require 'puppet/indirector/node/rest'
+
+module PuppetDebugger
+  module Support
+    module Node
+      # creates a node object using defaults or gets the remote node
+      # object if the remote_node_name is defined
+      def create_node
+        Puppet[:trusted_server_facts] = true if Puppet.version.to_f >= 4.1
+
+        if remote_node_name
+          # refetch
+          node_obj = set_node_from_name(remote_node_name)
+        end
+        unless node_obj
+          options = {}
+          options[:parameters] = default_facts.values
+          options[:facts] = default_facts
+          options[:classes] = []
+          options[:environment] = puppet_environment
+          name = default_facts.values['fqdn']
+          node_obj = Puppet::Node.new(name, options)
+          node_obj.add_server_facts(server_facts) if node_obj.respond_to?(:add_server_facts)
+          node_obj
+        end
+        node_obj
+      end
+
+      def set_remote_node_name(name)
+        @remote_node_name = name
+      end
+
+      def remote_node_name=(name)
+        @remote_node_name = name
+      end
+
+      def remote_node_name
+        @remote_node_name
+      end
+
+      # @return [node] puppet node object
+      def node
+        @node ||= create_node
+      end
+
+      def get_remote_node(name)
+        indirection = Puppet::Indirector::Indirection.instance(:node)
+        indirection.terminus_class = 'rest'
+        remote_node = indirection.find(name, :environment => puppet_environment)
+        remote_node
+      end
+
+      # this is a hack to get around that the puppet node fact face does not return
+      # a proper node object with the facts hash populated
+      # returns a node object with a proper facts hash
+      def convert_remote_node(remote_node)
+        options = {}
+        # remove trusted data as it will later get populated during compilation
+        parameters = remote_node.parameters.dup
+        trusted_data = parameters.delete('trusted')
+        options[:parameters] = parameters || {}
+        options[:facts] = Puppet::Node::Facts.new(remote_node.name,remote_node.parameters)
+        options[:classes] = remote_node.classes
+        options[:environment] = puppet_environment
+        node_object = Puppet::Node.new(remote_node.name, options)
+        node_object.add_server_facts(server_facts) if node_object.respond_to?(:add_server_facts)
+        node_object.trusted_data = trusted_data
+        node_object
+      end
+
+      # query the remote puppet server and retrieve the node object
+      #
+      def set_node_from_name(name)
+        out_buffer.puts ("Fetching node #{name}")
+        remote_node = get_remote_node(name)
+        if remote_node and remote_node.parameters.empty?
+          remote_node_name = nil  # clear out the remote name
+          raise PuppetDebugger::Exception::UndefinedNode.new(:name => remote_node.name)
+        end
+        remote_node_name = remote_node.name
+        node_object = convert_remote_node(remote_node)
+        set_node(node_object)
+      end
+
+      def set_node(value)
+        @node = value
+      end
+    end
+  end
+end

data/lib/puppet-debugger/support/play.rb

@@ -0,0 +1,91 @@
+module PuppetDebugger
+  module Support
+    module Play
+
+      def play_back(config={})
+        if config[:play]
+          if config[:play] =~ /^http/
+            play_back_url(config[:play])
+          elsif File.exists? config[:play]
+            play_back_string(File.read(config[:play]))
+          else config[:play]
+            out_buffer.puts "puppet-debugger can't play #{config[:play]}'"
+          end
+        end
+      end
+
+      def convert_to_text(url)
+        require 'uri'
+        url_data = URI(url)
+        case url_data.host
+        when /^gist\.github*/
+          unless url_data.path =~ /raw/
+            url = url += '.txt'
+          end
+          url
+        when /^github.com/
+          if url_data.path =~ /blob/
+            url.gsub('blob', 'raw')
+          end
+        when /^gist.github.com/
+          unless url_data.path =~ /raw/
+            url = url += '.txt'
+          end
+          url
+        when /^gitlab.com/
+          if url_data.path =~ /snippets/
+            url += '/raw' unless url_data.path =~ /raw/
+            url
+          else
+            url.gsub('blob', 'raw')
+          end
+        else
+          url
+        end
+      end
+
+      # opens the url and reads the data
+      def fetch_url_data(url)
+        open(url).read
+      end
+
+      def play_back_url(url)
+        begin
+          require 'open-uri'
+          require 'net/http'
+          converted_url = convert_to_text(url)
+          str = fetch_url_data(converted_url)
+          play_back_string(str)
+        rescue SocketError
+          abort "puppet-debugger can't play `#{converted_url}'"
+        end
+      end
+
+      # plays back the string to the output stream
+      # puts the input to the output as well as the produced output
+      def play_back_string(str)
+        full_buffer = ''
+        str.split("\n").each do |buf|
+          begin
+            full_buffer += buf
+            # unless this is puppet code, otherwise skip repl keywords
+            if keyword_expression.match(buf)
+              out_buffer.write(">> ")
+            else
+              parser.parse_string(full_buffer)
+              out_buffer.write(">> ")
+            end
+          rescue Puppet::ParseErrorWithIssue => e
+            if multiline_input?(e)
+              full_buffer += "\n"
+              next
+            end
+          end
+          out_buffer.puts(full_buffer)
+          handle_input(full_buffer)
+          full_buffer = ''
+        end
+      end
+    end
+  end
+end

data/lib/puppet-debugger/support/scope.rb

@@ -0,0 +1,42 @@
+module PuppetDebugger
+  module Support
+    module Scope
+      def set_scope(value)
+        @scope = value
+      end
+
+      # @return [Scope] puppet scope object
+      def scope
+        unless @scope
+          @scope ||= create_scope
+        end
+        @scope
+      end
+
+      def create_scope
+        do_initialize
+        begin
+          @compiler = create_compiler(node) # creates a new compiler for each scope
+          scope = Puppet::Parser::Scope.new(@compiler)
+          # creates a node class
+          scope.source = Puppet::Resource::Type.new(:node, node.name)
+          scope.parent = @compiler.topscope
+          load_lib_dirs
+          # compiling will load all the facts into the scope
+          # without this step facts will not get resolved
+          scope.compiler.compile # this will load everything into the scope
+        rescue StandardError => e
+          err = parse_error(e)
+          raise err
+        end
+        scope
+      end
+
+      # returns a hash of varaibles that are currently in scope
+      def scope_vars
+        vars = scope.to_hash.delete_if {| key, value | node.facts.values.key?(key.to_sym) }
+        vars['facts'] = 'removed by the puppet-debugger'
+      end
+    end
+  end
+end

data/lib/puppet-debugger/support.rb

@@ -0,0 +1,176 @@
+require 'puppet/pops'
+require 'facterdb'
+require 'tempfile'
+
+# load all the generators found in the generators directory
+Dir.glob(File.join(File.dirname(__FILE__),'support', '*.rb')).each do |file|
+  require_relative File.join('support', File.basename(file, '.rb'))
+end
+
+module PuppetDebugger
+  module Support
+    include PuppetDebugger::Support::Compilier
+    include PuppetDebugger::Support::Environment
+    include PuppetDebugger::Support::Facts
+    include PuppetDebugger::Support::Scope
+    include PuppetDebugger::Support::Functions
+    include PuppetDebugger::Support::Node
+    include PuppetDebugger::Support::InputResponders
+    include PuppetDebugger::Support::Play
+
+    # parses the error type into a more useful error message defined in errors.rb
+    # returns new error object or the original if error cannot be parsed
+    def parse_error(error)
+      case error
+      when SocketError
+        PuppetDebugger::Exception::ConnectError.new(:message => "Unknown host: #{Puppet[:server]}")
+      when Net::HTTPError
+        PuppetDebugger::Exception::AuthError.new(:message => error.message)
+      when Errno::ECONNREFUSED
+        PuppetDebugger::Exception::ConnectError.new(:message => error.message)
+      when Puppet::Error
+        if error.message =~ /could\ not\ find\ class/i
+          PuppetDebugger::Exception::NoClassError.new(:default_modules_paths => default_modules_paths,
+           :message => error.message)
+        elsif error.message =~ /default\ node/i
+          PuppetDebugger::Exception::NodeDefinitionError.new(:default_site_manifest => default_site_manifest,
+           :message => error.message)
+        else
+          error
+        end
+      else
+        error
+      end
+    end
+
+    # returns an array of module directories, generally this is the only place
+    # to look for puppet code by default.  This is read from the puppet configuration
+    def default_modules_paths
+      dirs = []
+      do_initialize if Puppet[:codedir].nil?
+      # add the puppet-debugger directory so we can load any defined functions
+      dirs << File.join(Puppet[:environmentpath],default_puppet_env_name,'modules') unless Puppet[:environmentpath].empty?
+      dirs << Puppet.settings[:basemodulepath].split(':')
+      dirs.flatten
+    end
+
+    # this is the lib directory of this gem
+    # in order to load any puppet functions from this gem we need to add the lib path
+    # of this gem
+    def puppet_repl_lib_dir
+      File.expand_path(File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'lib'))
+    end
+
+    # returns all the modules paths defined in the environment
+    def modules_paths
+      puppet_environment.full_modulepath
+    end
+
+    def initialize_from_scope(value)
+      set_scope(value)
+      unless value.nil?
+        set_environment(value.environment)
+        set_node(value.compiler.node)
+        set_compiler(value.compiler)
+      end
+    end
+
+     def keyword_expression
+       @keyword_expression ||= Regexp.new(/^exit|^:set|^play|^classification|^facts|^vars|^functions|^classes|^resources|^krt|^environment|^reset|^help/)
+     end
+
+    def known_resource_types
+      res = {
+        :hostclasses => scope.environment.known_resource_types.hostclasses.keys,
+        :definitions => scope.environment.known_resource_types.definitions.keys,
+        :nodes => scope.environment.known_resource_types.nodes.keys,
+      }
+      if sites = scope.environment.known_resource_types.instance_variable_get(:@sites)
+        res.merge!(:sites => scope.environment.known_resource_types.instance_variable_get(:@sites).first)
+      end
+      if scope.environment.known_resource_types.respond_to?(:applications)
+        res.merge!(:applications => scope.environment.known_resource_types.applications.keys)
+      end
+      # some versions of puppet do not support capabilities
+      if scope.environment.known_resource_types.respond_to?(:capability_mappings)
+        res.merge!(:capability_mappings => scope.environment.known_resource_types.capability_mappings.keys)
+      end
+      res
+    end
+
+    # this is required in order to load things only when we need them
+    def do_initialize
+      begin
+        Puppet.initialize_settings
+        Puppet[:parser] = 'future'  # this is required in order to work with puppet 3.8
+        Puppet[:trusted_node_data] = true
+      rescue ArgumentError => e
+
+      rescue Puppet::DevError => e
+        # do nothing otherwise calling init twice raises an error
+      end
+    end
+
+    # @param String - any valid puppet language code
+    # @return Hostclass - a puppet Program object which is considered the main class
+    def generate_ast(string = nil)
+      parse_result = parser.parse_string(string, '')
+      # the parse_result may be
+      # * empty / nil (no input)
+      # * a Model::Program
+      # * a Model::Expression
+      #
+      model = parse_result.nil? ? nil : parse_result.current
+      args = {}
+      ::Puppet::Pops::Model::AstTransformer.new('').merge_location(args, model)
+
+      ast_code =
+      if model.is_a? ::Puppet::Pops::Model::Program
+        ::Puppet::Parser::AST::PopsBridge::Program.new(model, args)
+      else
+        args[:value] = model
+        ::Puppet::Parser::AST::PopsBridge::Expression.new(args)
+      end
+      # Create the "main" class for the content - this content will get merged with all other "main" content
+      ::Puppet::Parser::AST::Hostclass.new('', :code => ast_code)
+    end
+
+    # @param String - any valid puppet language code
+    # @return Object - returns either a string of the result or object from puppet evaulation
+    def puppet_eval(input)
+      # in order to add functions to the scope the loaders must be created
+      # in order to call native functions we need to set the global_scope
+      ast = generate_ast(input)
+      # record the input for puppet to retrieve and reference later
+      file = Tempfile.new(['puppet_repl_input', '.pp'])
+      File.open(file, 'w') do |f|
+        f.write(input)
+      end
+      Puppet.override( {:code => input, :global_scope => scope, :loaders => scope.compiler.loaders } , 'For puppet-debugger') do
+         # because the repl is not a module we leave the modname blank
+         scope.environment.known_resource_types.import_ast(ast, '')
+         parser.evaluate_string(scope, input, File.expand_path(file))
+      end
+    end
+
+    def puppet_lib_dir
+      # returns something like "/Library/Ruby/Gems/2.0.0/gems/puppet-4.2.2/lib/puppet.rb"
+      # this is only useful when returning a namespace with the functions
+      @puppet_lib_dir ||= File.dirname(Puppet.method(:[]).source_location.first)
+    end
+
+    # returns a future parser for evaluating code
+    def parser
+      @parser ||= ::Puppet::Pops::Parser::EvaluatingParser.new
+    end
+
+    def default_manifests_dir
+      File.join(Puppet[:environmentpath],default_puppet_env_name,'manifests')
+    end
+
+    def default_site_manifest
+      File.join(default_manifests_dir, 'site.pp')
+    end
+
+  end
+end

data/lib/puppet-debugger.rb

@@ -0,0 +1,55 @@
+require_relative 'puppet-debugger/cli'
+require_relative 'version'
+require 'awesome_print'
+require_relative 'awesome_print/ext/awesome_puppet'
+require_relative 'trollop'
+require 'puppet/util/log'
+require_relative 'puppet-debugger/debugger_code'
+
+require_relative 'puppet-debugger/support/errors'
+# monkey patch in some color effects string methods
+class String
+  def red;            "\033[31m#{self}\033[0m" end
+  def green;          "\033[32m#{self}\033[0m" end
+  def cyan;           "\033[36m#{self}\033[0m" end
+  def yellow;         "\033[33m#{self}\033[0m" end
+  def warning;        yellow                   end
+  def fatal;          red                      end
+  def info;           green                    end
+
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map(&:capitalize).join
+  end
+end
+
+Puppet::Util::Log.newdesttype :buffer do
+  require 'puppet/util/colors'
+  include Puppet::Util::Colors
+
+  attr_accessor :err_buffer, :out_buffer
+
+  def initialize(err=$stderr, out=$stdout)
+    @err_buffer = err
+    @out_buffer = out
+  end
+
+  def handle(msg)
+    levels = {
+      :emerg   => { :name => 'Emergency', :color => :hred,  :stream => err_buffer },
+      :alert   => { :name => 'Alert',     :color => :hred,  :stream => err_buffer },
+      :crit    => { :name => 'Critical',  :color => :hred,  :stream => err_buffer },
+      :err     => { :name => 'Error',     :color => :hred,  :stream => err_buffer },
+      :warning => { :name => 'Warning',   :color => :hred,  :stream => err_buffer },
+      :notice  => { :name => 'Notice',    :color => :reset, :stream => out_buffer },
+      :info    => { :name => 'Info',      :color => :green, :stream => out_buffer },
+      :debug   => { :name => 'Debug',     :color => :cyan,  :stream => out_buffer },
+    }
+
+    str = msg.respond_to?(:multiline) ? msg.multiline : msg.to_s
+    str = msg.source == "Puppet" ? str : "#{msg.source}: #{str}"
+
+    level = levels[msg.level]
+    level[:stream].puts colorize(level[:color], "#{level[:name]}: #{str}")
+  end
+end