chef-apply 0.1.2

data/lib/chef_apply/temp_cookbook.rb

@@ -0,0 +1,159 @@
+#
+# Copyright:: Copyright (c) 2018 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "tmpdir"
+require "fileutils"
+require "chef_apply/log"
+require "chef_apply/error"
+
+module ChefApply
+  # This class knows how to create a local cookbook in a temp file, populate
+  # it with various recipes, attributes, config, etc. and delete it when the
+  # cookbook is no longer necessary
+  class TempCookbook
+    attr_reader :path
+
+    # We expect name to come in as a list of strings - resource/resource_name
+    # or cookbook/recipe combination
+    def initialize
+      @path = Dir.mktmpdir("cw")
+    end
+
+    def from_existing_recipe(existing_recipe_path)
+      ext_name = File.extname(existing_recipe_path)
+      raise UnsupportedExtension.new(ext_name) unless ext_name == ".rb"
+      cb = cookbook_for_recipe(existing_recipe_path)
+      if cb
+        # Full existing cookbook - only needs policyfile
+        ChefApply::Log.debug("Found full cookbook at path '#{cb[:path]}' and using recipe '#{cb[:recipe_name]}'")
+        name = cb[:name]
+        recipe_name = cb[:recipe_name]
+        FileUtils.cp_r(cb[:path], path)
+        # cp_r copies the whole existing cookbook into the tempdir so need to reset our path
+        @path = File.join(path, File.basename(cb[:path]))
+        generate_policyfile(name, recipe_name)
+      else
+        # Cookbook from single recipe not in a cookbook. We create the full cookbook
+        # structure including metadata, then generate policyfile. We set the cookbook
+        # name to the recipe name so hopefully this gives us better reporting info
+        # in the future
+        ChefApply::Log.debug("Found single recipe at path '#{existing_recipe_path}'")
+        recipe = File.basename(existing_recipe_path)
+        recipe_name = File.basename(existing_recipe_path, ext_name)
+        name = "cw_recipe"
+        recipes_dir = generate_recipes_dir
+        # This has the potential to break if they specify a recipe without a .rb
+        # extension, but lets wait to deal with that bug until we encounter it
+        FileUtils.cp(existing_recipe_path, File.join(recipes_dir, recipe))
+        generate_metadata(name)
+        generate_policyfile(name, recipe_name)
+      end
+    end
+
+    def from_resource(resource_type, resource_name, properties)
+      # Generate a cookbook containing a single default recipe with the specified
+      # resource in it. Incloud the resource type in the cookbook name so hopefully
+      # this gives us better reporting info in the future.
+      ChefApply::Log.debug("Generating cookbook for single resource '#{resource_type}[#{resource_name}]'")
+      name = "cw_#{resource_type}"
+      recipe_name = "default"
+      recipes_dir = generate_recipes_dir
+      File.open(File.join(recipes_dir, "#{recipe_name}.rb"), "w+") do |f|
+        f.print(create_resource(resource_type, resource_name, properties))
+      end
+      generate_metadata(name)
+      generate_policyfile(name, recipe_name)
+    end
+
+    def delete
+      FileUtils.remove_entry path
+    end
+
+    def cookbook_for_recipe(existing_recipe_path)
+      metadata = File.expand_path(File.join(existing_recipe_path, "../../metadata.rb"))
+      if File.file?(metadata)
+        require "chef/cookbook/metadata"
+        m = Chef::Cookbook::Metadata.new
+        m.from_file(metadata)
+        {
+          name: m.name,
+          recipe_name: File.basename(existing_recipe_path, File.extname(existing_recipe_path)),
+          path: File.expand_path(File.join(metadata, "../"))
+        }
+      else
+        nil
+      end
+    end
+
+    def generate_recipes_dir
+      recipes_path = File.join(path, "recipes")
+      FileUtils.mkdir_p(recipes_path)
+      recipes_path
+    end
+
+    def generate_metadata(name)
+      metadata_file = File.join(path, "metadata.rb")
+      File.open(metadata_file, "w+") do |f|
+        f.print("name \"#{name}\"\n")
+      end
+      metadata_file
+    end
+
+    def generate_policyfile(name, recipe_name)
+      policy_file = File.join(path, "Policyfile.rb")
+      if File.exist?(policy_file)
+        File.open(policy_file, "a") do |f|
+          # We override the specified run_list with the run_list we want.
+          # We append and put this at the end of the file so it overrides
+          # any specified run_list.
+          f.print("\n# Overriding run_list with command line specified value\n")
+          f.print("run_list \"#{name}::#{recipe_name}\"\n")
+        end
+      else
+        File.open(policy_file, "w+") do |f|
+          f.print("name \"#{name}_policy\"\n")
+          ChefApply::Config.chef.cookbook_repo_paths.each do |p|
+            f.print("default_source :chef_repo, \"#{p}\"\n")
+          end
+          f.print("default_source :supermarket\n")
+          f.print("run_list \"#{name}::#{recipe_name}\"\n")
+          f.print("cookbook \"#{name}\", path: \".\"\n")
+        end
+      end
+      policy_file
+    end
+
+    def create_resource(resource_type, resource_name, properties)
+      r = "#{resource_type} '#{resource_name}'"
+      # lets format the properties into the correct syntax Chef expects
+      unless properties.empty?
+        r += " do\n"
+        properties.each do |k, v|
+          v = "'#{v}'" if v.is_a? String
+          r += "  #{k} #{v}\n"
+        end
+        r += "end"
+      end
+      r += "\n"
+      r
+    end
+
+    class UnsupportedExtension < ChefApply::ErrorNoLogs
+      def initialize(ext); super("CHEFVAL009", ext); end
+    end
+  end
+end

data/lib/chef_apply/text.rb

@@ -0,0 +1,77 @@
+#
+# Copyright:: Copyright (c) 2017 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "r18n-desktop"
+
+# A very thin wrapper around R18n, the idea being that we're likely to replace r18n
+# down the road and don't want to have to change all of our commands.
+module ChefApply
+  class Text
+    R18n.from_env(File.join(File.dirname(__FILE__), "../..", "i18n/"))
+    t = R18n.get.t
+    t.translation_keys.each do |k|
+      k = k.to_sym
+      define_singleton_method k do |*args|
+        TextWrapper.new(t.send(k, *args))
+      end
+    end
+  end
+
+  # Our text spinner class really doesn't like handling the TranslatedString or Untranslated classes returned
+  # by the R18n library. So instead we return these TextWrapper instances which have dynamically defined methods
+  # corresponding to the known structure of the R18n text file. Most importantly, if a user has accessed
+  # a leaf node in the code we return a regular String instead of the R18n classes.
+  class TextWrapper
+    def initialize(translation_tree)
+      @tree = translation_tree
+      @tree.translation_keys.each do |k|
+        k = k.to_sym
+        define_singleton_method k do |*args|
+          subtree = @tree.send(k, *args)
+          if subtree.translation_keys.empty?
+            # If there are no more possible children, just return the translated value
+            subtree.to_s
+          else
+            TextWrapper.new(subtree)
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      raise InvalidKey.new(@tree.instance_variable_get(:@path), name)
+    end
+
+    class InvalidKey < RuntimeError
+      def initialize(path, terminus)
+        line = caller(3, 1).first # 1 - TextWrapper.method_missing
+                                 # 2 - TextWrapper.initialize
+                                 # 3 - actual caller
+        if line =~ /.*\/lib\/(.*\.rb):(\d+)/
+          line = "File: #{$1} Line: #{$2}"
+        end
+
+        # Calling back into Text here seems icky, this is an error
+        # that only engineering should see.
+        message = "i18n key #{path}.#{terminus} does not exist.\n"
+        message << "Referenced from #{line}"
+        super(message)
+      end
+    end
+
+  end
+end

data/lib/chef_apply/ui/error_printer.rb

@@ -0,0 +1,261 @@
+#
+# Copyright:: Copyright (c) 2017 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "train/errors"
+require "pastel"
+require "chef_apply/error"
+require "chef_apply/config"
+require "chef_apply/text"
+require "chef_apply/ui/terminal"
+
+module ChefApply::UI
+  class ErrorPrinter
+    attr_reader :id, :pastel, :show_log, :show_stack, :exception, :target_host
+    # TODO define 't' as a method is a temporary workaround
+    # to ensure that text key lookups are testable.
+    def t
+      ChefApply::Text.errors
+    end
+
+    DEFAULT_ERROR_NO = "CHEFINT001"
+
+    def self.show_error(e)
+      # Name is misleading - it's unwrapping but also doing further
+      # error resolution for common errors:
+      unwrapped = ChefApply::StandardErrorResolver.unwrap_exception(e)
+      if unwrapped.class == ChefApply::MultiJobFailure
+        capture_multiple_failures(unwrapped)
+      end
+      formatter = ErrorPrinter.new(e, unwrapped)
+      Terminal.output(formatter.format_error)
+    rescue => e
+      dump_unexpected_error(e)
+    end
+
+    def self.capture_multiple_failures(e)
+      out_file = ChefApply::Config.error_output_path
+      e.params << out_file # Tell the operator where to find this info
+      File.open(out_file, "w") do |out|
+        e.jobs.each do |j|
+          wrapped = ChefApply::StandardErrorResolver.wrap_exception(j.exception, j.target_host)
+          ep = ErrorPrinter.new(wrapped)
+          msg = ep.format_body().tr("\n", " ").gsub(/ {2,}/, " ").chomp.strip
+          out.write("Host: #{j.target_host.hostname} ")
+          if ep.exception.respond_to? :id
+            out.write("Error: #{ep.exception.id}: ")
+          else
+            out.write(": ")
+          end
+          out.write("#{msg}\n")
+        end
+      end
+    end
+
+    def self.write_backtrace(e, args)
+      formatter = ErrorPrinter.new(e)
+      out = StringIO.new
+      formatter.add_backtrace_header(out, args)
+      formatter.add_formatted_backtrace(out)
+      formatter.save_backtrace(out)
+    rescue => ex
+      dump_unexpected_error(ex)
+    end
+
+    # Use this to dump an an exception to output. useful
+    # if an error occurs in the error handling itself.
+    def self.dump_unexpected_error(e)
+      Terminal.output "INTERNAL ERROR"
+      Terminal.output "-=" * 30
+      Terminal.output "Message:"
+      Terminal.output e.message if e.respond_to?(:message)
+      Terminal.output "Backtrace:"
+      Terminal.output e.backtrace if e.respond_to?(:backtrace)
+      Terminal.output "=-" * 30
+    end
+
+    def initialize(wrapper, unwrapped = nil, target_host = nil)
+      @exception = unwrapped || wrapper.contained_exception
+      @target_host = wrapper.target_host || target_host
+      @pastel = Pastel.new
+      @show_log = exception.respond_to?(:show_log) ? exception.show_log : true
+      @show_stack = exception.respond_to?(:show_stack) ? exception.show_stack : true
+      @content = StringIO.new
+      @command = exception.respond_to?(:command) ? exception.command : nil
+      @id = DEFAULT_ERROR_NO
+      if exception.respond_to?(:id) && exception.id =~ /CHEF.*/
+        @id = exception.id
+      end
+      if exception.respond_to?(:decorate)
+        @decorate = exception.decorate
+      else
+        @decorate = true
+      end
+    rescue => e
+      ErrorPrinter.dump_unexpected_error(e)
+      exit! 128
+    end
+
+    def format_error
+      if @decorate
+        format_decorated
+      else
+        format_undecorated
+      end
+      @content.string
+    end
+
+    def format_undecorated
+      @content << "\n"
+      @content << format_body()
+      if @command
+        @content << "\n"
+        @content << @command.usage
+      end
+    end
+
+    def format_decorated
+      @content << "\n"
+      @content << format_header()
+      @content << "\n\n"
+      @content << format_body()
+      @content << "\n"
+      @content << format_footer()
+      @content << "\n"
+    end
+
+    def format_header
+      pastel.decorate(@id, :bold)
+    end
+
+    def format_body
+      if exception.kind_of? ChefApply::Error
+        format_workstation_exception
+      elsif exception.kind_of? Train::Error
+        format_train_exception
+      else
+        format_other_exception
+      end
+    end
+
+    def format_footer
+      if show_log
+        if show_stack
+          t.footer.both(ChefApply::Config.log.location,
+                        ChefApply::Config.stack_trace_path)
+        else
+          t.footer.log_only(ChefApply::Config.log.location)
+        end
+      else
+        if show_stack
+          t.footer.stack_only
+        else
+          t.footer.neither
+        end
+      end
+    end
+
+    def add_backtrace_header(out, args)
+      out.write("\n#{"-" * 80}\n")
+      out.print("#{Time.now}: Error encountered while running the following:\n")
+      out.print("  #{args.join(' ')}\n")
+      out.print("Backtrace:\n")
+    end
+
+    def save_backtrace(output)
+      File.open(ChefApply::Config.stack_trace_path, "ab+") do |f|
+        f.write(output.string)
+      end
+    end
+
+    def self.error_summary(e)
+      if e.kind_of? ChefApply::Error
+        # By convention, all of our defined messages have a short summary on the first line.
+        ChefApply::Text.errors.send(e.id, *e.params).split("\n").first
+      elsif e.kind_of? String
+        e
+      else
+        if e.respond_to? :message
+          e.message
+        else
+          ChefApply::Text.errors.UNKNOWN
+        end
+      end
+    end
+
+    def format_workstation_exception
+      params = exception.params
+      t.send(@id, *params)
+    end
+
+    def format_train_exception
+      backend, host = formatted_host()
+      if host.nil?
+        t.CHEFTRN002(exception.message)
+      else
+        t.CHEFTRN001(backend, host, exception.message)
+      end
+    end
+
+    def format_other_exception
+      t.send(DEFAULT_ERROR_NO, exception.message)
+    end
+
+    def formatted_host
+      return nil if target_host.nil?
+      cfg = target_host.config
+      port = cfg[:port].nil? ? "" : ":#{cfg[:port]}"
+      user = cfg[:user].nil? ? "" : "#{cfg[:user]}@"
+      "#{user}#{target_host.hostname}#{port}"
+    end
+
+    # mostly copied from
+    # https://gist.github.com/stanio/13d74294ca1868fed7fb
+    def add_formatted_backtrace(out)
+      _format_single(out, exception)
+      current_backtrace = exception.backtrace
+      cause = exception.cause
+      until cause.nil?
+        cause_trace = _unique_trace(cause.backtrace.to_a, current_backtrace)
+        out.print "Caused by: "
+        _format_single(out, cause, cause_trace)
+        backtrace_length = cause.backtrace.length
+        if backtrace_length > cause_trace.length
+          out.print "\t... #{backtrace_length - cause_trace.length} more"
+        end
+        out.print "\n"
+        current_backtrace = cause.backtrace
+        cause = cause.cause
+      end
+    end
+
+    def _format_single(out, exception, backtrace = nil)
+      out.puts "#{exception.class}: #{exception.message}"
+      backtrace ||= exception.backtrace.to_a
+      backtrace.each { |trace| out.puts "\t#{trace}" }
+    end
+
+    def _unique_trace(backtrace1, backtrace2)
+      i = 1
+      while i <= backtrace1.size && i <= backtrace2.size
+        break if backtrace1[-i] != backtrace2[-i]
+        i += 1
+      end
+      backtrace1[0..-i]
+    end
+  end
+
+end