puppet 6.6.0-universal-darwin → 6.7.0-universal-darwin

data/lib/puppet/indirector/ssl_file.rb

@@ -139,17 +139,19 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     # All types serialized to disk contain only ASCII content:
     # * SSL::Key may be a .export(OpenSSL::Cipher::DES.new(:EDE3, :CBC), pass) or .to_pem
     # * All other classes are translated to strings by calling .to_pem
-
     if file_location
       Puppet.settings.setting(self.class.file_setting).open('w:ASCII') { |f| yield f }
-    elsif setting = self.class.directory_setting
-      begin
-        Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
-      rescue => detail
-        raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
-      end
     else
-      raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
+      setting = self.class.directory_setting
+      if setting
+        begin
+          Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
+        rescue => detail
+          raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
+        end
+      else
+        raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
+      end
     end
   end
 end

data/lib/puppet/indirector/terminus.rb

@@ -29,10 +29,13 @@ class Puppet::Indirector::Terminus
     def indirection=(name)
       if name.is_a?(Puppet::Indirector::Indirection)
         @indirection = name
-      elsif ind = Puppet::Indirector::Indirection.instance(name)
-        @indirection = ind
       else
-        raise ArgumentError, _("Could not find indirection instance %{name} for %{terminus}") % { name: name, terminus: self.name }
+        ind = Puppet::Indirector::Indirection.instance(name)
+        if ind
+          @indirection = ind
+        else
+          raise ArgumentError, _("Could not find indirection instance %{name} for %{terminus}") % { name: name, terminus: self.name }
+        end
       end
     end
 

data/lib/puppet/info_service.rb

@@ -2,6 +2,7 @@
 module Puppet::InfoService
   require 'puppet/info_service/class_information_service'
   require 'puppet/info_service/task_information_service'
+  require 'puppet/info_service/plan_information_service'
 
   def self.classes_per_environment(env_file_hash)
     Puppet::InfoService::ClassInformationService.new.classes_per_environment(env_file_hash)
@@ -14,4 +15,12 @@ module Puppet::InfoService
   def self.task_data(environment_name, module_name, task_name)
     Puppet::InfoService::TaskInformationService.task_data(environment_name, module_name, task_name)
   end
+
+  def self.plans_per_environment(environment_name)
+    Puppet::InfoService::PlanInformationService.plans_per_environment(environment_name)
+  end
+
+  def self.plan_data(environment_name, module_name, plan_name)
+    Puppet::InfoService::PlanInformationService.plan_data(environment_name, module_name, plan_name)
+  end
 end

data/lib/puppet/info_service/plan_information_service.rb

@@ -0,0 +1,36 @@
+class Puppet::InfoService::PlanInformationService
+  require 'puppet/module'
+
+  def self.plans_per_environment(environment_name)
+    # get the actual environment object, raise error if the named env doesn't exist
+    env = Puppet.lookup(:environments).get!(environment_name)
+    env.modules.map do |mod|
+      mod.plans.map do |plan|
+        {:module => {:name => plan.module.name}, :name => plan.name}
+      end
+    end.flatten
+  end
+
+  def self.plan_data(environment_name, module_name, plan_name)
+    # raise EnvironmentNotFound if applicable
+    Puppet.lookup(:environments).get!(environment_name)
+
+    pup_module = Puppet::Module.find(module_name, environment_name)
+    if pup_module.nil?
+      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
+                                            {module_name: module_name, environment_name: environment_name}
+    end
+
+    plan = pup_module.plans.find { |t| t.name == plan_name }
+    if plan.nil?
+      raise Puppet::Module::Plan::PlanNotFound.new(plan_name, module_name)
+    end
+
+    begin
+      plan.validate
+      {:metadata => plan.metadata, :files => plan.files}
+    rescue Puppet::Module::Plan::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
+  end
+end

data/lib/puppet/interface.rb

@@ -91,7 +91,8 @@ class Puppet::Interface
     #
     # @api public
     def [](name, version)
-      unless face = Puppet::Interface::FaceCollection[name, version]
+      face = Puppet::Interface::FaceCollection[name, version]
+      unless face
         # REVISIT (#18042) no sense in rechecking if version == :current -- josh
         if Puppet::Interface::FaceCollection[name, :current]
           raise Puppet::Error, "Could not find version #{version} of #{name}"

data/lib/puppet/interface/action.rb

@@ -277,12 +277,16 @@ WRAPPER
 
   def add_option(option)
     option.aliases.each do |name|
-      if conflict = get_option(name) then
+      conflict = get_option(name)
+      if conflict
         raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
             { option: option, conflict: conflict }
-      elsif conflict = @face.get_option(name) then
-        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{face}") %
-            { option: option, conflict: conflict, face: @face }
+      else
+        conflict = @face.get_option(name)
+        if conflict
+          raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{face}") %
+              { option: option, conflict: conflict, face: @face }
+        end
       end
     end
 
@@ -340,7 +344,8 @@ WRAPPER
     overlap = Hash.new do |h, k| h[k] = [] end
     unknown = []
     original.keys.each do |name|
-      if option = get_option(name) then
+      option = get_option(name)
+      if option
         canonical = option.name
         if result.has_key? canonical
           overlap[canonical] << name

data/lib/puppet/interface/action_manager.rb

@@ -22,7 +22,8 @@ module Puppet::Interface::ActionManager
     action = Puppet::Interface::ActionBuilder.build(self, name, &block)
 
     # REVISIT: (#18042) doesn't this mean we can't redefine the default action? -- josh
-    if action.default and current = get_default_action
+    current = get_default_action if action.default
+    if current
       raise "Actions #{current.name} and #{name} cannot both be default"
     end
 

data/lib/puppet/interface/documentation.rb

@@ -318,17 +318,20 @@ class Puppet::Interface
       when String then
         input.strip.split(/,/).map do |part|
           part = part.strip
-          if part =~ /^\d+$/ then
+          if part.match(/^\d+$/)
             part.to_i
-          elsif found = part.split(/-/) then
-            unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
+          else
+            found = part.split(/-/)
+            if found
+              unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
+                #TRANSLATORS 'copyright' is an attribute name and should not be translated
+                raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
+              end
+              Range.new(found[0].to_i, found[1].to_i)
+            else
               #TRANSLATORS 'copyright' is an attribute name and should not be translated
               raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
             end
-            Range.new(found[0].to_i, found[1].to_i)
-          else
-            #TRANSLATORS 'copyright' is an attribute name and should not be translated
-            raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
           end
         end
 

data/lib/puppet/interface/face_collection.rb

@@ -24,13 +24,16 @@ module Puppet::Interface::FaceCollection
 
     # If the version they request specifically doesn't exist, don't search
     # elsewhere.  Usually this will start from :current and all...
-    return nil unless face = self[name, version]
-    unless action = face.get_action(action_name)
+    face = self[name, version]
+    return nil unless face
+    action = face.get_action(action_name)
+    unless action
       # ...we need to search for it bound to an o{lder,ther} version.  Since
       # we load all actions when the face is first references, this will be in
       # memory in the known set of versions of the face.
       (@faces[name].keys - [ :current ]).sort.reverse_each do |vers|
-        break if action = @faces[name][vers].get_action(action_name)
+        action = @faces[name][vers].get_action(action_name)
+        break if action
       end
     end
 

data/lib/puppet/interface/option.rb

@@ -35,7 +35,8 @@ class Puppet::Interface::Option
         if Puppet.settings.include? name then
           raise ArgumentError, _("%{option}: already defined in puppet") % { option: item.inspect }
         end
-        if dup = dups[name] then
+        dup = dups[name]
+        if dup
           raise ArgumentError, _("%{option}: duplicates existing alias %{duplicate} in %{parent}") %
               { option: item.inspect, duplicate: dup.inspect, parent: @parent }
         else
@@ -84,7 +85,8 @@ class Puppet::Interface::Option
 
   # @api private
   def optparse_to_optionname(declaration)
-    unless found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/) then
+    found = declaration.match(/^-+(?:\[no-\])?([^ =]+)/)
+    unless found
       raise ArgumentError, _("Can't find a name in the declaration %{declaration}") % { declaration: declaration.inspect }
     end
     found.captures.first

data/lib/puppet/interface/option_manager.rb

@@ -53,14 +53,16 @@ module Puppet::Interface::OptionManager
     @options_hash ||= {}
 
     option.aliases.each do |name|
-      if conflict = get_option(name) then
+      conflict = get_option(name)
+      if conflict
         raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
             { option: option, conflict: conflict }
       end
 
       actions.each do |action|
         action = get_action(action)
-        if conflict = action.get_option(name) then
+        conflict = action.get_option(name)
+        if conflict
           raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{action}") %
               { option: option, conflict: conflict, action: action }
         end

data/lib/puppet/module.rb

@@ -1,5 +1,6 @@
 require 'puppet/util/logging'
 require 'puppet/module/task'
+require 'puppet/module/plan'
 require 'puppet/util/json'
 require 'semantic_puppet/gem_version'
 
@@ -60,7 +61,7 @@ class Puppet::Module
     SemanticPuppet::VersionRange.parse(range)
   end
 
-  attr_reader :name, :environment, :path, :metadata, :tasks
+  attr_reader :name, :environment, :path, :metadata, :tasks, :plans
   attr_writer :environment
 
   attr_accessor :dependencies, :forge_name
@@ -171,6 +172,39 @@ class Puppet::Module
     end
   end
 
+  def plans_directory
+    subpath("plans")
+  end
+
+  def plans
+    return @plans if instance_variable_defined?(:@plans)
+
+    if Puppet::FileSystem.exist?(plans_directory)
+      @plans = Puppet::Module::Plan.plans_in_module(self)
+    else
+      @plans = []
+    end
+  end
+
+  # This is a re-implementation of the Filetypes singular type method (e.g.
+  # `manifest('my/manifest.pp')`. We don't implement the full filetype "API" for
+  # plans.
+  def plan_file(name)
+    # If 'file' is nil then they're asking for the base path.
+    # This is used for things like fileserving.
+    if name
+      full_path = File.join(plans_directory, name)
+    else
+      full_path = plans_directory
+    end
+
+    if Puppet::FileSystem.exist?(full_path)
+      return full_path
+    else
+      return nil
+    end
+  end
+
   def license_file
     return @license_file if defined?(@license_file)
 

data/lib/puppet/module/plan.rb

@@ -0,0 +1,160 @@
+require 'puppet/util/logging'
+
+class Puppet::Module
+  class Plan
+    class Error < Puppet::Error
+      attr_accessor :kind, :details
+      def initialize(message, kind, details = nil)
+        super(message)
+        @details = details || {}
+        @kind = kind
+      end
+
+      def to_h
+        {
+          msg: message,
+          kind: kind,
+          details: details
+        }
+      end
+    end
+
+    class InvalidName < Error
+      def initialize(name, msg)
+        super(msg, 'puppet.plans/invalid-name')
+      end
+    end
+
+    class InvalidFile < Error
+      def initialize(msg)
+        super(msg, 'puppet.plans/invalid-file')
+      end
+    end
+
+    class InvalidPlan < Error
+    end
+    class InvalidMetadata < Error
+    end
+    class PlanNotFound < Error
+      def initialize(plan_name, module_name)
+        msg = _("Plan %{plan_name} not found in module %{module_name}.") %
+          {plan_name: plan_name, module_name: module_name}
+        super(msg, 'puppet.plans/plan-not-found', { 'name' => plan_name })
+      end
+    end
+
+    ALLOWED_EXTENSIONS = %w{.pp .yaml}
+    RESERVED_WORDS = %w{and application attr case class consumes default else
+        elsif environment false function if import in inherits node or private
+        produces site true type undef unless}
+    RESERVED_DATA_TYPES = %w{any array boolean catalogentry class collection
+        callable data default enum float hash integer numeric optional pattern
+        resource runtime scalar string struct tuple type undef variant}
+    MOUNTS = %w[lib files plans]
+
+    def self.is_plan_name?(name)
+      return true if name =~ /^[a-z][a-z0-9_]*$/
+      return false
+    end
+
+    # Determine whether a plan file has a legal name and extension
+    def self.is_plans_filename?(path)
+      name = File.basename(path, '.*')
+      ext = File.extname(path)
+      return [false, _("Plan names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")] unless is_plan_name?(name)
+      unless ALLOWED_EXTENSIONS.include? ext
+        return [false, _("Plan name cannot have extension %{ext}, must be .pp or .yaml") % { ext: ext }]
+      end
+      if RESERVED_WORDS.include?(name)
+        return [false, _("Plan name cannot be a reserved word, but was '%{name}'") % { name: name }]
+      end
+      if RESERVED_DATA_TYPES.include?(name)
+        return [false, _("Plan name cannot be a Puppet data type, but was '%{name}'") % { name: name }]
+      end
+      return [true]
+    end
+
+    # Executables list should contain the full path of all possible implementation files
+    def self.find_implementations(name, plan_files)
+      basename = name.split('::')[1] || 'init'
+
+      # If implementations isn't defined, then we use executables matching the
+      # plan name, and only one may exist.
+      implementations = plan_files.select { |impl| File.basename(impl, '.*') == basename }
+
+      # Select .pp before .yaml, since .pp comes before .yaml alphabetically.
+      chosen = implementations.sort.first
+
+      [{ "name" => File.basename(chosen), "path" => chosen }]
+    end
+    private_class_method :find_implementations
+
+    def self.find_files(name, plan_files)
+      find_implementations(name, plan_files)
+    end
+
+    def self.plans_in_module(pup_module)
+      # Search e.g. 'modules/<pup_module>/plans' for all plans
+      plan_files = Dir.glob(File.join(pup_module.plans_directory, '*'))
+        .keep_if { |f| valid, _ = is_plans_filename?(f); valid }
+
+      plans = plan_files.group_by { |f| plan_name_from_path(f) }
+
+      plans.map do |plan, plan_filenames|
+        new_with_files(pup_module, plan, plan_filenames)
+      end
+    end
+
+    attr_reader :name, :module, :metadata_file, :metadata
+
+    # file paths must be relative to the modules plan directory
+    def initialize(pup_module, plan_name, plan_files)
+      valid, reason = Puppet::Module::Plan.is_plans_filename?(plan_files.first)
+      unless valid
+        raise InvalidName.new(plan_name, reason)
+      end
+
+      name = plan_name == "init" ? pup_module.name : "#{pup_module.name}::#{plan_name}"
+
+      @module = pup_module
+      @name = name
+      @metadata_file = metadata_file
+      @plan_files = plan_files || []
+    end
+
+    def metadata
+      # Nothing to go here unless plans eventually support metadata.
+      @metadata ||= {}
+    end
+
+    def files
+      @files ||= self.class.find_files(@name, @plan_files)
+    end
+
+    def validate
+      files
+      true
+    end
+
+    def ==(other)
+      self.name == other.name &&
+      self.module == other.module
+    end
+
+    def environment_name
+      @module.environment.respond_to?(:name) ? @module.environment.name : 'production'
+    end
+    private :environment_name
+
+    def self.new_with_files(pup_module, name, plan_files)
+      Puppet::Module::Plan.new(pup_module, name, plan_files)
+    end
+    private_class_method :new_with_files
+
+    # Abstracted here so we can add support for subdirectories later
+    def self.plan_name_from_path(path)
+      return File.basename(path, '.*')
+    end
+    private_class_method :plan_name_from_path
+  end
+end