/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/puppetlabs/puppetlabs-concat/
=== Contact:
Puppetlabs, via our puppet-users@ mailing list.
puppetlabs-concat-1.0.0/README.markdown 000644 000765 000024 00000006502 12203005613 020272 0 ustar 00hunner staff 000000 000000 What is it?
===========
A Puppet module that can construct files from fragments.
Please see the comments in the various .pp files for details
as well as posts on my blog at http://www.devco.net/
Released under the Apache 2.0 licence
Usage:
------
If you wanted a /etc/motd file that listed all the major modules
on the machine. And that would be maintained automatically even
if you just remove the include lines for other modules you could
use code like below, a sample /etc/motd would be:
Puppet modules on this server:
-- Apache
-- MySQL
Local sysadmins can also append to the file by just editing /etc/motd.local
their changes will be incorporated into the puppet managed motd.
# class to setup basic motd, include on all nodes
class motd {
$motd = "/etc/motd"
concat{$motd:
owner => root,
group => root,
mode => '0644',
}
concat::fragment{"motd_header":
target => $motd,
content => "\nPuppet modules on this server:\n\n",
order => 01,
}
# local users on the machine can append to motd by just creating
# /etc/motd.local
concat::fragment{"motd_local":
target => $motd,
ensure => "/etc/motd.local",
order => 15
}
}
# used by other modules to register themselves in the motd
define motd::register($content="", $order=10) {
if $content == "" {
$body = $name
} else {
$body = $content
}
concat::fragment{"motd_fragment_$name":
target => "/etc/motd",
content => " -- $body\n"
}
}
# a sample apache module
class apache {
include apache::install, apache::config, apache::service
motd::register{"Apache": }
}
Detailed documentation of the class options can be found in the
manifest files.
Known Issues:
-------------
* Since puppet-concat now relies on a fact for the concat directory,
you will need to set up pluginsync = true on the [master] section of your
node's '/etc/puppet/puppet.conf' for at least the first run.
You have this issue if puppet fails to run on the client and you have
a message similar to
"err: Failed to apply catalog: Parameter path failed: File
paths must be fully qualified, not 'undef' at [...]/concat/manifests/setup.pp:44".
Contributors:
-------------
**Paul Elliot**
* Provided 0.24.8 support, shell warnings and empty file creation support.
**Chad Netzer**
* Various patches to improve safety of file operations
* Symlink support
**David Schmitt**
* Patch to remove hard coded paths relying on OS path
* Patch to use file{} to copy the resulting file to the final destination. This means Puppet client will show diffs and that hopefully we can change file ownerships now
**Peter Meier**
* Basedir as a fact
* Unprivileged user support
**Sharif Nassar**
* Solaris/Nexenta support
* Better error reporting
**Christian G. Warden**
* Style improvements
**Reid Vandewiele**
* Support non GNU systems by default
**Erik Dalén**
* Style improvements
**Gildas Le Nadan**
* Documentation improvements
**Paul Belanger**
* Testing improvements and Travis support
**Branan Purvine-Riley**
* Support Puppet Module Tool better
**Dustin J. Mitchell**
* Always include setup when using the concat define
**Andreas Jaggi**
* Puppet Lint support
**Jan Vansteenkiste**
* Configurable paths
Contact:
--------
puppet-users@ mailing list.
puppetlabs-concat-1.0.0/spec/ 000755 000765 000024 00000000000 12203005613 016520 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/spec/defines/ 000755 000765 000024 00000000000 12203005613 020135 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/spec/fixtures/ 000755 000765 000024 00000000000 12203005613 020371 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/spec/spec_helper.rb 000644 000765 000024 00000000064 12203005613 021336 0 ustar 00hunner staff 000000 000000 require 'puppetlabs_spec_helper/module_spec_helper'
puppetlabs-concat-1.0.0/spec/spec_helper_system.rb 000644 000765 000024 00000001230 12203005613 022736 0 ustar 00hunner staff 000000 000000 require 'rspec-system/spec_helper'
require 'rspec-system-puppet/helpers'
require 'rspec-system-serverspec/helpers'
include Serverspec::Helper::RSpecSystem
include Serverspec::Helper::DetectOS
include RSpecSystemPuppet::Helpers
RSpec.configure do |c|
# Project root
proj_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
# Enable colour
c.tty = true
c.include RSpecSystemPuppet::Helpers
# This is where we 'setup' the nodes before running our tests
c.before :suite do
# Install puppet
puppet_install
# Install modules and dependencies
puppet_module_install(:source => proj_root, :module_name => 'concat')
end
end
puppetlabs-concat-1.0.0/spec/system/ 000755 000765 000024 00000000000 12203005613 020044 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/spec/system/basic_spec.rb 000644 000765 000024 00000000705 12203005613 022466 0 ustar 00hunner staff 000000 000000 require 'spec_helper_system'
# Here we put the more basic fundamental tests, ultra obvious stuff.
describe "basic tests:" do
context 'make sure we have copied the module across' do
# No point diagnosing any more if the module wasn't copied properly
context shell 'ls /etc/puppet/modules/concat' do
its(:stdout) { should =~ /Modulefile/ }
its(:stderr) { should be_empty }
its(:exit_code) { should be_zero }
end
end
end
puppetlabs-concat-1.0.0/spec/system/concat_spec.rb 000644 000765 000024 00000002462 12203005613 022656 0 ustar 00hunner staff 000000 000000 require 'spec_helper_system'
describe 'basic concat test' do
context 'should run successfully' do
pp="
concat { '/tmp/file':
owner => root,
group => root,
mode => '0644',
}
concat::fragment { '1':
target => '/tmp/file',
content => '1',
order => '01',
}
concat::fragment { '2':
target => '/tmp/file',
content => '2',
order => '02',
}
"
context puppet_apply(pp) do
its(:stderr) { should be_empty }
its(:exit_code) { should_not == 1 }
its(:refresh) { should be_nil }
its(:stderr) { should be_empty }
its(:exit_code) { should be_zero }
end
describe file('/tmp/file') do
it { should be_file }
it { should contain '1' }
it { should contain '2' }
end
# Test that all the relevant bits exist on disk after it
# concats.
describe file('/var/lib/puppet/concat') do
it { should be_directory }
end
describe file('/var/lib/puppet/concat/_tmp_file') do
it { should be_directory }
end
describe file('/var/lib/puppet/concat/_tmp_file/fragments') do
it { should be_directory }
end
describe file('/var/lib/puppet/concat/_tmp_file/fragments.concat') do
it { should be_file }
end
end
end
puppetlabs-concat-1.0.0/spec/system/empty_spec.rb 000644 000765 000024 00000001136 12203005613 022542 0 ustar 00hunner staff 000000 000000 require 'spec_helper_system'
describe 'basic concat test' do
context 'should run successfully' do
pp="
concat { '/tmp/file':
owner => root,
group => root,
mode => '0644',
force => true,
}
"
context puppet_apply(pp) do
its(:stderr) { should be_empty }
its(:exit_code) { should_not == 1 }
its(:refresh) { should be_nil }
its(:stderr) { should be_empty }
its(:exit_code) { should be_zero }
end
describe file('/tmp/file') do
it { should be_file }
it { should_not contain '1\n2' }
end
end
end
puppetlabs-concat-1.0.0/spec/system/replace_spec.rb 000644 000765 000024 00000001420 12203005613 023013 0 ustar 00hunner staff 000000 000000 require 'spec_helper_system'
describe 'file should not replace' do
shell('echo "file exists" >> /tmp/file')
context 'should fail' do
pp="
concat { '/tmp/file':
owner => root,
group => root,
mode => '0644',
replace => false,
}
concat::fragment { '1':
target => '/tmp/file',
content => '1',
order => '01',
}
concat::fragment { '2':
target => '/tmp/file',
content => '2',
order => '02',
}
"
context puppet_apply(pp) do
its(:stderr) { should be_empty }
its(:exit_code) { should_not == 1 }
its(:refresh) { should be_nil }
its(:stderr) { should be_empty }
its(:exit_code) { should be_zero }
end
end
end
puppetlabs-concat-1.0.0/spec/system/warn_spec.rb 000644 000765 000024 00000001664 12203005613 022361 0 ustar 00hunner staff 000000 000000 require 'spec_helper_system'
describe 'basic concat test' do
context 'should run successfully' do
pp="
concat { '/tmp/file':
owner => root,
group => root,
mode => '0644',
warn => true,
}
concat::fragment { '1':
target => '/tmp/file',
content => '1',
order => '01',
}
concat::fragment { '2':
target => '/tmp/file',
content => '2',
order => '02',
}
"
context puppet_apply(pp) do
its(:stderr) { should be_empty }
its(:exit_code) { should_not == 1 }
its(:refresh) { should be_nil }
its(:stderr) { should be_empty }
its(:exit_code) { should be_zero }
end
describe file('/tmp/file') do
it { should be_file }
it { should contain '# This file is managed by Puppet. DO NOT EDIT.' }
it { should contain '1' }
it { should contain '2' }
end
end
end
puppetlabs-concat-1.0.0/spec/fixtures/manifests/ 000755 000765 000024 00000000000 12203005613 022362 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/spec/fixtures/manifests/site.pp 000644 000765 000024 00000000000 12203005613 023655 0 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/spec/defines/init_spec.rb 000644 000765 000024 00000004465 12203005613 022450 0 ustar 00hunner staff 000000 000000 require 'spec_helper'
describe 'concat' do
basedir = '/var/lib/puppet/concat'
let(:title) { '/etc/foo.bar' }
let(:facts) { {
:concat_basedir => '/var/lib/puppet/concat',
:id => 'root',
} }
let :pre_condition do
'include concat::setup'
end
directories = [
"#{basedir}/_etc_foo.bar",
"#{basedir}/_etc_foo.bar/fragments",
]
directories.each do |dirs|
it do
should contain_file(dirs).with({
'ensure' => 'directory',
'backup' => 'puppet',
'group' => 0,
'mode' => '0644',
'owner' => 'root',
})
end
end
files = [
"/etc/foo.bar",
"#{basedir}/_etc_foo.bar/fragments.concat",
]
files.each do |file|
it do
should contain_file(file).with({
'ensure' => 'present',
'backup' => 'puppet',
'group' => 0,
'mode' => '0644',
'owner' => 'root',
})
end
end
it do
should contain_exec("concat_/etc/foo.bar").with_command(
"#{basedir}/bin/concatfragments.sh " +
"-o #{basedir}/_etc_foo.bar/fragments.concat.out " +
"-d #{basedir}/_etc_foo.bar "
)
end
end
describe 'concat' do
basedir = '/var/lib/puppet/concat'
let(:title) { 'foobar' }
let(:target) { '/etc/foo.bar' }
let(:facts) { {
:concat_basedir => '/var/lib/puppet/concat',
:id => 'root',
} }
let :pre_condition do
'include concat::setup'
end
directories = [
"#{basedir}/foobar",
"#{basedir}/foobar/fragments",
]
directories.each do |dirs|
it do
should contain_file(dirs).with({
'ensure' => 'directory',
'backup' => 'puppet',
'group' => 0,
'mode' => '0644',
'owner' => 'root',
})
end
end
files = [
"foobar",
"#{basedir}/foobar/fragments.concat",
]
files.each do |file|
it do
should contain_file(file).with({
'ensure' => 'present',
'backup' => 'puppet',
'group' => 0,
'mode' => '0644',
'owner' => 'root',
})
end
end
it do
should contain_exec("concat_foobar").with_command(
"#{basedir}/bin/concatfragments.sh " +
"-o #{basedir}/foobar/fragments.concat.out " +
"-d #{basedir}/foobar "
)
end
end
# vim:sw=2:ts=2:expandtab:textwidth=79
puppetlabs-concat-1.0.0/manifests/fragment.pp 000644 000765 000024 00000003557 12203005613 021735 0 ustar 00hunner staff 000000 000000 # == 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=undef,
$source=undef,
$order=10,
$ensure = 'present',
$mode = '0644',
$owner = $::id,
$group = $concat::setup::root_group,
$backup = 'puppet') {
$safe_name = regsubst($name, '[/\n]', '_', 'GM')
$safe_target_name = regsubst($target, '[/\n]', '_', 'GM')
$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 $ensure {
'', 'absent', 'present', 'file', 'directory': {
if ! ($content or $source) {
crit('No content, source or symlink specified')
}
}
default: {
# do nothing, make puppet-lint happy
}
}
file{"${fragdir}/fragments/${order}_${safe_name}":
ensure => $ensure,
mode => $mode,
owner => $owner,
group => $group,
source => $source,
content => $content,
backup => $backup,
alias => "concat_fragment_${name}",
notify => Exec["concat_${target}"]
}
}
puppetlabs-concat-1.0.0/manifests/init.pp 000644 000765 000024 00000011440 12203005613 021063 0 ustar 00hunner staff 000000 000000 # == Define: concat
#
# 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'
# [*replace*]
# Whether to replace a file that already exists on the local system
#
# === 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 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',
$replace = true,
$gnu = undef,
$order='alpha',
$ensure_newline = false
) {
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'
$default_warn_message = '# This file is managed by Puppet. DO NOT EDIT.'
case $warn {
'true', true, yes, on: {
$warnmsg = $default_warn_message
}
'false', false, no, off: {
$warnmsg = ''
}
default: {
$warnmsg = $warn
}
}
$warnmsg_escaped = regsubst($warnmsg, "'", "'\\\\''", '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}")
}
}
case $order {
numeric: {
$orderflag = '-n'
}
alpha: {
$orderflag = ''
}
default: {
fail("Improper 'order' value given to concat: ${order}")
}
}
case $ensure_newline {
'true', true, yes, on: {
$newlineflag = '-l'
}
'false', false, no, off: {
$newlineflag = ''
}
default: {
fail("Improper 'ensure_newline' value given to concat: ${ensure_newline}")
}
}
File {
owner => $::id,
group => $group,
mode => $mode,
backup => $backup,
replace => $replace
}
file { $fragdir:
ensure => directory,
}
$source_real = $version ? {
24 => 'puppet:///concat/null',
default => undef,
}
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.concat":
ensure => present,
}
file { "${fragdir}/${concat_name}":
ensure => present,
}
file { $name:
ensure => present,
path => $path,
alias => "concat_${name}",
group => $group,
mode => $mode,
owner => $owner,
source => "${fragdir}/${concat_name}",
}
exec { "concat_${name}":
alias => "concat_${fragdir}",
command => "${concat::setup::concatdir}/bin/concatfragments.sh -o ${fragdir}/${concat_name} -d ${fragdir} ${warnflag} ${forceflag} ${orderflag} ${newlineflag}",
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} ${newlineflag}",
}
if $::id == 'root' {
Exec["concat_${name}"] {
user => root,
group => $group,
}
}
}
# vim:sw=2:ts=2:expandtab:textwidth=79
puppetlabs-concat-1.0.0/manifests/setup.pp 000644 000765 000024 00000003163 12203005613 021263 0 ustar 00hunner staff 000000 000000 # === Class: concat::setup
#
# Sets up the concat system.
#
# [$concatdir]
# is where the fragments live and is set on the fact concat_basedir.
# Since puppet should always manage files in $concatdir and they should
# not be deleted ever, /tmp is not an option.
#
# [$puppetversion]
# should be either 24 or 25 to enable a 24 compatible
# mode, in 24 mode you might see phantom notifies this is a side effect
# of the method we use to clear the fragments directory.
#
# The regular expression below will try to figure out your puppet version
# but this code will only work in 0.24.8 and newer.
#
# It also copies out the concatfragments.sh file to ${concatdir}/bin
#
class concat::setup {
$id = $::id
$root_group = $id ? {
root => 0,
default => $id
}
if $::concat_basedir {
$concatdir = $::concat_basedir
} else {
fail ("\$concat_basedir not defined. Try running again with pluginsync=true on the [master] section of your node's '/etc/puppet/puppet.conf'.")
}
$majorversion = regsubst($::puppetversion, '^[0-9]+[.]([0-9]+)[.][0-9]+$', '\1')
$fragments_source = $majorversion ? {
24 => 'puppet:///concat/concatfragments.sh',
default => 'puppet:///modules/concat/concatfragments.sh'
}
file{"${concatdir}/bin/concatfragments.sh":
owner => $id,
group => $root_group,
mode => '0755',
source => $fragments_source;
[ $concatdir, "${concatdir}/bin" ]:
ensure => directory,
owner => $id,
group => $root_group,
mode => '0750';
## Old versions of this module used a different path.
'/usr/local/bin/concatfragments.sh':
ensure => absent;
}
}
puppetlabs-concat-1.0.0/lib/facter/ 000755 000765 000024 00000000000 12203005613 017600 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/lib/facter/concat_basedir.rb 000644 000765 000024 00000000334 12203005613 023065 0 ustar 00hunner staff 000000 000000 # == Fact: concat_basedir
#
# A custom fact that sets the default location for fragments
#
# "${::vardir}/concat/"
#
Facter.add("concat_basedir") do
setcode do
File.join(Puppet[:vardir],"concat")
end
end
puppetlabs-concat-1.0.0/files/concatfragments.sh 000755 000765 000024 00000007523 12203005613 022414 0 ustar 00hunner staff 000000 000000 #!/bin/sh
# Script to concat files to a config file.
#
# Given a directory like this:
# /path/to/conf.d
# |-- fragments
# | |-- 00_named.conf
# | |-- 10_domain.net
# | `-- zz_footer
#
# The script supports a test option that will build the concat file to a temp location and
# use /usr/bin/cmp to verify if it should be run or not. This would result in the concat happening
# twice on each run but gives you the option to have an unless option in your execs to inhibit rebuilds.
#
# Without the test option and the unless combo your services that depend on the final file would end up
# restarting on each run, or in other manifest models some changes might get missed.
#
# OPTIONS:
# -o The file to create from the sources
# -d The directory where the fragments are kept
# -t Test to find out if a build is needed, basically concats the files to a temp
# location and compare with what's in the final location, return codes are designed
# for use with unless on an exec resource
# -w Add a shell style comment at the top of the created file to warn users that it
# is generated by puppet
# -f Enables the creation of empty output files when no fragments are found
# -n Sort the output numerically rather than the default alpha sort
#
# the command:
#
# concatfragments.sh -o /path/to/conffile.cfg -d /path/to/conf.d
#
# creates /path/to/conf.d/fragments.concat and copies the resulting
# file to /path/to/conffile.cfg. The files will be sorted alphabetically
# pass the -n switch to sort numerically.
#
# The script does error checking on the various dirs and files to make
# sure things don't fail.
OUTFILE=""
WORKDIR=""
TEST=""
FORCE=""
WARN=""
SORTARG=""
ENSURE_NEWLINE=""
PATH=/sbin:/usr/sbin:/bin:/usr/bin
## Well, if there's ever a bad way to do things, Nexenta has it.
## http://nexenta.org/projects/site/wiki/Personalities
unset SUN_PERSONALITY
while getopts "o:s:d:tnw:fl" options; do
case $options in
o ) OUTFILE=$OPTARG;;
d ) WORKDIR=$OPTARG;;
n ) SORTARG="-n";;
w ) WARNMSG="$OPTARG";;
f ) FORCE="true";;
t ) TEST="true";;
l ) ENSURE_NEWLINE="true";;
* ) echo "Specify output file with -o and fragments directory with -d"
exit 1;;
esac
done
# do we have -o?
if [ x${OUTFILE} = "x" ]; then
echo "Please specify an output file with -o"
exit 1
fi
# do we have -d?
if [ x${WORKDIR} = "x" ]; then
echo "Please fragments directory with -d"
exit 1
fi
# can we write to -o?
if [ -f ${OUTFILE} ]; then
if [ ! -w ${OUTFILE} ]; then
echo "Cannot write to ${OUTFILE}"
exit 1
fi
else
if [ ! -w `dirname ${OUTFILE}` ]; then
echo "Cannot write to `dirname ${OUTFILE}` to create ${OUTFILE}"
exit 1
fi
fi
# do we have a fragments subdir inside the work dir?
if [ ! -d "${WORKDIR}/fragments" ] && [ ! -x "${WORKDIR}/fragments" ]; then
echo "Cannot access the fragments directory"
exit 1
fi
# are there actually any fragments?
if [ ! "$(ls -A ${WORKDIR}/fragments)" ]; then
if [ x${FORCE} = "x" ]; then
echo "The fragments directory is empty, cowardly refusing to make empty config files"
exit 1
fi
fi
cd ${WORKDIR}
if [ "x${WARNMSG}" = "x" ]; then
: > "fragments.concat"
else
printf '%s\n' "$WARNMSG" > "fragments.concat"
fi
if [ x${ENSURE_NEWLINE} != x ]; then
find fragments/ -type f -follow -print0 | xargs -0 -I '{}' sh -c 'if [ -n "$(tail -c 1 < {} )" ]; then echo >> {} ; fi'
fi
# find all the files in the fragments directory, sort them numerically and concat to fragments.concat in the working dir
IFS_BACKUP=$IFS
IFS='
'
for fragfile in `find fragments/ -type f -follow | LANG=C sort ${SORTARG}`
do
cat $fragfile >> "fragments.concat"
done
IFS=$IFS_BACKUP
if [ x${TEST} = "x" ]; then
# This is a real run, copy the file to outfile
cp fragments.concat ${OUTFILE}
RETVAL=$?
else
# Just compare the result to outfile to help the exec decide
cmp ${OUTFILE} fragments.concat
RETVAL=$?
fi
exit $RETVAL
puppetlabs-concat-1.0.0/files/null/ 000755 000765 000024 00000000000 12203005613 017642 5 ustar 00hunner staff 000000 000000 puppetlabs-concat-1.0.0/files/null/.gitignore 000644 000765 000024 00000000000 12203005613 021620 0 ustar 00hunner staff 000000 000000