Puppet Class: cron

Defined in:

manifests/init.pp

Summary

This class wraps *cron::install* for ease of use

Overview

Examples:

simply include the module

include cron

include it but don’t manage the cron package

class { 'cron':
  manage_package => false,
}

Parameters:

• service_name (String[1]) —

  Can be set to define a different cron service name.

• package_name (String[1]) —

  Can be set to install a different cron package.

• manage_package (Boolean) (defaults to: true) —

  Can be set to disable package installation.

• manage_service (Boolean) (defaults to: true) —

  Defines if puppet should manage the service.

• service_ensure (Cron::Service_ensure) (defaults to: 'running') —

  Defines if the service should be running.

• service_enable (Cron::Service_enable) (defaults to: true) —

  Defines if the service should be enabled at boot.

• users_allow (Array[Cron::User]) (defaults to: []) —

  A list of users which are exclusively able to create, edit, display, or remove crontab files. Only used if manage_users_allow == true.

• users_deny (Array[Cron::User]) (defaults to: []) —

  A list of users which are prohibited from create, edit, display, or remove crontab files. Only used if manage_users_deny == true.

• manage_users_allow (Boolean) (defaults to: false) —

  If the /etc/cron.allow should be managed.

• manage_users_deny (Boolean) (defaults to: false) —

  If the /etc/cron.deny should be managed.

• allow_deny_mode (Stdlib::Filemode) (defaults to: '0644') —

  Specify the cron.allow/deny file mode.

• merge (Enum['deep', 'first', 'hash', 'unique']) (defaults to: 'hash') —

  The ‘lookup()` merge method to use with cron job hiera lookups.

• manage_crontab (Boolean) (defaults to: false) —

  Whether to manage /etc/crontab

• crontab_shell (Stdlib::Absolutepath) (defaults to: '/bin/bash') —

  The value for SHELL in /etc/crontab

• crontab_path (String[1]) (defaults to: '/sbin:/bin:/usr/sbin:/usr/bin') —

  The value for PATH in /etc/crontab

• crontab_mailto (String[1]) (defaults to: 'root') —

  The value for MAILTO in /etc/crontab

• crontab_home (Optional[Stdlib::Absolutepath]) (defaults to: undef) —

  The value for HOME in /etc/crontab

• crontab_run_parts (Cron::Run_parts) (defaults to: {}) —

  Define sadditional cron::run_parts resources

• file_mode (Stdlib::Filemode) (defaults to: '0644') —

  The file mode for the system crontab file

• dir_mode (Stdlib::Filemode) (defaults to: '0755') —

  The file mode for the cron directories

• package_ensure (Cron::Package_ensure) (defaults to: 'installed')

# File 'manifests/init.pp', line 30

class cron (
  String[1]            $service_name,
  String[1]            $package_name,
  Boolean              $manage_package          = true,
  Boolean              $manage_service          = true,
  Cron::Service_ensure $service_ensure          = 'running',
  Cron::Service_enable $service_enable          = true,
  Cron::Package_ensure $package_ensure          = 'installed',
  Array[Cron::User]    $users_allow             = [],
  Array[Cron::User]    $users_deny              = [],
  Boolean              $manage_users_allow      = false,
  Boolean              $manage_users_deny       = false,
  Stdlib::Filemode     $allow_deny_mode         = '0644',
  Enum['deep', 'first', 'hash', 'unique'] $merge = 'hash',
  Boolean              $manage_crontab          = false,
  Stdlib::Absolutepath $crontab_shell           = '/bin/bash',
  String[1]            $crontab_path            = '/sbin:/bin:/usr/sbin:/usr/bin',
  String[1]            $crontab_mailto          = 'root',
  Optional[Stdlib::Absolutepath] $crontab_home  = undef,
  Cron::Run_parts      $crontab_run_parts       = {},
  Stdlib::Filemode     $file_mode       = '0644',
  Stdlib::Filemode     $dir_mode        = '0755',
) {
  contain 'cron::install'
  contain 'cron::service'

  Class['cron::install'] -> Class['cron::service']

  # Manage cron.allow and cron.deny
  if $manage_users_allow {
    file { '/etc/cron.allow':
      ensure  => file,
      mode    => $allow_deny_mode,
      owner   => 'root',
      group   => 0,
      content => epp('cron/users.epp', { 'users' => $users_allow }),
    }
  }

  if $manage_users_deny {
    file { '/etc/cron.deny':
      ensure  => file,
      mode    => $allow_deny_mode,
      owner   => 'root',
      group   => 0,
      content => epp('cron/users.epp', { 'users' => $users_deny }),
    }
  }

  if $manage_crontab {
    # Template uses:
    # - $crontab_shell
    # - $crontab_path
    # - $crontab_mailto
    # - $crontab_home
    # - $crontab_run_parts
    file { '/etc/crontab':
      ensure  => file,
      owner   => 'root',
      group   => 0,
      mode    => $file_mode,
      content => epp('cron/crontab.epp'),
    }

    $crontab_run_parts.each |String $r, Hash $r_params| {
      file { "/etc/cron.${r}":
        ensure => directory,
        owner  => 'root',
        group  => 0,
        mode   => $dir_mode,
        before => File['/etc/crontab'],
      }
    }
  }

  # Create jobs from hiera

  $cron_job = lookup('cron::job', Optional[Hash], $merge, {})
  $cron_job.each | String $t, Hash $params | {
    cron::job { $t:
      * => $params,
    }
  }

  $cron_job_multiple = lookup('cron::job::multiple', Optional[Hash], $merge, {})
  $cron_job_multiple.each | String $t, Hash $params | {
    cron::job::multiple { $t:
      * => $params,
    }
  }

  $cron_hourly = lookup('cron::hourly', Optional[Hash], $merge, {})
  $cron_hourly.each | String $t, Hash $params | {
    cron::hourly { $t:
      * => $params,
    }
  }

  $cron_daily = lookup('cron::daily', Optional[Hash], $merge, {})
  $cron_daily.each | String $t, Hash $params | {
    cron::daily { $t:
      * => $params,
    }
  }

  $cron_weekly = lookup('cron::weekly', Optional[Hash], $merge, {})
  $cron_weekly.each | String $t, Hash $params | {
    cron::weekly { $t:
      * => $params,
    }
  }

  $cron_monthly = lookup('cron::monthly', Optional[Hash], $merge, {})
  $cron_monthly.each | String $t, Hash $params | {
    cron::monthly { $t:
      * => $params,
    }
  }
}