kosmos/chef
8
3
Fork 0
Code Issues 34 Pull Requests 3 Projects 2 Activity

Vendor the external cookbooks

Browse Source 
Knife-Zero doesn't include Berkshelf support, so vendoring everything in
the repo is convenient again
This commit is contained in:
Greg Karékinian
2019-10-13 19:17:42 +02:00
parent f4bfe31ac1
commit a32f34b408
1245 changed files with 100630 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
cookbooks/logrotate/LICENSE Normal file
View File

@@ -0,0 +1,203 @@
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2009-2013, Chef Software, Inc.
Copyright 2015-2016, Steven Danna
Copyright 2016, Bloomberg Finance L.P.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

11
cookbooks/logrotate/Makefile Normal file
View File

@@ -0,0 +1,11 @@
all: delivery
travis: debug_version_info all
debug_version_info:
/opt/chefdk/embedded/bin/chef --version
/opt/chefdk/embedded/bin/cookstyle --version
/opt/chefdk/embedded/bin/foodcritic --version
delivery:
/opt/chefdk/bin/chef exec delivery local all

232
cookbooks/logrotate/README.md Normal file
View File

@@ -0,0 +1,232 @@
# logrotate Cookbook
[![Build Status](https://secure.travis-ci.org/stevendanna/logrotate.png?branch=master)](http://travis-ci.org/stevendanna/logrotate)
Manages the logrotate package and provides a definition to manage
application specific logrotate configuration.
## Requirements
### Platforms
Should work on any platform that includes a 'logrotate' package and
writes logrotate configuration to /etc/logrotate.d. Tested on Ubuntu
and Centos.
### Chef
- Chef 12.5+
### Cookbooks
- none
## Recipes
### global
Generates and controls a global `/etc/logrotate.conf` file that will
include additional files generated by the `logrotate_app` definition
(see below). The contents of the configuration file is controlled
through node attributes under `node['logrotate']['global']`. The
default attributes are based on the configuration from the Ubuntu
logrotate package.
To define a valueless directive (e.g. `compress`, `copy`) simply add
an attribute named for the directive with a truthy value:
```ruby
node['logrotate']['global']['compress'] = 'any value here'
```
Note that defining a valueless directive with a falsey value will not
make it false, but will remove it:
```ruby
# Removes a defaulted 'compress' directive; does not add a 'nocompress' directive.
node.override['logrotate']['global']['compress'] = false
```
To fully override a booleanish directive like `compress`, you should
probably remove the positive form and add the negative form:
```ruby
node.override['logrotate']['global']['compress'] = false
node.override['logrotate']['global']['nocompress'] = true
```
The same is true of frequency directives; to be certain the frequency
directive you want is included in the global configuration, you should
override the ones you don't want as false:
```ruby
%w[ daily weekly yearly ].each do |freq|
node.override['logrotate']['global'][freq] = false
end
node.override['logrotate']['global']['monthly'] = true
```
To define a parameter with a value (e.g. `create`, `mail`) add an
attribute with the desired value:
```ruby
node['logrotate']['global']['create'] = '0644 root adm'
```
To define a path stanza in the global configuration (generally
unneeded because of the `logrotate_app` definition) just add an
attribute with the path as the name and a hash containing directives
and parameters as described above:
```ruby
node['logrotate']['global']['/var/log/wtmp'] = {
'missingok' => true,
'monthly' => true,
'create' => '0660 root utmp',
'rotate' => 1
}
```
`firstaction`, `prerotate`, `postrotate`, and `lastaction` scripts can
be defined either as arrays of the lines to put in the script or
multiline strings:
```ruby
node['logrotate']['global']['/var/log/foo/*.log'] = {
'missingok' => true,
'monthly' => true,
'create' => '0660 root adm',
'rotate' => 1,
'prerotate' => ['service foo start_rotate', 'logger started foo service log rotation'],
'postrotate' => <<-EOF
service foo end_rotate
logger completed foo service log rotation
EOF
}
```
Resources
-----------
### logrotate_app
This resource can be used to drop off customized logrotate config
files on a per application basis.
The resource takes the following properties:
- `path`: specifies a single path (string) or multiple paths (array)
that should have logrotation stanzas created in the config file. No
default, this must be specified.
- `cookbook`: The cookbook that continues the template for
logrotate_app config definitions. By default this is `logrotate`.
Users can provide their own template by setting this attribute to
point at a different cookbook.
- `template_name`: sets the template source, default is
"logrotate.erb".
- `template_mode`: the mode to create the logrotate template with
(default: "0644")
- `template_owner`: the owner of the logrotate template (default:
"root")
- `template_group`: the group of the logrotate template (default:
"root")
- `frequency`: sets the frequency for rotation. Default value is
'weekly'. Valid values are: hourly, daily, weekly, monthly, yearly,
see the logrotate man page for more information. Note that usually
logrotate is configured to be run by cron daily. You have to change
this configuration and run logrotate hourly to be able to really
rotate logs hourly. Hourly rotation requires logrotate v3.8.5 or
higher.
- `options`: Any logrotate configuration option that doesn't specify a
value. See the logrotate(8) manual page of v3.9.2 or earlier for
details.
In addition to these properties, any logrotate option that takes a
parameter can be used as a logrotate_app property. For example, to set
the `rotate` option you can use a resource declaration such as:
```ruby
logrotate_app 'tomcat-myapp' do
path '/var/log/tomcat/myapp.log'
frequency 'daily'
rotate 30
create '644 root adm'
end
```
See the logrotate(8) manual page of v3.9.2 or earlier for the list of
available options.
## Usage
The default recipe will ensure logrotate is always up to date.
To create application specific logrotate configs, use the
`logrotate_app` definition. For example, to rotate logs for a tomcat
application named myapp that writes its log file to
`/var/log/tomcat/myapp.log`:
```ruby
logrotate_app 'tomcat-myapp' do
path '/var/log/tomcat/myapp.log'
frequency 'daily'
rotate 30
create '644 root adm'
end
```
To rotate multiple logfile paths, specify the path as an array:
```ruby
logrotate_app 'tomcat-myapp' do
path ['/var/log/tomcat/myapp.log', '/opt/local/tomcat/catalina.out']
frequency 'daily'
create '644 root adm'
rotate 7
end
```
To specify which logrotate options, specify the options as an array:
```ruby
logrotate_app 'tomcat-myapp' do
path '/var/log/tomcat/myapp.log'
options ['missingok', 'delaycompress', 'notifempty']
frequency 'daily'
rotate 30
create '644 root adm'
end
```
## License & Authors
- Author:: Steven Danna (<steve@chef.io>)
- Author:: Scott M. Likens (<scott@likens.us>)
- Author:: Joshua Timberman (<joshua@chef.io>)
```text
Copyright 2009, Scott M. Likens
Copyright 2011-2012, Chef Software, Inc.
Copyright 2016, Steven Danna
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

55
cookbooks/logrotate/attributes/default.rb Normal file
View File

@@ -0,0 +1,55 @@
#
# Cookbook:: logrotate
# Attribute:: default
#
# Copyright:: 2013-2017, Chef Software, Inc
# Copyright:: 2015-2017, Steven Danna
# Copyright:: 2016-2017, Bloomberg Finance L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
default['logrotate']['package'] = {
'name' => 'logrotate',
'source' => nil,
'version' => nil,
'provider' => nil,
'action' => :upgrade,
}
default['logrotate']['directory'] = '/etc/logrotate.d'
default['logrotate']['cron']['install'] = platform?('solaris2') || platform?('aix')
default['logrotate']['cron']['name'] = 'logrotate'
default['logrotate']['cron']['command'] = '/usr/sbin/logrotate /etc/logrotate.conf'
default['logrotate']['cron']['minute'] = 35
default['logrotate']['cron']['hour'] = 2
default['logrotate']['global'] = {
'weekly' => true,
'rotate' => 4,
'create' => '',
'/var/log/wtmp' => {
'missingok' => true,
'monthly' => true,
'create' => '0664 root utmp',
'rotate' => 1,
},
'/var/log/btmp' => {
'missingok' => true,
'monthly' => true,
'create' => '0660 root utmp',
'rotate' => 1,
},
}

102
cookbooks/logrotate/chefignore Normal file
View File

@@ -0,0 +1,102 @@
# Put files/directories that should be ignored in this file when uploading
# to a chef-server or supermarket.
# Lines that start with '# ' are comments.
# OS generated files #
######################
.DS_Store
Icon?
nohup.out
ehthumbs.db
Thumbs.db
# SASS #
########
.sass-cache
# EDITORS #
###########
\#*
.#*
*~
*.sw[a-z]
*.bak
REVISION
TAGS*
tmtags
*_flymake.*
*_flymake
*.tmproj
.project
.settings
mkmf.log
## COMPILED ##
##############
a.out
*.o
*.pyc
*.so
*.com
*.class
*.dll
*.exe
*/rdoc/
# Testing #
###########
.watchr
.rspec
spec/*
spec/fixtures/*
test/*
features/*
examples/*
Guardfile
Procfile
.kitchen*
.rubocop.yml
spec/*
Rakefile
.travis.yml
.foodcritic
.codeclimate.yml
# SCM #
#######
.git
*/.git
.gitignore
.gitmodules
.gitconfig
.gitattributes
.svn
*/.bzr/*
*/.hg/*
*/.svn/*
# Berkshelf #
#############
Berksfile
Berksfile.lock
cookbooks/*
tmp
# Cookbooks #
#############
CONTRIBUTING*
CHANGELOG*
TESTING*
MAINTAINERS.toml
# Strainer #
############
Colanderfile
Strainerfile
.colander
.strainer
# Vagrant #
###########
.vagrant
Vagrantfile

85
cookbooks/logrotate/libraries/logrotate_config.rb Normal file
View File

@@ -0,0 +1,85 @@
#
# Cookbook:: logrotate
# Library:: CookbookLogrotate
#
# Copyright:: 2013-2017, Chef
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# Helper module for Logrotate configuration module CookbookLogrotate
module CookbookLogrotate
DIRECTIVES = %w(compress copy copytruncate daily dateext
dateyesterday delaycompress hourly ifempty mailfirst maillast
missingok monthly nocompress nocopy nocopytruncate nocreate nocreateolddir
nodelaycompress nodateext nomail nomissingok noolddir
nosharedscripts noshred notifempty renamecopy sharedscripts shred weekly
yearly).freeze unless const_defined?(:DIRECTIVES)
VALUES = %w(compresscmd uncompresscmd compressext compressoptions
create createolddir dateformat include mail extension maxage minsize maxsize
rotate size shredcycles start tabooext su olddir).freeze unless const_defined?(:VALUES)
SCRIPTS = %w(firstaction prerotate postrotate lastaction preremove).freeze unless const_defined?(:SCRIPTS)
DIRECTIVES_AND_VALUES_AND_SCRIPTS = DIRECTIVES + VALUES + SCRIPTS unless const_defined?(:DIRECTIVES_AND_VALUES_AND_SCRIPTS)
# Helper class for creating configurations
class LogrotateConfiguration
attr_reader :directives, :values, :scripts, :paths
class << self
def from_hash(hash)
new(hash)
end
def directives_from(hash)
hash.select { |k, v| DIRECTIVES.include?(k) && v }.keys
end
def values_from(hash)
hash.select { |k| VALUES.include?(k) }
end
def paths_from(hash)
hash.select { |k| !DIRECTIVES_AND_VALUES_AND_SCRIPTS.include?(k) }.each_with_object({}) do |(path, config), accum_paths|
accum_paths[path] = {
'directives' => directives_from(config),
'values' => values_from(config),
'scripts' => scripts_from(config),
}
end
end
def scripts_from(hash)
defined_scripts = hash.select { |k| SCRIPTS.include?(k) }
defined_scripts.each_with_object({}) do |(script, lines), accum_scripts|
accum_scripts[script] = if lines.respond_to?(:join)
lines.join("\n")
else
lines
end
end
end
end
private
def initialize(hash)
@directives = LogrotateConfiguration.directives_from(hash)
@values = LogrotateConfiguration.values_from(hash)
@scripts = LogrotateConfiguration.scripts_from(hash)
@paths = LogrotateConfiguration.paths_from(hash)
end
end
end

11
cookbooks/logrotate/libraries/matchers.rb Normal file
View File

@@ -0,0 +1,11 @@
if defined?(ChefSpec)
ChefSpec.define_matcher :logrotate_app
def enable_logrotate_app(resource)
ChefSpec::Matchers::ResourceMatcher.new(:logrotate_app, :enable, resource)
end
def disable_logrotate_app(resource)
ChefSpec::Matchers::ResourceMatcher.new(:logrotate_app, :disable, resource)
end
end

60
cookbooks/logrotate/metadata.json Normal file
View File

@@ -0,0 +1,60 @@
{
"name": "logrotate",
"description": "Installs logrotate package and provides a definition for logrotate configs",
"long_description": "Installs the logrotate package, manages /etc/logrotate.conf, and provides a logrotate_app definition.",
"maintainer": "Steven Danna",
"maintainer_email": "steve@chef.io",
"license": "Apache 2.0",
"platforms": {
"amazon": ">= 0.0.0",
"centos": ">= 0.0.0",
"debian": ">= 0.0.0",
"fedora": ">= 0.0.0",
"redhat": ">= 0.0.0",
"scientific": ">= 0.0.0",
"solaris2": ">= 0.0.0",
"ubuntu": ">= 0.0.0"
},
"dependencies": {
},
"recommendations": {
},
"suggestions": {
},
"conflicting": {
},
"providing": {
"logrotate_app": ">= 0.0.0"
},
"replacing": {
},
"attributes": {
},
"groupings": {
},
"recipes": {
"logrotate": "Installs logrotate package"
},
"version": "2.2.0",
"source_url": "https://github.com/stevendanna/logrotate",
"issues_url": "https://github.com/stevendanna/logrotate/issues",
"privacy": false,
"chef_versions": [
[
">= 12.5"
]
],
"ohai_versions": [
],
"gems": [
]
}

18
cookbooks/logrotate/metadata.rb Normal file
View File

@@ -0,0 +1,18 @@
name 'logrotate'
maintainer 'Steven Danna'
maintainer_email 'steve@chef.io'
license 'Apache 2.0'
description 'Installs logrotate package and provides a definition for logrotate configs'
long_description 'Installs the logrotate package, manages /etc/logrotate.conf, and provides a logrotate_app definition.'
version '2.2.0'
recipe 'logrotate', 'Installs logrotate package'
provides 'logrotate_app'
%w(amazon centos debian fedora redhat scientific solaris2 ubuntu).each do |platform|
supports platform
end
source_url 'https://github.com/stevendanna/logrotate'
issues_url 'https://github.com/stevendanna/logrotate/issues'
chef_version '>= 12.5' if respond_to?(:chef_version)

42
cookbooks/logrotate/recipes/default.rb Normal file
View File

@@ -0,0 +1,42 @@
#
# Cookbook:: logrotate
# Recipe:: default
#
# Copyright:: 2009-2017, Chef Software, Inc.
# Copyright:: 2015-2017, Steven Danna
# Copyright:: 2016-2017, Bloomberg Finance L.P.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
return if platform?('windows')
package node['logrotate']['package']['name'] do
provider node['logrotate']['package']['provider'] if node['logrotate']['package']['provider']
source node['logrotate']['package']['source'] if node['logrotate']['package']['source']
version node['logrotate']['package']['version'] if node['logrotate']['package']['version']
action node['logrotate']['package']['action']
end
directory node['logrotate']['directory'] do
owner 'root'
group node['root_group']
mode '0755'
end
if node['logrotate']['cron']['install'] # ~FC023
cron node['logrotate']['cron']['name'] do
minute node['logrotate']['cron']['minute']
hour node['logrotate']['cron']['hour']
command node['logrotate']['cron']['command']
end
end

30
cookbooks/logrotate/recipes/global.rb Normal file
View File

@@ -0,0 +1,30 @@
#
# Cookbook:: logrotate
# Recipe:: default
#
# Copyright:: 2009-2017, Chef Software, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
include_recipe 'logrotate::default'
parsed_configuration = CookbookLogrotate::LogrotateConfiguration.from_hash(node['logrotate']['global'].to_hash)
template '/etc/logrotate.conf' do
source 'logrotate-global.erb'
mode '0644'
variables(
configuration: parsed_configuration
)
end

116
cookbooks/logrotate/resources/app.rb Normal file
View File

@@ -0,0 +1,116 @@
#
# Copyright:: 2016-2017, Steven Danna
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
resource_name :logrotate_app
property :path, [String, Array], required: true
property :frequency, String, default: 'weekly'
property :cookbook, default: 'logrotate'
property :template_name, default: 'logrotate.erb'
property :template_mode, default: '0644'
property :template_owner, default: 'root'
property :template_group, default: 'root'
property :base_dir, String, default: '/etc/logrotate.d'
property :options, [Array, String], default: %w(missingok compress delaycompress copytruncate notifempty)
default_action :enable
CookbookLogrotate::SCRIPTS.each do |script_name|
property script_name.to_sym, coerce: proc { |val| Array(val).join("\n") }
end
CookbookLogrotate::VALUES.each do |configurable_name|
property configurable_name.to_sym
end
# Deprecated options
property :sharedscripts, [TrueClass, FalseClass], default: false
property :enable, [TrueClass, FalseClass], default: true
action :enable do
unless new_resource.enable
Chef::Log.deprecation 'Use `action :disable` rather than `enable false` in the logrotate_app resource'
action_disable
return true
end
logrotate_config = {
# The path should be a space separated list of quoted filesystem paths
path: Array(new_resource.path).map { |path| path.to_s.inspect }.join(' '),
frequency: new_resource.frequency,
directives: handle_options(new_resource),
scripts: handle_scripts(new_resource),
configurables: handle_configurables(new_resource),
}
directory new_resource.base_dir do
owner 'root'
group node['root_group']
mode '0755'
action :create
end
template "#{new_resource.base_dir}/#{new_resource.name}" do
source new_resource.template_name
cookbook new_resource.cookbook
mode new_resource.template_mode
owner new_resource.template_owner
group new_resource.template_group
backup false
variables logrotate_config
end
end
action :disable do
file "#{new_resource.base_dir}/#{new_resource.name}" do
action :delete
end
end
def handle_configurables(new_resource)
configurables = {}
CookbookLogrotate::VALUES.each do |opt_name|
if value = new_resource.send(opt_name.to_sym) # rubocop: disable Lint/AssignmentInCondition
configurables[opt_name] = value
end
end
configurables
end
def handle_scripts(new_resource)
scripts = {}
CookbookLogrotate::SCRIPTS.each do |script_name|
if script_body = new_resource.send(script_name.to_sym) # rubocop: disable Lint/AssignmentInCondition
scripts[script_name] = script_body
end
end
scripts
end
def handle_options(new_resource)
opts = if new_resource.options.is_a?(Array)
new_resource.options.dup
else
new_resource.options.split
end
if new_resource.sharedscripts
Chef::Log.deprecation('The sharedscripts resource property is deprecated. Use the options property instead to set this value')
opts << 'sharedscripts'
end
opts
end

35
cookbooks/logrotate/templates/default/logrotate-global.erb Normal file
View File

@@ -0,0 +1,35 @@
# This file was generated by Chef for <%= node['fqdn'] %>.
# Do not modify this file by hand!
<% @configuration.directives.each do |d| -%>
<%= d %>
<% end -%>
<% @configuration.values.each do |k, v| -%>
<%= k %> <%= v %>
<% end -%>
<% @configuration.scripts.each do | scripttype, body | -%>
<%= scripttype %>
<%= body %>
endscript
<% end -%>
include /etc/logrotate.d
<% @configuration.paths.each do |path, path_config| -%>
<%= path %> {
<% path_config['directives'].each do |d|-%>
<%= d %>
<% end -%>
<% path_config['values'].each do | k, v | -%>
<%= k %> <%= v %>
<% end -%>
<% path_config['scripts'].each do | scripttype, body | -%>
<%= scripttype %>
<%= body %>
endscript
<% end -%>
}
<% end -%>

19
cookbooks/logrotate/templates/default/logrotate.erb Normal file
View File

@@ -0,0 +1,19 @@
# This file was generated by Chef for <%= node['fqdn'] %>.
# Do not modify this file by hand!
<%= @path %> {
<%- if @frequency %>
<%= @frequency %>
<%- end %>
<%- @configurables.each do |name, value| %>
<%= "#{name} #{value}" %>
<%- end %>
<% @directives.each do |o| -%>
<%= o %>
<% end -%>
<%- @scripts.each do |script_name, script| %>
<%= script_name %>
<%= script %>
endscript
<%- end %>
}