chef-apply 0.1.2 → 0.1.15

data/lib/chef_apply/cli/help.rb

@@ -0,0 +1,69 @@
+#
+# 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 ChefApply
+  class CLI
+    module Help
+      T = ChefApply::Text.cli
+      def show_help
+        UI::Terminal.output format_help
+      end
+
+      def format_help
+        help_text = banner.clone # This prevents us appending to the banner text
+        help_text << "\n"
+        help_text << format_flags
+      end
+
+      def format_flags
+        flag_text = "FLAGS:\n"
+        justify_length = 0
+        options.each_value do |spec|
+          justify_length = [justify_length, spec[:long].length + 4].max
+        end
+        options.sort.to_h.each_value do |flag_spec|
+          short = flag_spec[:short] || "  "
+          short = short[0, 2] # We only want the flag portion, not the capture portion (if present)
+          if short == "  "
+            short = "    "
+          else
+            short = "#{short}, "
+          end
+          flags = "#{short}#{flag_spec[:long]}"
+          flag_text << "    #{flags.ljust(justify_length)}    "
+          ml_padding = " " * (justify_length + 8)
+          first = true
+          flag_spec[:description].split("\n").each do |d|
+            flag_text << ml_padding unless first
+            first = false
+            flag_text << "#{d}\n"
+          end
+        end
+        flag_text
+      end
+
+      def usage
+        T.usage
+      end
+
+      def show_version
+        require "chef_apply/version"
+        UI::Terminal.output T.version.show(ChefApply::VERSION)
+      end
+    end
+  end
+end

data/lib/chef_apply/cli/options.rb

@@ -0,0 +1,147 @@
+#
+# 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
+  class CLI
+    module Options
+
+      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
+
+        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
+end

data/lib/chef_apply/cli/validation.rb

@@ -0,0 +1,99 @@
+#
+# 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/error"
+
+module ChefApply
+  class CLI
+    module Validation
+      PROPERTY_MATCHER = /^([a-zA-Z0-9_]+)=(.+)$/
+      CB_MATCHER = '[\w\-]+'
+
+      # The first param is always hostname. Then we either have
+      # 1. A recipe designation
+      # 2. A resource type and resource name followed by any properties
+      def validate_params(params)
+        if params.size < 2
+          raise OptionValidationError.new("CHEFVAL002", self)
+        end
+        if params.size == 2
+          # Trying to specify a recipe to run remotely, no properties
+          cb = params[1]
+          if File.exist?(cb)
+            # This is a path specification, and we know it is valid
+          elsif cb =~ /^#{CB_MATCHER}$/ || cb =~ /^#{CB_MATCHER}::#{CB_MATCHER}$/
+            # They are specifying a cookbook as 'cb_name' or 'cb_name::recipe'
+          else
+            raise OptionValidationError.new("CHEFVAL004", self, cb)
+          end
+        elsif params.size >= 3
+          properties = params[3..-1]
+          properties.each do |property|
+            unless property =~ PROPERTY_MATCHER
+              raise OptionValidationError.new("CHEFVAL003", self, property)
+            end
+          end
+        end
+      end
+
+      # Convert properties in the form k1=v1,k2=v2,kn=vn
+      # into a hash, while validating correct form and format
+      def properties_from_string(string_props)
+        properties = {}
+        string_props.each do |a|
+          key, value = PROPERTY_MATCHER.match(a)[1..-1]
+          value = transform_property_value(value)
+          properties[key] = value
+        end
+        properties
+      end
+
+      # Incoming properties are always read as a string from the command line.
+      # Depending on their type we should transform them so we do not try and pass
+      # a string to a resource property that expects an integer or boolean.
+      def transform_property_value(value)
+        case value
+        when /^0/
+          # when it is a zero leading value like "0777" don't turn
+          # it into a number (this is a mode flag)
+          value
+        when /^\d+$/
+          value.to_i
+        when /(^(\d+)(\.)?(\d+)?)|(^(\d+)?(\.)(\d+))/
+          value.to_f
+        when /true/i
+          true
+        when /false/i
+          false
+        else
+          value
+        end
+      end
+    end
+
+    class OptionValidationError < ChefApply::ErrorNoLogs
+      attr_reader :command
+      def initialize(id, calling_command, *args)
+        super(id, *args)
+        # TODO - this is getting cumbersome - move them to constructor options hash in base
+        @decorate = false
+        @command = calling_command
+      end
+    end
+  end
+
+end

data/lib/chef_apply/error.rb

@@ -53,7 +53,7 @@ module ChefApply
     end
   end
 
-  class MultiJobFailure < ChefApply::ErrorNoLogs
+  class MultiJobFailure < ErrorNoLogs
     attr_reader :jobs
     def initialize(jobs)
       super("CHEFMULTI001")
@@ -62,47 +62,8 @@ module ChefApply
     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
+  # Provide a base type for internal usage errors that should not leak out
+  # but may anyway.
+  class APIError < Error
   end
-
 end

data/lib/chef_apply/errors/standard_error_resolver.rb

@@ -0,0 +1,45 @@
+module ChefApply
+  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
+        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
+end

data/lib/chef_apply/startup.rb

@@ -18,6 +18,8 @@ require "chef_apply/config"
 require "chef_apply/text"
 require "chef_apply/ui/terminal"
 require "chef_apply/telemeter/sender"
+require "chef/log"
+require "chef/config"
 module ChefApply
   class Startup
     attr_reader :argv
@@ -41,6 +43,9 @@ module ChefApply
       # are required.
       setup_workstation_user_directories
 
+      # Customize behavior of Ruby and any gems around error handling
+      setup_error_handling
+
       # Startup tasks that may change behavior based on configuration value
       # must be run after load_config
       load_config
@@ -120,6 +125,17 @@ module ChefApply
       FileUtils.mkdir_p(Config.telemetry_path)
     end
 
+    def setup_error_handling
+      # In Ruby 2.5+ threads print out to stdout when they raise an exception. This is an agressive
+      # attempt to ensure debugging information is not lost, but in our case it is not necessary
+      # because we handle all the errors ourself. So we disable this to keep output clean.
+      # See https://ruby-doc.org/core-2.5.0/Thread.html#method-c-report_on_exception
+      #
+      # We set this globally so that it applies to all threads we create - we never want any non-UI thread
+      # to render error output to the terminal.
+      Thread.report_on_exception = false
+    end
+
     def load_config
       path = custom_config_path
       Config.custom_location(path) unless path.nil?
@@ -145,6 +161,12 @@ module ChefApply
     def setup_logging
       ChefApply::Log.setup(Config.log.location, Config.log.level.to_sym)
       ChefApply::Log.info("Initialized logger")
+
+      ChefConfig.logger = ChefApply::Log
+      # Setting the config isn't enough, we need to ensure the logger is initialized
+      # or automatic initialization will still go to stdout
+      Chef::Log.init(ChefApply::Log)
+      Chef::Log.level = ChefApply::Log.level
     end
 
     def start_chef_apply