bolt 0.21.1 → 0.21.2

data/vendored/puppet/lib/puppet/module_tool/applications/builder.rb

@@ -1,152 +0,0 @@
-require 'fileutils'
-require 'puppet/util/json'
-require 'puppet/file_system'
-require 'pathspec'
-require 'facter'
-
-module Puppet::ModuleTool
-  module Applications
-    class Builder < Application
-
-      def initialize(path, options = {})
-        @path = File.expand_path(path)
-        @pkg_path = File.join(@path, 'pkg')
-        super(options)
-      end
-
-      def run
-        # Disallow anything that invokes md5 to avoid un-friendly termination due to FIPS
-        raise _("Module building is prohibited in FIPS mode.") if Facter.value(:fips_enabled)
-
-        load_metadata!
-        create_directory
-        copy_contents
-        write_json
-        Puppet.notice _("Building %{path} for release") % { path: @path }
-        pack
-        relative = Pathname.new(archive_file).relative_path_from(Pathname.new(File.expand_path(Dir.pwd)))
-
-        # Return the Pathname object representing the path to the release
-        # archive just created. This return value is used by the module_tool
-        # face build action, and displayed to on the console using the to_s
-        # method.
-        #
-        # Example return value:
-        #
-        #   <Pathname:puppetlabs-apache/pkg/puppetlabs-apache-0.0.1.tar.gz>
-        #
-        relative
-      end
-
-      private
-
-      def archive_file
-        File.join(@pkg_path, "#{metadata.release_name}.tar.gz")
-      end
-
-      def pack
-        FileUtils.rm archive_file rescue nil
-
-        tar = Puppet::ModuleTool::Tar.instance
-        Dir.chdir(@pkg_path) do
-          tar.pack(metadata.release_name, archive_file)
-        end
-      end
-
-      def create_directory
-        FileUtils.mkdir(@pkg_path) rescue nil
-        if File.directory?(build_path)
-          FileUtils.rm_rf(build_path, :secure => true)
-        end
-        FileUtils.mkdir(build_path)
-      end
-
-      def ignored_files
-        if @ignored_files
-          return @ignored_files
-        else
-          pmtignore = File.join(@path, '.pmtignore')
-          gitignore = File.join(@path, '.gitignore')
-
-          if File.file? pmtignore
-            @ignored_files = PathSpec.new Puppet::FileSystem.read(pmtignore, :encoding => 'utf-8')
-          elsif File.file? gitignore
-            @ignored_files = PathSpec.new Puppet::FileSystem.read(gitignore, :encoding => 'utf-8')
-          else
-            @ignored_files = PathSpec.new
-          end
-        end
-      end
-
-      def copy_contents
-        symlinks = []
-        Find.find(File.join(@path)) do |path|
-          # because Find.find finds the path itself
-          if path == @path
-            next
-          end
-
-          # Needed because pathspec looks for a trailing slash in the path to
-          # determine if a path is a directory
-          path = path.to_s + '/' if File.directory? path
-
-          # if it matches, then prune it with fire
-          unless ignored_files.match_paths([path], @path).empty?
-            Find.prune
-          end
-
-          # don't copy all the Puppet ARTIFACTS
-          rel = Pathname.new(path).relative_path_from(Pathname.new(@path))
-          case rel.to_s
-          when *Puppet::ModuleTool::ARTIFACTS
-            Find.prune
-          end
-
-          # make dir tree, copy files, and add symlinks to the symlinks list
-          dest = "#{build_path}/#{rel.to_s}"
-          if File.directory? path
-            FileUtils.mkdir dest, :mode => File.stat(path).mode
-          elsif Puppet::FileSystem.symlink? path
-            symlinks << path
-          else
-            FileUtils.cp path, dest, :preserve => true
-          end
-        end
-
-        # send a message about each symlink and raise an error if they exist
-        unless symlinks.empty?
-          symlinks.each do |s|
-            s = Pathname.new s
-            mpath = Pathname.new @path
-            Puppet.warning _("Symlinks in modules are unsupported. Please investigate symlink %{from} -> %{to}.") % { from: s.relative_path_from(mpath), to: s.realpath.relative_path_from(mpath) }
-          end
-
-          raise Puppet::ModuleTool::Errors::ModuleToolError, _("Found symlinks. Symlinks in modules are not allowed, please remove them.")
-        end
-      end
-
-      def write_json
-        metadata_path = File.join(build_path, 'metadata.json')
-
-        if metadata.to_hash.include? 'checksums'
-          Puppet.warning _("A 'checksums' field was found in metadata.json. This field will be ignored and can safely be removed.")
-        end
-
-        # TODO: This may necessarily change the order in which the metadata.json
-        # file is packaged from what was written by the user.  This is a
-        # regretable, but required for now.
-        Puppet::FileSystem.open(metadata_path, nil, 'w:UTF-8') do |f|
-          f.write(metadata.to_json)
-        end
-
-        Puppet::FileSystem.open(File.join(build_path, 'checksums.json'), nil, 'wb') do |f|
-          f.write(Puppet::Util::Json.dump(Checksums.new(build_path), :pretty => true))
-        end
-      end
-
-      def build_path
-        @build_path ||= File.join(@pkg_path, metadata.release_name)
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/module_tool/skeleton/templates/generator/spec/spec_helper.rb

@@ -1 +0,0 @@
-require 'puppetlabs_spec_helper/module_spec_helper'

data/vendored/puppet/lib/puppet/provider/mailalias/aliases.rb

@@ -1,50 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:mailalias).provide(
-  :aliases,
-  :parent => Puppet::Provider::ParsedFile,
-  :default_target => "/etc/aliases",
-  :filetype => :flat
-) do
-  text_line :comment, :match => /^#/
-  text_line :blank, :match => /^\s*$/
-
-  record_line :aliases, :fields => %w{name recipient}, :separator => /\s*:\s*/, :block_eval => :instance do
-    def post_parse(record)
-      if record[:recipient]
-	record[:recipient] = record[:recipient].split(/\s*,\s*/).collect { |d| d.gsub(/^['"]|['"]$/, '') }
-      end
-      record
-    end
-
-    def process(line)
-      ret = {}
-      records = line.split(':',4)
-      ret[:name] = records[0].strip
-      if records.length == 4 and records[2].strip == 'include'
-	ret[:file] = records[3].strip
-      else
-	records = line.split(':',2)
-	ret[:recipient] = records[1].strip
-      end
-      ret
-    end
-
-    def to_line(record)
-      if record[:recipient]
-	dest = record[:recipient].collect do |d|
-	  # Quote aliases that have non-alpha chars
-	  if d =~ /[^-+\w@.]/
-	    '"%s"' % d
-	  else
-	    d
-	  end
-	end.join(",")
-	"#{record[:name]}: #{dest}"
-      elsif record[:file]
-	"#{record[:name]}: :include: #{record[:file]}"
-      end
-    end
-  end
-end
-

data/vendored/puppet/lib/puppet/provider/maillist/mailman.rb

@@ -1,108 +0,0 @@
-require 'puppet/provider/parsedfile'
-
-Puppet::Type.type(:maillist).provide(:mailman) do
-  if [ "CentOS", "RedHat", "Fedora" ].any? { |os|  Facter.value(:operatingsystem) == os }
-    commands :list_lists => "/usr/lib/mailman/bin/list_lists", :rmlist => "/usr/lib/mailman/bin/rmlist", :newlist => "/usr/lib/mailman/bin/newlist"
-    commands :mailman => "/usr/lib/mailman/mail/mailman"
-  else
-    # This probably won't work for non-Debian installs, but this path is sure not to be in the PATH.
-    commands :list_lists => "list_lists", :rmlist => "rmlist", :newlist => "newlist"
-    commands :mailman => "/var/lib/mailman/mail/mailman"
-  end
-
-  mk_resource_methods
-
-  # Return a list of existing mailman instances.
-  def self.instances
-    list_lists('--bare').
-      split("\n").
-      collect { |line| new(:ensure => :present, :name => line.strip) }
-  end
-
-  # Prefetch our list list, yo.
-  def self.prefetch(lists)
-    instances.each do |prov|
-      if list = lists[prov.name] || lists[prov.name.downcase]
-        list.provider = prov
-      end
-    end
-  end
-
-  def aliases
-    mailman = self.class.command(:mailman)
-    name = self.name.downcase
-    aliases = {name => "| #{mailman} post #{name}"}
-    %w{admin bounces confirm join leave owner request subscribe unsubscribe}.each do |address|
-      aliases["#{name}-#{address}"] = "| #{mailman} #{address} #{name}"
-    end
-    aliases
-  end
-
-  # Create the list.
-  def create
-    args = []
-    if val = @resource[:mailserver]
-      args << "--emailhost" << val
-    end
-    if val = @resource[:webserver]
-      args << "--urlhost" << val
-    end
-
-    args << self.name
-    if val = @resource[:admin]
-      args << val
-    else
-      raise ArgumentError, _("Mailman lists require an administrator email address")
-    end
-    if val = @resource[:password]
-      args << val
-    else
-      raise ArgumentError, _("Mailman lists require an administrator password")
-    end
-    newlist(*args)
-  end
-
-  # Delete the list.
-  def destroy(purge = false)
-    args = []
-    args << "--archives" if purge
-    args << self.name
-    rmlist(*args)
-  end
-
-  # Does our list exist already?
-  def exists?
-    properties[:ensure] != :absent
-  end
-
-  # Clear out the cached values.
-  def flush
-    @property_hash.clear
-  end
-
-  # Look up the current status.
-  def properties
-    if @property_hash.empty?
-      @property_hash = query || {:ensure => :absent}
-      @property_hash[:ensure] = :absent if @property_hash.empty?
-    end
-    @property_hash.dup
-  end
-
-  # Remove the list and its archives.
-  def purge
-    destroy(true)
-  end
-
-  # Pull the current state of the list from the full list.  We're
-  # getting some double entendre here....
-  def query
-    self.class.instances.each do |list|
-      if list.name == self.name or list.name.downcase == self.name
-        return list.properties
-      end
-    end
-    nil
-  end
-end
-

data/vendored/puppet/lib/puppet/provider/zfs/zfs.rb

@@ -1,108 +0,0 @@
-Puppet::Type.type(:zfs).provide(:zfs) do
-  desc "Provider for zfs."
-
-  commands :zfs => 'zfs'
-
-  def self.instances
-    zfs(:list, '-H').split("\n").collect do |line|
-      name, _used, _avail, _refer, _mountpoint = line.split(/\s+/)
-      new({:name => name, :ensure => :present})
-    end
-  end
-
-  def add_properties
-    properties = []
-    Puppet::Type.type(:zfs).validproperties.each do |property|
-      next if property == :ensure
-      if value = @resource[property] and value != ""
-        if property == :volsize
-          properties << "-V" << "#{value}"
-        else
-          properties << "-o" << "#{property}=#{value}"
-        end
-      end
-    end
-    properties
-  end
-
-  def create
-    zfs(*([:create] + add_properties + [@resource[:name]]))
-  end
-
-  def destroy
-    zfs(:destroy, @resource[:name])
-  end
-
-  def exists?
-    begin
-      zfs(:list, @resource[:name])
-      true
-    rescue Puppet::ExecutionFailure
-      false
-    end
-  end
-
-  # On FreeBSD zoned is called jailed
-  def container_property
-    case Facter.value(:operatingsystem)
-      when "FreeBSD"
-        :jailed
-      else
-        :zoned
-    end
-  end
-
-  PARAMETER_UNSET_OR_NOT_AVAILABLE = '-'
-
-  # https://docs.oracle.com/cd/E19963-01/html/821-1448/gbscy.html
-  # shareiscsi (added in build 120) was removed from S11 build 136
-  # aclmode was removed from S11 in build 139 but it may have been added back
-  # acltype is for ZFS on Linux, and allows disabling or enabling POSIX ACLs
-  # http://webcache.googleusercontent.com/search?q=cache:-p74K0DVsdwJ:developers.slashdot.org/story/11/11/09/2343258/solaris-11-released+&cd=13
-  [:aclmode, :acltype, :shareiscsi].each do |field|
-    # The zfs commands use the property value '-' to indicate that the
-    # property is not set. We make use of this value to indicate that the
-    # property is not set since it is not available. Conversely, if these
-    # properties are attempted to be unset, and resulted in an error, our
-    # best bet is to catch the exception and continue.
-    define_method(field) do
-      begin
-        zfs(:get, "-H", "-o", "value", field, @resource[:name]).strip
-      rescue
-        PARAMETER_UNSET_OR_NOT_AVAILABLE
-      end
-    end
-    define_method(field.to_s + "=") do |should|
-      begin
-        zfs(:set, "#{field}=#{should}", @resource[:name])
-      rescue
-      end
-    end
-  end
-
-  [:aclinherit, :atime, :canmount, :checksum,
-   :compression, :copies, :dedup, :devices, :exec, :logbias,
-   :mountpoint, :nbmand,  :primarycache, :quota, :readonly,
-   :recordsize, :refquota, :refreservation, :reservation,
-   :secondarycache, :setuid, :sharenfs, :sharesmb,
-   :snapdir, :version, :volsize, :vscan, :xattr].each do |field|
-    define_method(field) do
-      zfs(:get, "-H", "-o", "value", field, @resource[:name]).strip
-    end
-
-    define_method(field.to_s + "=") do |should|
-      zfs(:set, "#{field}=#{should}", @resource[:name])
-    end
-  end
-
-
-  define_method(:zoned) do
-    zfs(:get, "-H", "-o", "value", container_property, @resource[:name]).strip
-  end
-
-  define_method("zoned=") do |should|
-    zfs(:set, "#{container_property}=#{should}", @resource[:name])
-  end
-
-end
-

data/vendored/puppet/lib/puppet/provider/zone/solaris.rb

@@ -1,364 +0,0 @@
-Puppet::Type.type(:zone).provide(:solaris) do
-  desc "Provider for Solaris Zones."
-
-  commands :adm => "/usr/sbin/zoneadm", :cfg => "/usr/sbin/zonecfg"
-  defaultfor :osfamily => :solaris
-
-  mk_resource_methods
-
-  # Convert the output of a list into a hash
-  def self.line2hash(line)
-    fields = [:id, :name, :ensure, :path, :uuid, :brand, :iptype]
-    properties = Hash[fields.zip(line.split(':'))]
-
-    del_id = [:brand, :uuid]
-    # Configured but not installed zones do not have IDs
-    del_id << :id if properties[:id] == "-"
-    del_id.each { |p| properties.delete(p) }
-
-    properties[:ensure] = properties[:ensure].intern
-    properties[:iptype] = 'exclusive' if properties[:iptype] == 'excl'
-
-    properties
-  end
-
-  def self.instances
-    adm(:list, "-cp").split("\n").collect do |line|
-      new(line2hash(line))
-    end
-  end
-
-  def multi_conf(name, should, &action)
-    has = properties[name]
-    has = [] if !has || has == :absent
-    rms = has - should
-    adds = should - has
-    (rms.map{|o| action.call(:rm,o)} + adds.map{|o| action.call(:add,o)}).join("\n")
-  end
-
-  def self.def_prop(var, str)
-    define_method('%s_conf' % var.to_s) do |v|
-      str % v
-    end
-    define_method('%s=' % var.to_s) do |v|
-      setconfig self.send( ('%s_conf'% var).intern, v)
-    end
-  end
-
-  def self.def_multiprop(var, &conf)
-    define_method(var.to_s) do |v|
-      o = properties[var]
-      return '' if o.nil? or o == :absent
-      o.join(' ')
-    end
-    define_method('%s=' % var.to_s) do |v|
-      setconfig self.send( ('%s_conf'% var).intern, v)
-    end
-    define_method('%s_conf' % var.to_s) do |v|
-      multi_conf(var, v, &conf)
-    end
-  end
-
-  def_prop :iptype, "set ip-type=%s"
-  def_prop :autoboot, "set autoboot=%s"
-  def_prop :path, "set zonepath=%s"
-  def_prop :pool, "set pool=%s"
-  def_prop :shares, "add rctl\nset name=zone.cpu-shares\nadd value (priv=privileged,limit=%s,action=none)\nend"
-
-  def_multiprop :ip do |action, str|
-    interface, ip, defrouter = str.split(':')
-    case action
-    when :add
-      cmd = ["add net"]
-      cmd << "set physical=#{interface}" if interface
-      cmd << "set address=#{ip}" if ip
-      cmd << "set defrouter=#{defrouter}" if defrouter
-      cmd << "end"
-      cmd.join("\n")
-    when :rm
-      if ip
-        "remove net address=#{ip}"
-      elsif interface
-        "remove net physical=#{interface}"
-      else
-        raise ArgumentError, _("can not remove network based on default router")
-      end
-    else self.fail action
-    end
-  end
-
-  def_multiprop :dataset do |action, str|
-    case action
-    when :add; ['add dataset',"set name=#{str}",'end'].join("\n")
-    when :rm; "remove dataset name=#{str}"
-    else self.fail action
-    end
-  end
-
-  def_multiprop :inherit do |action, str|
-    case action
-    when :add; ['add inherit-pkg-dir', "set dir=#{str}",'end'].join("\n")
-    when :rm; "remove inherit-pkg-dir dir=#{str}"
-    else self.fail action
-    end
-  end
-
-  def my_properties
-    [:path, :iptype, :autoboot, :pool, :shares, :ip, :dataset, :inherit]
-  end
-
-  # Perform all of our configuration steps.
-  def configure
-    self.fail "Path is required" unless @resource[:path]
-    arr = ["create -b #{@resource[:create_args]}"]
-
-    # Then perform all of our configuration steps.  It's annoying
-    # that we need this much internal info on the resource.
-    self.resource.properties.each do |property|
-      next unless my_properties.include? property.name
-      method = (property.name.to_s + '_conf').intern
-      arr << self.send(method ,@resource[property.name]) unless property.safe_insync?(properties[property.name])
-    end
-    setconfig(arr.join("\n"))
-  end
-
-  def destroy
-    zonecfg :delete, "-F"
-  end
-
-  def add_cmd(cmd)
-    @cmds = [] if @cmds.nil?
-    @cmds << cmd
-  end
-
-  def exists?
-    properties[:ensure] != :absent
-  end
-
-  # We cannot use the execpipe in util because the pipe is not opened in
-  # read/write mode.
-  def exec_cmd(var)
-    # In bash, the exit value of the last command is the exit value of the
-    # entire pipeline
-    out = execute("echo \"#{var[:input]}\" | #{var[:cmd]}", :failonfail => false, :combine => true)
-    st = $?.exitstatus
-    {:out => out, :exit => st}
-  end
-
-  # Clear out the cached values.
-  def flush
-    return if @cmds.nil? || @cmds.empty?
-    str = (@cmds << "commit" << "exit").join("\n")
-    @cmds = []
-    @property_hash.clear
-
-    command = "#{command(:cfg)} -z #{@resource[:name]} -f -"
-    r = exec_cmd(:cmd => command, :input => str)
-    if r[:exit] != 0 or r[:out] =~ /not allowed/
-      raise ArgumentError, _("Failed to apply configuration")
-    end
-  end
-
-  def install
-    if @resource[:clone] # TODO: add support for "-s snapshot"
-      zoneadm :clone, @resource[:clone]
-    elsif @resource[:install_args]
-      zoneadm :install, @resource[:install_args].split(" ")
-    else
-      zoneadm :install
-    end
-  end
-
-  # Look up the current status.
-  def properties
-    if @property_hash.empty?
-      @property_hash = status || {}
-      if @property_hash.empty?
-        @property_hash[:ensure] = :absent
-      else
-        @resource.class.validproperties.each do |name|
-          @property_hash[name] ||= :absent
-        end
-      end
-    end
-    @property_hash.dup
-  end
-
-  # We need a way to test whether a zone is in process.  Our 'ensure'
-  # property models the static states, but we need to handle the temporary ones.
-  def processing?
-    hash = status
-    return false unless hash
-    ["incomplete", "ready", "shutting_down"].include? hash[:ensure]
-  end
-
-  # Collect the configuration of the zone. The output looks like:
-  # zonename: z1
-  # zonepath: /export/z1
-  # brand: native
-  # autoboot: true
-  # bootargs:
-  # pool:
-  # limitpriv:
-  # scheduling-class:
-  # ip-type: shared
-  # hostid:
-  # net:
-  #         address: 192.168.1.1
-  #         physical: eg0001
-  #         defrouter not specified
-  # net:
-  #         address: 192.168.1.3
-  #         physical: eg0002
-  #         defrouter not specified
-  #
-  def getconfig
-    output = zonecfg :info
-
-    name = nil
-    current = nil
-    hash = {}
-    output.split("\n").each do |line|
-      case line
-      when /^(\S+):\s*$/
-        name = $1
-        current = nil # reset it
-      when /^(\S+):\s*(\S+)$/
-        hash[$1.intern] = $2
-      when /^\s+(\S+):\s*(.+)$/
-        if name
-          hash[name] ||= []
-          unless current
-            current = {}
-            hash[name] << current
-          end
-          current[$1.intern] = $2
-        else
-          err "Ignoring '#{line}'"
-        end
-      else
-        debug "Ignoring zone output '#{line}'"
-      end
-    end
-
-    hash
-  end
-
-  # Execute a configuration string.  Can't be private because it's called
-  # by the properties.
-  def setconfig(str)
-    add_cmd str
-  end
-
-  def start
-    # Check the sysidcfg stuff
-    if cfg = @resource[:sysidcfg]
-      self.fail "Path is required" unless @resource[:path]
-      zoneetc = File.join(@resource[:path], "root", "etc")
-      sysidcfg = File.join(zoneetc, "sysidcfg")
-
-      # if the zone root isn't present "ready" the zone
-      # which makes zoneadmd mount the zone root
-      zoneadm :ready unless File.directory?(zoneetc)
-
-      unless Puppet::FileSystem.exist?(sysidcfg)
-        begin
-          # For compatibility reasons use System encoding for this OS file
-          # the manifest string is UTF-8 so this could result in conversion errors
-          # which should propagate to users
-          Puppet::FileSystem.open(sysidcfg, 0600, "w:#{Encoding.default_external.name}") do |f|
-            f.puts cfg
-          end
-        rescue => detail
-          puts detail.stacktrace if Puppet[:debug]
-          raise Puppet::Error, "Could not create sysidcfg: #{detail}", detail.backtrace
-        end
-      end
-    end
-
-    zoneadm :boot
-  end
-
-  # Return a hash of the current status of this zone.
-  def status
-    begin
-      output = adm "-z", @resource[:name], :list, "-p"
-    rescue Puppet::ExecutionFailure
-      return nil
-    end
-
-    main = self.class.line2hash(output.chomp)
-
-    # Now add in the configuration information
-    config_status.each do |name, value|
-      main[name] = value
-    end
-
-    main
-  end
-
-  def ready
-    zoneadm :ready
-  end
-
-  def stop
-    zoneadm :halt
-  end
-
-  def unconfigure
-    zonecfg :delete, "-F"
-  end
-
-  def uninstall
-    zoneadm :uninstall, "-F"
-  end
-
-  private
-
-  # Turn the results of getconfig into status information.
-  def config_status
-    config = getconfig
-    result = {}
-
-    result[:autoboot] = config[:autoboot] ? config[:autoboot].intern : :true
-    result[:pool] = config[:pool]
-    result[:shares] = config[:shares]
-    if dir = config["inherit-pkg-dir"]
-      result[:inherit] = dir.collect { |dirs| dirs[:dir] }
-    end
-    if datasets = config["dataset"]
-      result[:dataset] = datasets.collect { |dataset| dataset[:name] }
-    end
-    result[:iptype] = config[:'ip-type'] if config[:'ip-type']
-    if net = config["net"]
-      result[:ip] = net.collect do |params|
-        if params[:defrouter]
-          "#{params[:physical]}:#{params[:address]}:#{params[:defrouter]}"
-        elsif params[:address]
-          "#{params[:physical]}:#{params[:address]}"
-        else
-          params[:physical]
-        end
-      end
-    end
-
-    result
-  end
-
-  def zoneadm(*cmd)
-    adm("-z", @resource[:name], *cmd)
-  rescue Puppet::ExecutionFailure => detail
-    self.fail Puppet::Error, "Could not #{cmd[0]} zone: #{detail}", detail
-  end
-
-  def zonecfg(*cmd)
-    # You apparently can't get the configuration of the global zone (strictly in solaris11)
-    return "" if self.name == "global"
-    begin
-      cfg("-z", self.name, *cmd)
-    rescue Puppet::ExecutionFailure => detail
-      self.fail Puppet::Error, "Could not #{cmd[0]} zone: #{detail}", detail
-    end
-  end
-end
-