freighthop 0.3.3 → 0.4.0

data/modules/concat/manifests/fragment.pp

@@ -1,52 +1,112 @@
+# == Define: concat::fragment
+#
 # Puts a file fragment into a directory previous setup using concat
 #
-# OPTIONS:
-#   - target    The file that these fragments belong to
-#   - content   If present puts the content into the file
-#   - source    If content was not specified, use the source
-#   - order     By default all files gets a 10_ prefix in the directory
-#               you can set it to anything else using this to influence the
-#               order of the content in the file
-#   - ensure    Present/Absent or destination to a file to include another file
-#   - mode      Mode for the file
-#   - owner     Owner of the file
-#   - group     Owner of the file
-#   - backup    Controls the filebucketing behavior of the final file and
-#               see File type reference for its use.  Defaults to 'puppet'
-define concat::fragment($target, $content='', $source='', $order=10, $ensure = 'present', $mode = '0644', $owner = $::id, $group = $concat::setup::root_group, $backup = 'puppet') {
-  $safe_name = regsubst($name, '/', '_', 'G')
-  $safe_target_name = regsubst($target, '/', '_', 'G')
-  $concatdir = $concat::setup::concatdir
-  $fragdir = "${concatdir}/${safe_target_name}"
-
-  # if content is passed, use that, else if source is passed use that
-  # if neither passed, but $ensure is in symlink form, make a symlink
-  case $content {
-    '': {
-      case $source {
-        '': {
-          case $ensure {
-            '', 'absent', 'present', 'file', 'directory': {
-              crit('No content, source or symlink specified')
-            }
-            default: {
-              #do nothing, make puppet-lint happy.
-            }
-          }
-        }
-        default: { File{ source => $source } }
-      }
-    }
-    default: { File{ content => $content } }
-  }
-
-  file{"${fragdir}/fragments/${order}_${safe_name}":
-    ensure => $ensure,
-    mode   => $mode,
-    owner  => $owner,
-    group  => $group,
-    backup => $backup,
-    alias  => "concat_fragment_${name}",
-    notify => Exec["concat_${target}"]
+# === Options:
+#
+# [*target*]
+#   The file that these fragments belong to
+# [*content*]
+#   If present puts the content into the file
+# [*source*]
+#   If content was not specified, use the source
+# [*order*]
+#   By default all files gets a 10_ prefix in the directory you can set it to
+#   anything else using this to influence the order of the content in the file
+# [*ensure*]
+#   Present/Absent or destination to a file to include another file
+# [*mode*]
+#   Deprecated
+# [*owner*]
+#   Deprecated
+# [*group*]
+#   Deprecated
+# [*backup*]
+#   Deprecated
+#
+define concat::fragment(
+    $target,
+    $content = undef,
+    $source  = undef,
+    $order   = 10,
+    $ensure  = 'present',
+    $mode    = undef,
+    $owner   = undef,
+    $group   = undef,
+    $backup  = undef
+) {
+  validate_string($target)
+  if ! ($ensure in [ 'present', 'absent' ]) {
+    warning('Passing a value other than \'present\' or \'absent\' as the $ensure parameter to concat::fragment is deprecated.  If you want to use the content of a file as a fragment please use the $source parameter.')
+  }
+  validate_string($content)
+  if !(is_string($source) or is_array($source)) {
+    fail('$source is not a string or an Array.')
+  }
+  validate_string($order)
+  if $mode {
+    warning('The $mode parameter to concat::fragment is deprecated and has no effect')
+  }
+  if $owner {
+    warning('The $owner parameter to concat::fragment is deprecated and has no effect')
+  }
+  if $group {
+    warning('The $group parameter to concat::fragment is deprecated and has no effect')
+  }
+  if $backup {
+    warning('The $backup parameter to concat::fragment is deprecated and has no effect')
+  }
+
+  include concat::setup
+
+  $safe_name        = regsubst($name, '[/:\n]', '_', 'GM')
+  $safe_target_name = regsubst($target, '[/:\n]', '_', 'GM')
+  $concatdir        = $concat::setup::concatdir
+  $fragdir          = "${concatdir}/${safe_target_name}"
+
+  # The file type's semantics are problematic in that ensure => present will
+  # not over write a pre-existing symlink.  We are attempting to provide
+  # backwards compatiblity with previous concat::fragment versions that
+  # supported the file type's ensure => /target syntax
+
+  # be paranoid and only allow the fragment's file resource's ensure param to
+  # be file, absent, or a file target
+  $safe_ensure = $ensure ? {
+    ''        => 'file',
+    undef     => 'file',
+    'file'    => 'file',
+    'present' => 'file',
+    'absent'  => 'absent',
+    default   => $ensure,
+  }
+
+  # if it looks line ensure => /target syntax was used, fish that out
+  if ! ($ensure in ['', 'present', 'absent', 'file' ]) {
+    $ensure_target = $ensure
+  }
+
+  # the file type's semantics only allows one of: ensure => /target, content,
+  # or source
+  if ($ensure_target and $source) or
+    ($ensure_target and $content) or
+    ($source and $content) {
+    fail('You cannot specify more than one of $content, $source, $ensure => /target')
+  }
+
+  if ! ($content or $source or $ensure_target) {
+    crit('No content, source or symlink specified')
+  }
+
+  # punt on group ownership until some point in the distant future when $::gid
+  # can be relied on to be present
+  file { "${fragdir}/fragments/${order}_${safe_name}":
+    ensure  => $safe_ensure,
+    owner   => $::id,
+    mode    => '0640',
+    source  => $source,
+    content => $content,
+    backup  => false,
+    alias   => "concat_fragment_${name}",
+    notify  => Exec["concat_${target}"]
   }
 }

data/modules/concat/manifests/init.pp

@@ -1,249 +1,230 @@
-# A system to construct files using fragments from other files or templates.
+# == Define: concat
 #
-# This requires at least puppet 0.25 to work correctly as we use some
-# enhancements in recursive directory management and regular expressions
-# to do the work here.
-#
-# USAGE:
-# The basic use case is as below:
-#
-# concat{"/etc/named.conf":
-#    notify => Service["named"]
-# }
-#
-# concat::fragment{"foo.com_config":
-#    target  => "/etc/named.conf",
-#    order   => 10,
-#    content => template("named_conf_zone.erb")
-# }
-#
-# # add a fragment not managed by puppet so local users
-# # can add content to managed file
-# concat::fragment{"foo.com_user_config":
-#    target  => "/etc/named.conf",
-#    order   => 12,
-#    ensure  => "/etc/named.conf.local"
-# }
-#
-# This will use the template named_conf_zone.erb to build a single
-# bit of config up and put it into the fragments dir.  The file
-# will have an number prefix of 10, you can use the order option
-# to control that and thus control the order the final file gets built in.
-#
-# You can also specify a path and use a different name for your resources:
-#
-# # You can make this something dynamic, based on whatever parameters your
-# # module/class for example.
-# $vhost_file = '/etc/httpd/vhosts/01-my-vhost.conf'
-#
-# concat{'apache-vhost-myvhost':
-#   path => $vhost_file,
-# }
-#
-# # We don't care where the file is located, just what to put in it.
-# concat::fragment {'apache-vhost-myvhost-main':
-#   target  => 'apache-vhost-myvhost',
-#   content => '<virtualhost *:80>',
-#   order   => 01,
-# }
-#
-# concat::fragment {'apache-vhost-myvhost-close':
-#   target  => 'apache-vhost-myvhost',
-#   content => '</virtualhost>',
-#   order   => 99,
-# }
-#
-#
-# SETUP:
-# The class concat::setup uses the fact concat_basedir to define the variable
-# $concatdir, where all the temporary files and fragments will be
-# durably stored. The fact concat_basedir will be set up on the client to
-# <Puppet[:vardir]>/concat, so you will be able to run different setup/flavours
-# of puppet clients.
-# However, since this requires the file lib/facter/concat_basedir.rb to be
-# deployed on the clients, so you will have to set "pluginsync = true" on
-# both the master and client, at least for the first run.
-#
-# There's some regular expression magic to figure out the puppet version but
-# if you're on an older 0.24 version just set $puppetversion = 24
-#
-# DETAIL:
-# We use a helper shell script called concatfragments.sh that gets placed
-# in <Puppet[:vardir]>/concat/bin to do the concatenation.  While this might
-# seem more complex than some of the one-liner alternatives you might find on
-# the net we do a lot of error checking and safety checks in the script to avoid
-# problems that might be caused by complex escaping errors etc.
-#
-# LICENSE:
-# Apache Version 2
-#
-# LATEST:
-# http://github.com/ripienaar/puppet-concat/
-#
-# CONTACT:
-# R.I.Pienaar <rip@devco.net>
-# Volcane on freenode
-# @ripienaar on twitter
-# www.devco.net
-
-
 # Sets up so that you can use fragments to build a final config file,
 #
-# OPTIONS:
-#  - path       The path to the final file. Use this in case you want to
-#               differentiate between the name of a resource and the file path.
-#               Note: Use the name you provided in the target of your
-#               fragments.
-#  - mode       The mode of the final file
-#  - owner      Who will own the file
-#  - group      Who will own the file
-#  - force      Enables creating empty files if no fragments are present
-#  - warn       Adds a normal shell style comment top of the file indicating
-#               that it is built by puppet
-#  - backup     Controls the filebucketing behavior of the final file and
-#               see File type reference for its use.  Defaults to 'puppet'
-#
-# ACTIONS:
-#  - Creates fragment directories if it didn't exist already
-#  - Executes the concatfragments.sh script to build the final file, this
-#    script will create directory/fragments.concat.   Execution happens only
-#    when:
-#    * The directory changes
-#    * fragments.concat != final destination, this means rebuilds will happen
-#      whenever someone changes or deletes the final file.  Checking is done
-#      using /usr/bin/cmp.
-#    * The Exec gets notified by something else - like the concat::fragment
-#      define
-#  - Copies the file over to the final destination using a file resource
+# === Options:
+#
+# [*ensure*]
+#   Present/Absent
+# [*path*]
+#   The path to the final file. Use this in case you want to differentiate
+#   between the name of a resource and the file path.  Note: Use the name you
+#   provided in the target of your fragments.
+# [*owner*]
+#   Who will own the file
+# [*group*]
+#   Who will own the file
+# [*mode*]
+#   The mode of the final file
+# [*force*]
+#   Enables creating empty files if no fragments are present
+# [*warn*]
+#   Adds a normal shell style comment top of the file indicating that it is
+#   built by puppet
+# [*force*]
+# [*backup*]
+#   Controls the filebucketing behavior of the final file and see File type
+#   reference for its use.  Defaults to 'puppet'
+# [*replace*]
+#   Whether to replace a file that already exists on the local system
+# [*order*]
+# [*ensure_newline*]
+# [*gnu*]
+#   Deprecated
+#
+# === Actions:
+# * Creates fragment directories if it didn't exist already
+# * Executes the concatfragments.sh script to build the final file, this
+#   script will create directory/fragments.concat.   Execution happens only
+#   when:
+#   * The directory changes
+#   * fragments.concat != final destination, this means rebuilds will happen
+#     whenever someone changes or deletes the final file.  Checking is done
+#     using /usr/bin/cmp.
+#   * The Exec gets notified by something else - like the concat::fragment
+#     define
+# * Copies the file over to the final destination using a file resource
+#
+# === Aliases:
+#
+# * The exec can notified using Exec["concat_/path/to/file"] or
+#   Exec["concat_/path/to/directory"]
+# * The final file can be referenced as File["/path/to/file"] or
+#   File["concat_/path/to/file"]
 #
-# ALIASES:
-#  - The exec can notified using Exec["concat_/path/to/file"] or
-#    Exec["concat_/path/to/directory"]
-#  - The final file can be referened as File["/path/to/file"] or
-#    File["concat_/path/to/file"]
 define concat(
-  $path = $name,
-  $owner = $::id,
-  $group = $concat::setup::root_group,
-  $mode = '0644',
-  $warn = false,
-  $force = false,
-  $backup = 'puppet',
-  $gnu = undef,
-  $order='alpha'
+  $ensure         = 'present',
+  $path           = $name,
+  $owner          = undef,
+  $group          = undef,
+  $mode           = '0644',
+  $warn           = false,
+  $force          = false,
+  $backup         = 'puppet',
+  $replace        = true,
+  $order          = 'alpha',
+  $ensure_newline = false,
+  $gnu            = undef
 ) {
+  validate_re($ensure, '^present$|^absent$')
+  validate_absolute_path($path)
+  validate_string($owner)
+  validate_string($group)
+  validate_string($mode)
+  if ! (is_string($warn) or $warn == true or $warn == false) {
+    fail('$warn is not a string or boolean')
+  }
+  validate_bool($force)
+  validate_string($backup)
+  validate_bool($replace)
+  validate_re($order, '^alpha$|^numeric$')
+  validate_bool($ensure_newline)
+  if $gnu {
+    warning('The $gnu parameter to concat is deprecated and has no effect')
+  }
+
   include concat::setup
 
-  $safe_name   = regsubst($name, '/', '_', 'G')
-  $concatdir   = $concat::setup::concatdir
-  $version     = $concat::setup::majorversion
-  $fragdir     = "${concatdir}/${safe_name}"
-  $concat_name = 'fragments.concat.out'
+  $safe_name            = regsubst($name, '[/:]', '_', 'G')
+  $concatdir            = $concat::setup::concatdir
+  $fragdir              = "${concatdir}/${safe_name}"
+  $concat_name          = 'fragments.concat.out'
+  $script_command       = $concat::setup::script_command
   $default_warn_message = '# This file is managed by Puppet. DO NOT EDIT.'
+  $bool_warn_message    = 'Using stringified boolean values (\'true\', \'yes\', \'on\', \'false\', \'no\', \'off\') to represent boolean true/false as the $warn parameter to concat is deprecated and will be treated as the warning message in a future release'
 
   case $warn {
-    'true', true, yes, on: {
-      $warnmsg = $default_warn_message
+    true: {
+      $warn_message = $default_warn_message
+    }
+    'true', 'yes', 'on': {
+      warning($bool_warn_message)
+      $warn_message = $default_warn_message
     }
-    'false', false, no, off: {
-      $warnmsg = ''
+    false: {
+      $warn_message = ''
+    }
+    'false', 'no', 'off': {
+      warning($bool_warn_message)
+      $warn_message = ''
     }
     default: {
-      $warnmsg = $warn
+      $warn_message = $warn
     }
   }
 
-  $warnmsg_escaped = regsubst($warnmsg, "'", "'\\\\''", 'G')
+  $warnmsg_escaped = regsubst($warn_message, '\'', '\'\\\'\'', 'G')
   $warnflag = $warnmsg_escaped ? {
     ''      => '',
     default => "-w '${warnmsg_escaped}'"
   }
 
-  case $force {
-    'true', true, yes, on: {
-      $forceflag = '-f'
-    }
-    'false', false, no, off: {
-      $forceflag = ''
-    }
-    default: {
-      fail("Improper 'force' value given to concat: ${force}")
-    }
+  $forceflag = $force ? {
+    true  => '-f',
+    false => '',
   }
 
-  case $order {
-    numeric: {
-      $orderflag = '-n'
-    }
-    alpha: {
-      $orderflag = ''
-    }
-    default: {
-      fail("Improper 'order' value given to concat: ${order}")
-    }
+  $orderflag = $order ? {
+    'numeric' => '-n',
+    'alpha'   => '',
   }
 
-  File {
-    owner  => $::id,
-    group  => $group,
-    mode   => $mode,
-    backup => $backup
+  $newlineflag = $ensure_newline ? {
+    true  => '-l',
+    false => '',
   }
 
-  file { $fragdir:
-    ensure => directory,
+  File {
+    backup  => false,
   }
 
-  $source_real = $version ? {
-    24      => 'puppet:///concat/null',
-    default => undef,
-  }
+  if $ensure == 'present' {
+    file { $fragdir:
+      ensure => directory,
+      mode   => '0750',
+    }
 
-  file { "${fragdir}/fragments":
-    ensure   => directory,
-    force    => true,
-    ignore   => ['.svn', '.git', '.gitignore'],
-    notify   => Exec["concat_${name}"],
-    purge    => true,
-    recurse  => true,
-    source   => $source_real,
-  }
+    file { "${fragdir}/fragments":
+      ensure  => directory,
+      mode    => '0750',
+      force   => true,
+      ignore  => ['.svn', '.git', '.gitignore'],
+      notify  => Exec["concat_${name}"],
+      purge   => true,
+      recurse => true,
+    }
 
-  file { "${fragdir}/fragments.concat":
-    ensure   => present,
-  }
+    file { "${fragdir}/fragments.concat":
+      ensure => present,
+      mode   => '0640',
+    }
 
-  file { "${fragdir}/${concat_name}":
-    ensure   => present,
-  }
+    file { "${fragdir}/${concat_name}":
+      ensure => present,
+      mode   => '0640',
+    }
 
-  file { $name:
-    ensure   => present,
-    path     => $path,
-    alias    => "concat_${name}",
-    group    => $group,
-    mode     => $mode,
-    owner    => $owner,
-    source   => "${fragdir}/${concat_name}",
-  }
+    file { $name:
+      ensure  => present,
+      owner   => $owner,
+      group   => $group,
+      mode    => $mode,
+      replace => $replace,
+      path    => $path,
+      alias   => "concat_${name}",
+      source  => "${fragdir}/${concat_name}",
+      backup  => $backup,
+    }
 
-  exec { "concat_${name}":
-    alias       => "concat_${fragdir}",
-    command     => "${concat::setup::concatdir}/bin/concatfragments.sh -o ${fragdir}/${concat_name} -d ${fragdir} ${warnflag} ${forceflag} ${orderflag}",
-    notify      => File[$name],
-    require     => [
-      File[$fragdir],
-      File["${fragdir}/fragments"],
-      File["${fragdir}/fragments.concat"],
-    ],
-    subscribe   => File[$fragdir],
-    unless      => "${concat::setup::concatdir}/bin/concatfragments.sh -o ${fragdir}/${concat_name} -d ${fragdir} -t ${warnflag} ${forceflag} ${orderflag}",
-  }
+    # remove extra whitespace from string interpolation to make testing easier
+    $command = strip(regsubst("${script_command} -o ${fragdir}/${concat_name} -d ${fragdir} ${warnflag} ${forceflag} ${orderflag} ${newlineflag}", '\s+', ' ', 'G'))
+
+    # if puppet is running as root, this exec should also run as root to allow
+    # the concatfragments.sh script to potentially be installed in path that
+    # may not be accessible by a target non-root owner.
+    exec { "concat_${name}":
+      alias     => "concat_${fragdir}",
+      command   => $command,
+      notify    => File[$name],
+      subscribe => File[$fragdir],
+      unless    => "${command} -t",
+      path      => $::path,
+      require   => [
+        File[$fragdir],
+        File["${fragdir}/fragments"],
+        File["${fragdir}/fragments.concat"],
+      ],
+    }
+  } else {
+    file { [
+      $fragdir,
+      "${fragdir}/fragments",
+      "${fragdir}/fragments.concat",
+      "${fragdir}/${concat_name}"
+    ]:
+      ensure => absent,
+      force  => true,
+    }
+
+    file { $name:
+      ensure => absent,
+      backup => $backup,
+    }
+
+    $absent_exec_command = $::kernel ? {
+      'windows' => 'cmd.exe /c exit 0',
+      default   => 'true',
+    }
+
+    $absent_exec_path = $::kernel ? {
+      'windows' => $::path,
+      default   => '/bin:/usr/bin',
+    }
 
-  if $::id == 'root' {
-    Exec["concat_${name}"] {
-      user  => root,
-      group => $group,
+    exec { "concat_${name}":
+      alias   => "concat_${fragdir}",
+      command => $absent_exec_command,
+      path    => $absent_exec_path
     }
   }
 }