chef-core 0.0.1

data/lib/chef_core/cliux/ui/error_printer.rb

@@ -0,0 +1,266 @@
+#
+# 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_core/error"
+require "chef_core/text"
+require "chef_core/cliux/ui/terminal"
+require "chef_core/errors/standard_error_resolver"
+
+module ChefCore
+  module CLIUX
+    module UI
+      class ErrorPrinter
+        attr_reader :id, :pastel, :translation, :exception, :target_host, :config
+
+        # 't' is a convenience method for accessing error i18n error definitions.
+        # It also serves as a workaround to let us verify that correct text key
+        # lookups happen in unit tests.
+        def t
+          ChefCore::Text.errors
+        end
+
+        DEFAULT_ERROR_NO = "CHEFINT001".freeze
+
+        def self.show_error(e, config)
+          # Name is misleading - it's unwrapping but also doing further
+          # error resolution for common errors:
+          unwrapped = ChefCore::Errors::StandardErrorResolver.unwrap_exception(e)
+          if unwrapped.class == ChefCore::MultiJobFailure
+            capture_multiple_failures(unwrapped, config)
+          end
+          formatter = ErrorPrinter.new(wrapper: e,
+                                       exception: unwrapped,
+                                       config: config)
+
+          Terminal.output(formatter.format_error)
+        rescue => ex
+          dump_unexpected_error(ex)
+        end
+
+        def self.capture_multiple_failures(e, config)
+          e.params << config[:error_output_path] # Tell the operator where to find this info
+          File.open(config[:error_output_path], "w") do |out|
+            e.jobs.each do |j|
+              wrapped = ChefCore::Errors::StandardErrorResolver.wrap_exception(j.exception, j.target_host)
+              ep = ErrorPrinter.new(wrapper: wrapped, config: config)
+              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, config)
+          formatter = ErrorPrinter.new(wrapper: e, config: config)
+          out = StringIO.new
+          formatter.add_backtrace_header(out, args)
+          formatter.add_formatted_backtrace(out)
+          formatter.save_backtrace(out, config)
+        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: nil, config: nil, exception: nil)
+          @exception = exception || wrapper.contained_exception
+          @target_host = wrapper.target_host || target_host
+          @command = @exception.respond_to?(:command) ? @exception.command : nil
+          @pastel = Pastel.new
+          @content = StringIO.new
+          @config = config
+          @id = if @exception.kind_of? ChefCore::Error
+                  @exception.id
+                else
+                  DEFAULT_ERROR_NO
+                end
+          @translation = ChefCore::Text::ErrorTranslation.new(id)
+        rescue => e
+          ErrorPrinter.dump_unexpected_error(e)
+          exit! 128
+        end
+
+        def format_error
+          if translation.decorations
+            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? ChefCore::Error
+            format_workstation_exception
+          elsif exception.kind_of? Train::Error
+            format_train_exception
+          else
+            format_other_exception
+          end
+        end
+
+        def format_footer
+          if translation.log
+            if translation.stack
+              t.footer.both(config[:log_location], config[:stack_trace_path])
+            else
+              t.footer.log_only(config[:log_location])
+            end
+          else
+            if translation.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, config)
+          File.open(config[:stack_trace_path], "ab+") do |f|
+            f.write(output.string)
+          end
+        end
+
+        def self.error_summary(e)
+          if e.kind_of? ChefCore::Error
+            # By convention, all of our defined messages have a short summary on the first line.
+            ChefCore::Text.errors.send(e.id).text(*e.params).split("\n").first
+          elsif e.kind_of? String
+            e
+          else
+            if e.respond_to? :message
+              e.message
+            else
+              ChefCore::Text.errors.UNKNOWN
+            end
+          end
+        end
+
+        def format_workstation_exception
+          params = exception.params
+          t.send(@id).text(*params)
+        end
+
+        # TODO this gets moved to trainerrormapper  or simply removed since
+        #     many of these issues are now handled in the RemoteTarget::ConnectionFailure
+        def format_train_exception
+          backend, host = formatted_host()
+          if host.nil?
+            t.CHEFTRN002.text(exception.message)
+          else
+            t.CHEFTRN001.text(backend, host, exception.message)
+          end
+        end
+
+        def format_other_exception
+          t.send(DEFAULT_ERROR_NO).text(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
+  end
+end

data/lib/chef_core/cliux/ui/plain_text_element.rb

@@ -0,0 +1,80 @@
+#
+# 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.
+#
+
+module ChefCore
+  module CLIUX
+    module UI
+      class PlainTextElement
+        def initialize(format, opts)
+          @orig_format = format
+          @format = format
+          @output = opts[:output]
+        end
+
+        def run(&block)
+          yield
+        end
+
+        def update(params)
+          # Some of this is particular to our usage -
+          # prefix does not cause a text update, but does
+          # change the prefix for future messages.
+          if params.key?(:prefix)
+            @format = @orig_format.gsub(":prefix", params[:prefix])
+            return
+          end
+
+          if @succ
+            ind = "OK"
+            @succ = false
+            log_method = :info
+          elsif @err
+            ind = "ERR"
+            @err = false
+            log_method = :error
+          else
+            log_method = :debug
+            ind = " - "
+          end
+
+          # Since this is a generic type, we can replace any component
+          # name in this regex - but for now :spinner is the only component
+          # we're standing in for.
+          msg = @format.gsub(/:spinner/, ind)
+          params.each_pair do |k, v|
+            msg.gsub!(/:#{k}/, v)
+          end
+          ChefCore::Log.send(log_method, msg)
+          @output.puts(msg)
+        end
+
+        def error
+          @err = true
+          @succ = false
+        end
+
+        def success
+          @succ = true
+          @err = false
+        end
+
+        def auto_spin
+        end
+      end
+    end
+  end
+end

data/lib/chef_core/cliux/ui/plain_text_header.rb

@@ -0,0 +1,48 @@
+#
+# 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 "thread"
+require "chef_core/cliux/ui/plain_text_element"
+
+module ChefCore
+  module CLIUX
+    module UI
+      class PlainTextHeader
+        def initialize(format, opts)
+          @format = format
+          @output = opts[:output]
+          @children = {}
+          @threads = []
+        end
+
+        def register(child_format, child_opts, &block)
+          child_opts[:output] = @output
+          child = PlainTextElement.new(child_format, child_opts)
+          @children[child] = block
+        end
+
+        def auto_spin
+          msg = @format.gsub(/:spinner/, " HEADER ")
+          @output.puts(msg)
+          @children.each do |child, block|
+            @threads << Thread.new { block.call(child) }
+          end
+          @threads.each { |thr| thr.join }
+        end
+      end
+    end
+  end
+end

data/lib/chef_core/cliux/ui/terminal/job.rb

@@ -0,0 +1,41 @@
+#
+# 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.
+#
+
+module ChefCore
+  module CLIUX
+    module UI
+      class Terminal
+        class Job
+          attr_reader :proc, :prefix, :target_host, :exception
+          def initialize(prefix, target_host, &block)
+            @proc = block
+            @prefix = prefix
+            @target_host = target_host
+            @error = nil
+          end
+
+          def run(reporter)
+            @proc.call(reporter)
+          rescue => e
+            reporter.error(e.to_s)
+            @exception = e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef_core/cliux/ui/terminal.rb

@@ -0,0 +1,103 @@
+#
+# 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 "tty-spinner"
+require "tty-cursor"
+require "chef_core/log"
+require "chef_core/cliux/status_reporter"
+require "chef_core/cliux/ui/plain_text_element"
+require "chef_core/cliux/ui/plain_text_header"
+require "chef_core/cliux/ui/terminal/job"
+
+module ChefCore
+  module CLIUX
+    module UI
+      class Terminal
+        class << self
+          # To support matching in test
+          attr_accessor :location, :enable_spinners
+
+          def init(location, enable_spinners: false)
+            @enable_spinners = enable_spinners
+            @location = location
+          end
+
+          def write(msg)
+            @location.write(msg)
+          end
+
+          def output(msg)
+            @location.puts msg
+          end
+
+          def render_parallel_jobs(header, jobs)
+            # Do not indent the topmost 'parent' spinner, but do indent child spinners
+            indent_style = { top: "",
+                             middle: TTY::Spinner::Multi::DEFAULT_INSET[:middle],
+                             bottom: TTY::Spinner::Multi::DEFAULT_INSET[:bottom] }
+            # @option options [Hash] :style
+            #   keys :top :middle and :bottom can contain Strings that are used to
+            #   indent the spinners. Ignored if message is blank
+            multispinner = get_multispinner.new("[:spinner] #{header}",
+                                                output: @location,
+                                                hide_cursor: true,
+                                                style: indent_style)
+            jobs.each do |job|
+              multispinner.register(spinner_prefix(job.prefix), hide_cursor: true) do |spinner|
+                reporter = StatusReporter.new(spinner, prefix: job.prefix, key: :status)
+                job.run(reporter)
+              end
+            end
+            multispinner.auto_spin
+          ensure
+            # Spinners hide the cursor for better appearance, so we need to make sure
+            # we always bring it back
+            show_cursor
+          end
+
+          def render_job(initial_msg, job)
+            # TODO why do we have to pass prefix to both the spinner and the reporter?
+            spinner = get_spinner.new(spinner_prefix(job.prefix), output: @location, hide_cursor: true)
+            reporter = StatusReporter.new(spinner, prefix: job.prefix, key: :status)
+            reporter.update(initial_msg)
+            spinner.auto_spin
+            job.run(reporter)
+          end
+
+          def spinner_prefix(prefix)
+            spinner_msg = "[:spinner] "
+            spinner_msg += ":prefix " unless prefix.empty?
+            spinner_msg + ":status"
+          end
+
+          def get_multispinner
+            enable_spinners ? TTY::Spinner::Multi : PlainTextHeader
+          end
+
+          def get_spinner
+              # TODO bootstrap - these was as below, which seems backwards:
+            enable_spinners ? TTY::Spinner : PlainTextElement
+          end
+
+          def show_cursor
+            TTY::Cursor.show()
+          end
+        end
+      end
+    end
+  end
+end

data/lib/chef_core/cliux.rb

@@ -0,0 +1,7 @@
+
+require "chef_core/text"
+
+module ChefCore
+  module CLIUX
+  end
+end

data/lib/chef_core/error.rb

@@ -0,0 +1,49 @@
+#
+# 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.
+#
+
+module ChefCore
+  class Error < StandardError
+    attr_reader :id, :params
+    def initialize(id, *params)
+      @id = id
+      @params = params || []
+    end
+  end
+
+
+  class WrappedError < StandardError
+    attr_accessor :target_host, :contained_exception
+    def initialize(e, target_host)
+      super(e.message)
+      @contained_exception = e
+      @target_host = target_host
+    end
+  end
+
+  class MultiJobFailure < Error
+    attr_reader :jobs
+    def initialize(jobs)
+      super("CHEFMULTI001")
+      @jobs = jobs
+    end
+  end
+
+  # Provide a base type for internal usage errors that should not leak out
+  # but may anyway.
+  class APIError < Error
+  end
+end

data/lib/chef_core/errors/standard_error_resolver.rb

@@ -0,0 +1,38 @@
+module ChefCore
+  module Errors
+    # Provides mappings of common errors that we don't explicitly
+    # handle, but can offer expanded help text around.
+    class StandardErrorResolver
+      def self.resolve_exception(exception)
+        deps
+        case exception
+        when OpenSSL::SSL::SSLError
+          if exception.message =~ /SSL.*verify failed.*/
+            id = "CHEFNET002"
+          end
+        when SocketError then id = "CHEFNET001"
+        end
+        if id.nil?
+          exception
+        else
+          ChefCore::Error.new(id, exception.message)
+        end
+      end
+
+      def self.wrap_exception(original, target_host = nil)
+        resolved_exception = resolve_exception(original)
+        WrappedError.new(resolved_exception, target_host)
+      end
+
+      def self.unwrap_exception(wrapper)
+        resolve_exception(wrapper.contained_exception)
+      end
+
+      def self.deps
+        # Avoid loading additional includes until they're needed
+        require "socket"
+        require "openssl"
+      end
+    end
+  end
+end

data/lib/chef_core/file_fetcher.rb

@@ -0,0 +1,67 @@
+#
+# 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 "net/http"
+require "uri"
+
+module ChefCore
+  class FileFetcher
+    class << self
+      # Simple fetcher of an http(s) url. Returns the local path
+      # of the downloaded file.
+      def fetch(cache_path, path)
+        FileUtils.mkdir_p(cache_path)
+        url = URI.parse(path)
+        name = File.basename(url.path)
+        local_path = File.join(cache_path, name)
+
+        # TODO header check for size or checksum?
+        return local_path if File.exist?(local_path)
+
+        download_file(url, local_path)
+        local_path
+      end
+
+      def download_file(url, local_path)
+        temp_path = "#{local_path}.downloading"
+        file = open(temp_path, "wb")
+        ChefCore::Log.debug "Downloading: #{temp_path}"
+        Net::HTTP.start(url.host) do |http|
+          begin
+            http.request_get(url.path) do |resp|
+              resp.read_body do |segment|
+                file.write(segment)
+              end
+            end
+          rescue e
+            @error = true
+            raise
+          ensure
+            file.close()
+            # If any failures occurred, don't risk keeping
+            # an incomplete download that we'll see as 'cached'
+            if @error
+              FileUtils.rm_f(temp_path)
+            else
+              FileUtils.mv(temp_path, local_path)
+            end
+          end
+        end
+      end
+    end
+  end
+end