Method: Toaster::ResourceInspector.get_resource_from_source

Defined in:

lib/toaster/chef/resource_inspector.rb

.get_resource_from_source(resource_src, attribute_src, cookbook_paths = []) ⇒ Object

# File 'lib/toaster/chef/resource_inspector.rb', line 83

def self.get_resource_from_source(resource_src, attribute_src, cookbook_paths = [])
  resource = nil

  # we are performing multiple parsing attempts. if parsing goes well, 
  # the resource is returned. however, if a parsing error occurs, we 
  # investigate the error message, and for missing variables we add a default 
  # initializer to the beginning of the source code. Then, we re-attempt 
  # to parse the code.
  # The maximum number of such attempts is defined here.
  max_attempts = 20

  chef_client_json = { 
    "platform" => "ubuntu", 
    "platform_version" => "12.04",
    "kernel" => { "machine" => "x86_64" },
    "log_level" => :fatal,
    "ipaddress" => ""
  }

  # define some inits in script source:
  preamble = "
        require 'toaster/chef/chef_node_inspector'
        $old_node = node
        $new_node = Toaster::DefaultProcessorRecursive.new(
            #{chef_client_json.inspect})

        require 'toaster/chef/failsafe_resource_parser'

        $old_node.attributes_proxy = $new_node
        node = $new_node
        template = $new_node
        self.attributes_proxy = $new_node
        "

  attribute_src = 
    "#{preamble} #{attribute_src}"
#      resource_src = 
#        "#{preamble} #{resource_src}"

  #puts "getting resource source: #{resource_src}\n---"

  max_attempts.downto(1) do |attempt|

    Tempfile.open("chef.resource.rb") do |file|
      file.write(resource_src)
      file.flush

      Tempfile.open("chef.attributes.rb") do |file1|
        file1.write(attribute_src)
        file1.flush

        orig_log_level = ChefUtil.get_chef_log_level()

        begin

          ChefUtil.set_chef_log_level(:fatal)

          if !@@initialized
            chef_cfg = Chef::Config
            chef_cfg[:solo] = true
            chef_cfg[:node_name] = "foobar"
            path_new = []
            chef_cfg[:cookbook_path].each do |p|
              path_new << p if File.directory?(p)
            end
            chef_cfg[:cookbook_path] = path_new
            chef_cfg[:cookbook_path] << File.expand_path(File.join(File.dirname(__FILE__), 'cookbooks'))
            chef_cfg[:cookbook_path].concat(cookbook_paths)
            chef_cfg[:log_level] = :fatal
            chef_cfg[:verbose_logging] = false
            Chef::Application::Solo.new # this initializes some important state variables

            @@chef_client = Chef::Client.new(
              chef_client_json
            )
            begin
              @@node = @@chef_client.build_node
            rescue
              # required to avoid exception in Chef 11.12.8
              @@node = @@chef_client.policy_builder.load_node
            end
            @@cookbook_collection = Chef::CookbookCollection.new(
            Chef::CookbookLoader.new(chef_cfg[:cookbook_path]))

            @@initialized = true
          end

          if attribute_src && attribute_src.to_s.strip != ""
            @@node.from_file(file1.path)
          end

          run_context = nil
          begin
            run_context = Chef::RunContext.new(@@node, @@cookbook_collection)
          rescue
            # required to avoid exception in Chef 11.12.8
            run_context = Chef::RunContext.new(@@node, @@cookbook_collection, nil)
          end
          recipe = Chef::Recipe.new("apache2", "default", run_context)
          recipe.from_file(file.path)

          #puts "getting resource from recipe #{recipe}"
          resource = recipe.run_context.resource_collection.all_resources[0]
          #puts "returning resource: #{resource}"
          #puts "--> #{recipe.run_context.resource_collection.all_resources}"

          return resource
        rescue Object => ex
          msg = ex.to_s
          puts msg if attempt <= 1
          puts ex.backtrace if attempt <= 1

          if msg.match(/Cannot find a resource for/)
            pkg_name = msg.gsub(/.*for ([a-z0-9A-Z_]+) on.*/, '\1').to_s
            resource_src = "#{pkg_name} = \"initializer_for_unknown_variable_#{pkg_name}\" \n #{resource_src}"
          elsif msg.match(/undefined (local variable or )?method/)
            var_name = msg.gsub(/.*method `([a-z0-9A-Z_]+).* for.*/, '\1').to_s
            resource_src = "#{var_name} = \"initializer_for_unknown_variable_#{var_name}\" \n #{resource_src}"
          elsif msg.match(/No resource or method named `([a-z0-9A-Z_]+)' for/)
            res_name = msg.gsub(/.*No resource or method named `([a-z0-9A-Z_]+)' for.*/, '\1').to_s
            tmp_class_name = "MyResource#{Util.generate_short_uid()}"
            resource_src = 
            "class #{tmp_class_name} < Chef::Resource
              def initialize(name = nil, run_context = nil)
                super
                @resource_name = :#{res_name}
                @enclosing_provider_fixed = DefaultProcessorRecursive.new
                @enclosing_provider_fixed.swallow_calls_hash = {}
              end
              def enclosing_provider
                @enclosing_provider_fixed
              end
              def action(arg=nil)
                self.allowed_actions << arg
                super
              end
            end
            #{tmp_class_name}.provides(:#{res_name})
            #{resource_src}"
          elsif msg.match(  /resource matching/)
            regex = /.*resource matching (.*)\[(.*)\].*/
            res_type = msg.gsub(regex, '\1').to_s
            res_name = msg.gsub(regex, '\2').to_s
            resource_src = "#{res_type} \"#{res_name}\" do \n end \n\n #{resource_src}"
          else
            puts "ERROR: Could not get Chef resource object from source code: #{msg}"
            puts ex.backtrace.join("\n")
            puts File.read(file.path)
            puts "---------"
            puts File.read(file1.path)
            puts "---------"
            return nil
          end
        ensure
          ChefUtil.set_chef_log_level(orig_log_level)
        end
      end
    end
  end
  return resource
end