chef-apply 0.1.2 → 0.1.15

data/lib/chef_apply/temp_cookbook.rb

@@ -25,10 +25,7 @@ module ChefApply
   # 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
+    attr_reader :path, :descriptor, :from
     def initialize
       @path = Dir.mktmpdir("cw")
     end
@@ -40,12 +37,13 @@ module ChefApply
       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]
+        @descriptor = "#{cb[:name]}::#{cb[:recipe_name]}"
+        @from = "#{cb[:path]}"
         recipe_name = cb[:recipe_name]
+        cb_name = cb[: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
@@ -53,27 +51,32 @@ module ChefApply
         # 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"
+        recipe_name = File.basename(recipe, ext_name)
+        cb_name = "cw_recipe"
+        @descriptor = "#{recipe_name}"
+        @from = existing_recipe_path
         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)
+        generate_metadata(cb_name)
       end
+      generate_policyfile(cb_name, recipe_name)
     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.
+      @descriptor = "#{resource_type}[#{resource_name}]"
+      @from = "resource"
+
       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))
+        f.print(create_resource_definition(resource_type, resource_name, properties))
       end
       generate_metadata(name)
       generate_policyfile(name, recipe_name)
@@ -137,7 +140,7 @@ module ChefApply
       policy_file
     end
 
-    def create_resource(resource_type, resource_name, properties)
+    def create_resource_definition(resource_type, resource_name, properties)
       r = "#{resource_type} '#{resource_name}'"
       # lets format the properties into the correct syntax Chef expects
       unless properties.empty?
@@ -152,6 +155,14 @@ module ChefApply
       r
     end
 
+    def policyfile_lock_path
+      File.join(path, "Policyfile.lock.json")
+    end
+
+    def export_path
+      File.join(path, "export")
+    end
+
     class UnsupportedExtension < ChefApply::ErrorNoLogs
       def initialize(ext); super("CHEFVAL009", ext); end
     end

data/lib/chef_apply/text.rb

@@ -16,62 +16,30 @@
 #
 
 require "r18n-desktop"
+require "chef_apply/text/text_wrapper"
 
 # 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
+  module Text
+    def self._translation_path
+      @translation_path ||= File.join(File.dirname(__FILE__), "..", "..", "i18n")
     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|
+    def self.load
+      R18n.from_env(Text._translation_path)
+      R18n.extension_places << File.join(Text._translation_path, "errors")
+      t = R18n.get.t
+      t.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}"
+          TextWrapper.new(t.send(k, *args))
         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
 
+    # We need to do this when the class is loaded to avoid breaking a bunch of behaviors for now.
+    load
   end
+
 end

data/lib/chef_apply/text/text_wrapper.rb

@@ -0,0 +1,86 @@
+#
+# 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
+  module Text
+    # 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|
+          # Integer keys are not translatable - they're quantity indicators in the key that
+          # are instead sent as arguments. If we see one here, it means it was not correctly
+          # labeled as plural with !!pl in the parent key
+          if k.class == Integer
+            raise MissingPlural.new(@tree.instance_variable_get(:@path), k)
+          end
+          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
+
+      # TODO - make the checks for these conditions lint steps that run during build
+      #        instead of part of the shipped product.
+      class TextError < RuntimeError
+        attr_accessor :line
+        def set_call_context
+          # TODO - this can vary (8 isn't always right) - inspect
+          @line = caller(8, 1).first
+          if @line =~ /.*\/lib\/(.*\.rb):(\d+)/
+            @line = "File: #{$1} Line: #{$2}"
+          end
+        end
+      end
+
+      class InvalidKey < TextError
+        def initialize(path, terminus)
+          set_call_context
+          # 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
+
+      class MissingPlural < TextError
+        def initialize(path, terminus)
+          set_call_context
+          message = "i18n key #{path}.#{terminus} appears to reference a pluralization.\n"
+          message << "Please append the plural indicator '!!pl' to the end of #{path}.\n"
+          message << "Referenced from #{line}"
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/chef_apply/ui/error_printer.rb

@@ -21,6 +21,7 @@ require "chef_apply/error"
 require "chef_apply/config"
 require "chef_apply/text"
 require "chef_apply/ui/terminal"
+require "chef_apply/errors/standard_error_resolver"
 
 module ChefApply::UI
   class ErrorPrinter
@@ -36,7 +37,7 @@ module ChefApply::UI
     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)
+      unwrapped = ChefApply::Errors::StandardErrorResolver.unwrap_exception(e)
       if unwrapped.class == ChefApply::MultiJobFailure
         capture_multiple_failures(unwrapped)
       end
@@ -51,7 +52,7 @@ module ChefApply::UI
       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)
+          wrapped = ChefApply::Errors::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} ")

data/lib/chef_apply/ui/terminal.rb

@@ -47,11 +47,6 @@ module ChefApply
 
         def init(location)
           @location = location
-          # 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
-          Thread.report_on_exception = false
         end
 
         def write(msg)
@@ -63,9 +58,16 @@ module ChefApply
         end
 
         def render_parallel_jobs(header, jobs)
-          multispinner = TTY::Spinner::Multi.new("[:spinner] #{header}", output: @location)
+      # 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 = TTY::Spinner::Multi.new("[:spinner] #{header}", output: @location, hide_cursor: true, style: indent_style)
           jobs.each do |a|
-            multispinner.register(spinner_prefix(a.prefix)) do |spinner|
+            multispinner.register(spinner_prefix(a.prefix), hide_cursor: true) do |spinner|
               reporter = StatusReporter.new(spinner, prefix: a.prefix, key: :status)
               a.run(reporter)
             end
@@ -77,7 +79,7 @@ module ChefApply
         #      between render_job and render_parallel
         def render_job(msg, prefix: "", &block)
           klass = ChefApply::UI.const_get(ChefApply::Config.dev.spinner)
-          spinner = klass.new(spinner_prefix(prefix), output: @location)
+          spinner = klass.new(spinner_prefix(prefix), output: @location, hide_cursor: true)
           reporter = StatusReporter.new(spinner, prefix: prefix, key: :status)
           reporter.update(msg)
           spinner.run { yield(reporter) }

data/lib/chef_apply/version.rb

@@ -16,5 +16,5 @@
 #
 
 module ChefApply
-  VERSION = "0.1.2"
+  VERSION = "0.1.15"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-apply
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.15
 platform: ruby
 authors:
 - Chef Software, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-11 00:00:00.000000000 Z
+date: 2018-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-cli
@@ -320,19 +320,25 @@ files:
 - bin/chef-run
 - chef-apply.gemspec
 - i18n/en.yml
+- i18n/errors/en.yml
 - lib/chef_apply.rb
 - lib/chef_apply/action/base.rb
 - lib/chef_apply/action/converge_target.rb
+- lib/chef_apply/action/generate_local_policy.rb
+- lib/chef_apply/action/generate_temp_cookbook.rb
 - lib/chef_apply/action/install_chef.rb
 - lib/chef_apply/action/install_chef/base.rb
 - lib/chef_apply/action/install_chef/linux.rb
 - lib/chef_apply/action/install_chef/windows.rb
 - lib/chef_apply/action/reporter.rb
 - lib/chef_apply/cli.rb
-- lib/chef_apply/cli_options.rb
+- lib/chef_apply/cli/help.rb
+- lib/chef_apply/cli/options.rb
+- lib/chef_apply/cli/validation.rb
 - lib/chef_apply/config.rb
 - lib/chef_apply/error.rb
 - lib/chef_apply/errors/ccr_failure_mapper.rb
+- lib/chef_apply/errors/standard_error_resolver.rb
 - lib/chef_apply/file_fetcher.rb
 - lib/chef_apply/log.rb
 - lib/chef_apply/recipe_lookup.rb
@@ -345,6 +351,7 @@ files:
 - lib/chef_apply/telemeter/sender.rb
 - lib/chef_apply/temp_cookbook.rb
 - lib/chef_apply/text.rb
+- lib/chef_apply/text/text_wrapper.rb
 - lib/chef_apply/ui/error_printer.rb
 - lib/chef_apply/ui/plain_text_element.rb
 - lib/chef_apply/ui/terminal.rb

data/lib/chef_apply/cli_options.rb

@@ -1,145 +0,0 @@
-#
-# 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