chef-apply 0.1.2

data/lib/chef_apply/cli_options.rb

@@ -0,0 +1,145 @@
+#
+# 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 "chef_apply/text"
+require "chef_apply/action/install_chef"
+
+# Moving the options into here so the cli.rb file is smaller and easier to read
+# For options that need to be merged back into the global ChefApply::Config object
+#   we do that with a proc in the option itself. We decided to do that because it is
+#   an easy, straight forward way to merge those options when they do not directly
+#   map back to keys in the Config global. IE, we cannot just do
+#   `ChefApply::Config.merge!(options)` because the keys do not line up, and we do
+#   not want all CLI params merged back into the global config object.
+# We know that the config is already loaded from the file (or program defaults)
+#   because the `Startup` class was invoked to start the program.
+module ChefApply
+  module CLIOptions
+
+    T = ChefApply::Text.cli
+    TS = ChefApply::Text.status
+
+    def self.included(klass)
+      klass.banner T.description + "\n" + T.usage_full
+
+      klass.option :version,
+        short: "-v",
+        long: "--version",
+        description:  T.version.description,
+        boolean: true
+
+      klass.option :help,
+        short: "-h",
+        long: "--help",
+        description:   T.help.description,
+        boolean: true
+
+      # Special note:
+      # config_path is pre-processed in startup.rb, and is shown here only
+      # for purpoess of rendering help text.
+      klass.option :config_path,
+        short: "-c PATH",
+        long: "--config PATH",
+        description: T.default_config_location(ChefApply::Config.default_location),
+        default: ChefApply::Config.default_location,
+        proc: Proc.new { |path| ChefApply::Config.custom_location(path) }
+
+      klass.option :identity_file,
+        long: "--identity-file PATH",
+        short: "-i PATH",
+        description: T.identity_file,
+        proc: (Proc.new do |paths|
+          path = paths
+          unless File.exist?(path)
+            raise OptionValidationError.new("CHEFVAL001", self, path)
+          end
+          path
+        end)
+
+      klass.option :ssl,
+        long: "--[no-]ssl",
+        description:  T.ssl.desc(ChefApply::Config.connection.winrm.ssl),
+        boolean: true,
+        default: ChefApply::Config.connection.winrm.ssl,
+        proc: Proc.new { |val| ChefApply::Config.connection.winrm.ssl(val) }
+
+      klass.option :ssl_verify,
+        long: "--[no-]ssl-verify",
+        description:  T.ssl.verify_desc(ChefApply::Config.connection.winrm.ssl_verify),
+        boolean: true,
+        default: ChefApply::Config.connection.winrm.ssl_verify,
+        proc: Proc.new { |val| ChefApply::Config.connection.winrm.ssl_verify(val) }
+
+      klass.option :protocol,
+        long: "--protocol <PROTOCOL>",
+        short: "-p",
+        description: T.protocol_description(ChefApply::Config::SUPPORTED_PROTOCOLS.join(" "),
+                                            ChefApply::Config.connection.default_protocol),
+        default: ChefApply::Config.connection.default_protocol,
+        proc: Proc.new { |val| ChefApply::Config.connection.default_protocol(val) }
+
+      klass.option :user,
+        long: "--user <USER>",
+        description: T.user_description
+
+      klass.option :password,
+        long: "--password <PASSWORD>",
+        description: T.password_description
+
+      klass.option :cookbook_repo_paths,
+        long: "--cookbook-repo-paths PATH",
+        description: T.cookbook_repo_paths,
+        default: ChefApply::Config.chef.cookbook_repo_paths,
+        proc: (Proc.new do |paths|
+          paths = paths.split(",")
+          ChefApply::Config.chef.cookbook_repo_paths(paths)
+          paths
+        end)
+
+      klass.option :install,
+        long: "--[no-]install",
+        default: true,
+        boolean: true,
+        description:  T.install_description(Action::InstallChef::Base::MIN_CHEF_VERSION)
+
+      klass.option :sudo,
+        long: "--[no-]sudo",
+        description: T.sudo.flag_description.sudo,
+        boolean: true,
+        default: true
+
+      klass.option :sudo_command,
+        long: "--sudo-command <COMMAND>",
+        default: "sudo",
+        description: T.sudo.flag_description.command
+
+      klass.option :sudo_password,
+        long: "--sudo-password <PASSWORD>",
+        description: T.sudo.flag_description.password
+
+      klass.option :sudo_options,
+        long: "--sudo-options 'OPTIONS...'",
+        description: T.sudo.flag_description.options
+    end
+
+    # I really don't like that mixlib-cli refers to the parsed command line flags in
+    # a hash accesed via the `config` method. Thats just such an overloaded word.
+    def parsed_options
+      config
+    end
+  end
+end

data/lib/chef_apply/config.rb

@@ -0,0 +1,150 @@
+#
+# 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 "chef_apply/log"
+require "mixlib/config"
+require "fileutils"
+require "pathname"
+require "chef-config/config"
+require "chef-config/workstation_config_loader"
+
+module ChefApply
+  class Config
+    WS_BASE_PATH = File.join(Dir.home, ".chef-workstation/")
+    SUPPORTED_PROTOCOLS = %w{ssh winrm}
+
+    class << self
+      @custom_location = nil
+
+      # Ensure when we extend Mixlib::Config that we load
+      # up the workstation config since we will need that
+      # to converge later
+      def initialize_mixlib_config
+        super
+      end
+
+      def custom_location(path)
+        @custom_location = path
+        raise "No config file located at #{path}" unless exist?
+      end
+
+      def default_location
+        File.join(WS_BASE_PATH, "config.toml")
+      end
+
+      def telemetry_path
+        File.join(WS_BASE_PATH, "telemetry")
+      end
+
+      def telemetry_session_file
+        File.join(telemetry_path, "TELEMETRY_SESSION_ID")
+      end
+
+      def telemetry_installation_identifier_file
+        File.join(WS_BASE_PATH, "installation_id")
+      end
+
+      def base_log_directory
+        File.dirname(log.location)
+      end
+
+      # These paths are relative to the log output path, which is user-configurable.
+      def error_output_path
+        File.join(base_log_directory, "errors.txt")
+      end
+
+      def stack_trace_path
+        File.join(base_log_directory, "stack-trace.log")
+      end
+
+      def using_default_location?
+        @custom_location.nil?
+      end
+
+      def location
+        using_default_location? ? default_location : @custom_location
+      end
+
+      def load
+        if exist?
+          from_file(location)
+        end
+      end
+
+      def exist?
+        File.exist? location
+      end
+
+      def reset
+        @custom_location = nil
+        super
+      end
+    end
+
+    extend Mixlib::Config
+
+    config_strict_mode true
+
+    # When working on Chef Apply itself,
+    # developers should set telemetry.dev to true
+    # in their local configuration to ensure that dev usage
+    # doesn't skew customer telemetry.
+    config_context :telemetry do
+      default(:dev, false)
+      default(:enable, true)
+    end
+
+    config_context :log do
+      default(:level, "warn")
+      default(:location, File.join(WS_BASE_PATH, "logs/default.log"))
+    end
+
+    config_context :cache do
+      default(:path, File.join(WS_BASE_PATH, "cache"))
+    end
+
+    config_context :connection do
+      default(:default_protocol, "ssh")
+      default(:default_user, nil)
+
+      config_context :winrm do
+        default(:ssl, false)
+        default(:ssl_verify, true)
+      end
+    end
+
+    config_context :dev do
+      default(:spinner, "TTY::Spinner")
+    end
+
+    config_context :chef do
+      # We want to use any configured chef repo paths or trusted certs in
+      # ~/.chef/knife.rb on the user's workstation. But because they could have
+      # config that could mess up our Policyfile creation later we reset the
+      # ChefConfig back to default after loading that.
+      ChefConfig::WorkstationConfigLoader.new(nil, ChefApply::Log).load
+      default(:cookbook_repo_paths, [ChefConfig::Config[:cookbook_path]].flatten)
+      default(:trusted_certs_dir, ChefConfig::Config[:trusted_certs_dir])
+      ChefConfig::Config.reset
+    end
+
+    config_context :data_collector do
+      default :url, nil
+      default :token, nil
+    end
+  end
+end

data/lib/chef_apply/error.rb

@@ -0,0 +1,108 @@
+#
+# 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 ChefApply
+  class Error < StandardError
+    attr_reader :id, :params
+    attr_accessor :show_stack, :show_log, :decorate
+    def initialize(id, *params)
+      @id = id
+      @params = params || []
+      @show_log = true
+      @show_stack = true
+      @decorate = true
+    end
+  end
+
+  class ErrorNoLogs < Error
+    def initialize(id, *params)
+      super
+      @show_log = false
+      @show_stack = false
+    end
+  end
+
+  class ErrorNoStack < Error
+    def initialize(id, *params)
+      super
+      @show_log = true
+      @show_stack = false
+    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 < ChefApply::ErrorNoLogs
+    attr_reader :jobs
+    def initialize(jobs)
+      super("CHEFMULTI001")
+      @jobs = jobs
+      @decorate = false
+    end
+  end
+
+  # 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
+      show_log = true
+      show_stack = true
+      case exception
+      when OpenSSL::SSL::SSLError
+        if exception.message =~ /SSL.*verify failed.*/
+          id = "CHEFNET002"
+          show_log = false
+          show_stack = false
+        end
+      when SocketError then id = "CHEFNET001"; show_log = false; show_stack = false
+      end
+      if id.nil?
+        exception
+      else
+        e = ChefApply::Error.new(id, exception.message)
+        e.show_log = show_log
+        e.show_stack = show_stack
+        e
+      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

data/lib/chef_apply/errors/ccr_failure_mapper.rb

@@ -0,0 +1,93 @@
+#
+# 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 "chef_apply/error"
+
+module ChefApply::Errors
+  class CCRFailureMapper
+    attr_reader :params
+
+    def initialize(exception, params)
+      @params = params
+      @cause_line = exception
+    end
+
+    def raise_mapped_exception!
+      if @cause_line.nil?
+        raise RemoteChefRunFailedToResolveError.new(params[:stdout], params[:stderr])
+      else
+        errid, *args = exception_args_from_cause()
+        if errid.nil?
+          raise RemoteChefClientRunFailedUnknownReason.new()
+        else
+          raise RemoteChefClientRunFailed.new(errid, *args)
+        end
+
+      end
+    end
+
+    # Ideally we will write a custom handler to package up data we care
+    # about and present it more directly  https://docs.chef.io/handlers.html
+    # For now, we'll just match the most common failures based on their
+    # messages.
+    def exception_args_from_cause
+      # Ordering is important below.  Some earlier tests are more detailed
+      # cases of things that will match more general tests further down.
+      case @cause_line
+      when /.*had an error:(.*:)\s+(.*$)/
+        # Some invalid property value cases, among others.
+        ["CHEFCCR002", $2]
+      when /.*Chef::Exceptions::ValidationFailed:\s+Option action must be equal to one of:\s+(.*)!\s+You passed :(.*)\./
+        # Invalid action - specialization of invalid property value, below
+        ["CHEFCCR003", $2, $1]
+      when /.*Chef::Exceptions::ValidationFailed:\s+(.*)/
+        # Invalid resource property value
+        ["CHEFCCR004", $1]
+      when /.*NameError: undefined local variable or method `(.+)' for cookbook.+/
+        # Invalid resource type in most cases
+        ["CHEFCCR005", $1]
+      when /.*NoMethodError: undefined method `(.+)' for cookbook.+/
+        # Invalid resource type in most cases
+        ["CHEFCCR005", $1]
+      when /.*undefined method `(.*)' for (.+)/
+        # Unknown resource property
+        ["CHEFCCR006", $1, $2]
+
+      # Below would catch the general form of most errors, but the
+      # message itself in those lines is not generally aligned
+      # with the UX we want to provide.
+      # when /.*Exception|Error.*:\s+(.*)/
+      else
+        nil
+      end
+    end
+
+    class RemoteChefClientRunFailed < ChefApply::ErrorNoLogs
+      def initialize(id, *args); super(id, *args); end
+    end
+
+    class RemoteChefClientRunFailedUnknownReason < ChefApply::ErrorNoStack
+      def initialize(); super("CHEFCCR099"); end
+    end
+
+    class RemoteChefRunFailedToResolveError < ChefApply::ErrorNoStack
+      def initialize(stdout, stderr); super("CHEFCCR001", stdout, stderr); end
+    end
+
+  end
+
+end