saz-memcached-3.1.0/0000755000372000037200000000000013225233463013617 5ustar travistravissaz-memcached-3.1.0/Gemfile0000644000372000037200000000541613225233334015115 0ustar travistravissource ENV['GEM_SOURCE'] || 'https://rubygems.org' def location_for(place, fake_version = nil) if place =~ %r{^(git[:@][^#]*)#(.*)} [fake_version, { git: Regexp.last_match(1), branch: Regexp.last_match(2), require: false }].compact elsif place =~ %r{/^file:\/\/(.*)/} ['>= 0', { path: File.expand_path(Regexp.last_match(1)), require: false }] else [place, { require: false }] end end group :test do gem 'json_pure', '<= 2.0.1', require: false if RUBY_VERSION < '2.0.0' gem 'metadata-json-lint', require: false gem 'puppet-blacksmith', require: false gem 'puppet-lint-absolute_classname-check', require: false gem 'puppet-lint-classes_and_types_beginning_with_digits-check', require: false gem 'puppet-lint-leading_zero-check', require: false gem 'puppet-lint-trailing_comma-check', require: false gem 'puppet-lint-unquoted_string-check', require: false gem 'puppet-lint-variable_contains_upcase', require: false gem 'puppet-lint-version_comparison-check', require: false gem 'puppetlabs_spec_helper', require: false gem 'rspec-its', require: false gem 'rspec-puppet', require: false, git: 'https://github.com/rodjek/rspec-puppet.git' gem 'rspec-puppet-facts', require: false gem 'rspec-puppet-utils', require: false gem 'rubocop-rspec', '~> 1.5', require: false if RUBY_VERSION >= '2.2.0' gem 'voxpupuli-release', require: false, git: 'https://github.com/voxpupuli/voxpupuli-release-gem.git' end group :development do gem 'guard-rake', require: false gem 'travis', require: false gem 'travis-lint', require: false end group :system_tests do if (beaker_version = ENV['BEAKER_VERSION']) gem 'beaker', *location_for(beaker_version) end if (beaker_rspec_version = ENV['BEAKER_RSPEC_VERSION']) gem 'beaker-rspec', *location_for(beaker_rspec_version) else gem 'beaker-rspec', require: false end gem 'beaker-puppet_install_helper', require: false end if (facterversion = ENV['FACTER_GEM_VERSION']) gem 'facter', facterversion.to_s, require: false, groups: [:test] else gem 'facter', require: false, groups: [:test] end puppetversion = ENV['PUPPET_VERSION'].nil? ? '~> 4.0' : ENV['PUPPET_VERSION'].to_s gem 'puppet', puppetversion, require: false, groups: [:test] # vim: syntax=ruby saz-memcached-3.1.0/LICENSE0000644000372000037200000000122313225233334014617 0ustar travistravis Copyright 2011-2016 Steffen Zieger Copyright 2014-2016 Garrett Honeycutt 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. saz-memcached-3.1.0/README-DEVELOPER0000644000372000037200000000043213225233334016016 0ustar travistravisIn order to run tests: - puppet and facter must be installed and available in Ruby's LOADPATH - the latest revision of rspec-puppet must be installed - rake, and rspec2 must be install - the name of the module directory needs to be memcached to run all tests: rake spec saz-memcached-3.1.0/README.md0000644000372000037200000000340213225233334015072 0ustar travistravis# puppet-memcached [![Build Status](https://secure.travis-ci.org/saz/puppet-memcached.png)](http://travis-ci.org/saz/puppet-memcached) Manage memcached via Puppet ## Show some love If you find this module useful, send some bitcoins to 1Na3YFUmdxKxJLiuRXQYJU2kiNqA3KY2j9 ### Supported Puppet versions * Puppet >= 4 * Last version supporting Puppet 3: v3.0.2 ## How to use ``` Starting with version 3.0.0, memcached will be listening on 127.0.0.1 only. This should make setups more secure (e.g. if there are no firewall rules in place). To change this behavior, you need to set listen_ip to '0.0.0.0'. ``` ### Use roughly 90% of memory ```ruby class { 'memcached': } ``` ### Set a fixed memory limit in MB ```ruby class { 'memcached': max_memory => 2048 } ``` ### Use 12% of available memory ```ruby class { 'memcached': max_memory => '12%' } ``` ### Other class parameters * $package_ensure = 'present' * $logfile = '/var/log/memcached.log' * $pidfile = '/var/run/memcached.pid' (Debian family only, set to false to disable pidfile) * $max_memory = false * $max_item_size = false * $min_item_size = false * $factor = false * $lock_memory = false (WARNING: good if used intelligently, google for -k key) * $listen_ip = '127.0.0.1' * $tcp_port = 11211 * $udp_port = 11211 * $manage_firewall = false * $user = '' (OS specific setting, see params.pp) * $max_connections = 8192 * $verbosity = undef * $unix_socket = undef * $install_dev = false (TRUE if 'libmemcached-dev' package should be installed) * $processorcount = $::processorcount * $service_restart = true (restart service after configuration changes, false to prevent restarts) * $use_sasl = false (start memcached with SASL support) * $large_mem_pages = false (try to use large memory pages) saz-memcached-3.1.0/Rakefile0000644000372000037200000000225213225233334015262 0ustar travistravisrequire 'puppetlabs_spec_helper/rake_tasks' require 'puppet_blacksmith/rake_tasks' require 'voxpupuli/release/rake_tasks' if RUBY_VERSION >= '2.2.0' require 'rubocop/rake_task' RuboCop::RakeTask.new(:rubocop) do |task| # These make the rubocop experience maybe slightly less terrible task.options = ['-D', '-S', '-E'] end end PuppetLint.configuration.log_format = '%{path}:%{linenumber}:%{check}:%{KIND}:%{message}' PuppetLint.configuration.fail_on_warnings = true PuppetLint.configuration.send('relative') PuppetLint.configuration.send('disable_140chars') PuppetLint.configuration.send('disable_class_inherits_from_params_class') PuppetLint.configuration.send('disable_documentation') PuppetLint.configuration.send('disable_single_quote_string_with_variables') exclude_paths = %w[ pkg/**/* vendor/**/* .vendor/**/* spec/**/* ] PuppetLint.configuration.ignore_paths = exclude_paths PuppetSyntax.exclude_paths = exclude_paths desc 'Run acceptance tests' RSpec::Core::RakeTask.new(:acceptance) do |t| t.pattern = 'spec/acceptance' end desc 'Run tests metadata_lint, lint, syntax, spec' task test: [ :metadata_lint, :lint, :syntax, :spec ] # vim: syntax=ruby saz-memcached-3.1.0/lib/0000755000372000037200000000000013225233463014365 5ustar travistravissaz-memcached-3.1.0/lib/puppet/0000755000372000037200000000000013225233463015702 5ustar travistravissaz-memcached-3.1.0/lib/puppet/functions/0000755000372000037200000000000013225233463017712 5ustar travistravissaz-memcached-3.1.0/lib/puppet/functions/memcached/0000755000372000037200000000000013225233463021620 5ustar travistravissaz-memcached-3.1.0/lib/puppet/functions/memcached/max_memory.rb0000644000372000037200000000207313225233334024321 0ustar travistravis# Calculate max_memory size from fact 'memsize' and passed argument. Puppet::Functions.create_function(:'memcached::max_memory') do dispatch :max_memory do required_param 'Any', :arg return_type 'Integer' end def max_memory(arg) scope = closure_scope memsize = scope['facts']['memorysize'] if arg && !arg.to_s.end_with?('%') result_in_mb = arg.to_i else max_memory_percent = arg ? arg : '95%' # Taken from puppetlabs-stdlib to_bytes() function value, prefix = *%r{([0-9.e+-]*)\s*([^bB]?)}.match(memsize)[1, 2] value = value.to_f case prefix when '' then value = value when 'k' then value *= (1 << 10) when 'M' then value *= (1 << 20) when 'G' then value *= (1 << 30) when 'T' then value *= (1 << 40) when 'E' then value *= (1 << 50) else raise Puppet::ParseError, "memcached_max_memory(): Unknown prefix #{prefix}" end value = value.to_i result_in_mb = ((value / (1 << 20)) * (max_memory_percent.to_f / 100.0)).floor end result_in_mb end end saz-memcached-3.1.0/manifests/0000755000372000037200000000000013225233463015610 5ustar travistravissaz-memcached-3.1.0/manifests/init.pp0000644000372000037200000001106613225233334017115 0ustar travistravis# == Class: memcached # # Manage memcached # # == Parameters # [* syslog *] # Boolean. # If true will pipe output to /bin/logger, sends to syslog. # class memcached ( Enum['present', 'latest', 'absent'] $package_ensure = 'present', Boolean $service_manage = true, Optional[Stdlib::Absolutepath] $logfile = $::memcached::params::logfile, Boolean $syslog = false, Optional[Stdlib::Absolutepath] $pidfile = '/var/run/memcached.pid', Boolean $manage_firewall = false, $max_memory = '95%', Optional[Variant[Integer, String]] $max_item_size = undef, Optional[Variant[Integer, String]] $min_item_size = undef, Boolean $factor = false, Boolean $lock_memory = false, Optional[Stdlib::Compat::Ip_address] $listen_ip = '127.0.0.1', Integer $tcp_port = 11211, Integer $udp_port = 11211, String $user = $::memcached::params::user, Integer $max_connections = 8192, Optional[String] $verbosity = undef, Optional[String] $unix_socket = undef, String $unix_socket_mask = '0755', Boolean $install_dev = false, Variant[String,Integer] $processorcount = $::processorcount, Boolean $service_restart = true, Boolean $auto_removal = false, Boolean $use_sasl = false, Boolean $use_registry = $::memcached::params::use_registry, String $registry_key = 'HKLM\System\CurrentControlSet\services\memcached\ImagePath', Boolean $large_mem_pages = false, Boolean $use_svcprop = $::memcached::params::use_svcprop, String $svcprop_fmri = 'memcached:default', String $svcprop_key = 'memcached/options', Optional[Array[String]] $extended_opts = undef, String $config_tmpl = $::memcached::params::config_tmpl, Boolean $disable_cachedump = false ) inherits memcached::params { # Logging to syslog and file are mutually exclusive # Fail if both options are defined if $syslog and str2bool($logfile) { fail 'Define either syslog or logfile as logging destinations but not both.' } if $package_ensure == 'absent' { $service_ensure = 'stopped' $service_enable = false } else { $service_ensure = 'running' $service_enable = true } package { $memcached::params::package_name: ensure => $package_ensure, provider => $memcached::params::package_provider, } if $install_dev { package { $memcached::params::dev_package_name: ensure => $package_ensure, require => Package[$memcached::params::package_name], } } if $manage_firewall { firewall { "100_tcp_${tcp_port}_for_memcached": dport => $tcp_port, proto => 'tcp', action => 'accept', } firewall { "100_udp_${udp_port}_for_memcached": dport => $udp_port, proto => 'udp', action => 'accept', } } if $service_restart and $service_manage { $service_notify_real = Service[$memcached::params::service_name] } else { $service_notify_real = undef } if ( $memcached::params::config_file ) { file { $memcached::params::config_file: owner => 'root', group => 0, mode => '0644', content => template($config_tmpl), require => Package[$memcached::params::package_name], notify => $service_notify_real, } } if $service_manage { service { $memcached::params::service_name: ensure => $service_ensure, enable => $service_enable, hasrestart => true, hasstatus => $memcached::params::service_hasstatus, } } if $use_registry { registry_value{ $registry_key: ensure => 'present', type => 'string', data => template($config_tmpl), notify => $service_notify_real, } } if $use_svcprop { svcprop { $svcprop_key: fmri => $svcprop_fmri, property => $svcprop_key, value => template($memcached::params::config_tmpl), notify => $service_notify_real, } } } saz-memcached-3.1.0/manifests/params.pp0000644000372000037200000000616613225233334017442 0ustar travistravis# == Class: memcached::params # class memcached::params { case $::osfamily { 'Debian': { $package_name = 'memcached' $package_provider = undef $service_name = 'memcached' $service_hasstatus = false $dev_package_name = 'libmemcached-dev' $config_file = '/etc/memcached.conf' $config_tmpl = "${module_name}/memcached.conf.erb" $user = 'nobody' $logfile = '/var/log/memcached.log' $use_registry = false $use_svcprop = false } /RedHat|Suse/: { $package_name = 'memcached' $package_provider = undef $service_name = 'memcached' $service_hasstatus = true $dev_package_name = 'libmemcached-devel' $config_file = '/etc/sysconfig/memcached' $config_tmpl = "${module_name}/memcached_sysconfig.erb" $user = 'memcached' $logfile = '/var/log/memcached.log' $use_registry = false $use_svcprop = false } /windows/: { $package_name = 'memcached' $package_provider = 'chocolatey' $service_name = 'memcached' $service_hasstatus = true $dev_package_name = 'libmemcached-devel' $config_file = undef $config_tmpl = "${module_name}/memcached_windows.erb" $user = 'BUILTIN\Administrators' $logfile = undef $use_registry = true $use_svcprop = false } 'Solaris': { $package_name = 'memcached' $package_provider = undef $service_name = 'memcached' $service_hasstatus = false $dev_package_name = 'libmemcached' $config_file = undef $config_tmpl = "${module_name}/memcached_svcprop.erb" $user = 'nobody' $logfile = '/var/log/memcached.log' $use_registry = false $use_svcprop = true } 'FreeBSD': { $package_name = 'memcached' $package_provider = undef $service_name = 'memcached' $service_hasstatus = false $dev_package_name = 'libmemcached' $config_file = '/etc/rc.conf.d/memcached' $config_tmpl = "${module_name}/memcached_freebsd_rcconf.erb" $user = 'nobody' $logfile = '/var/log/memcached.log' $use_registry = false $use_svcprop = false } default: { case $::operatingsystem { 'Amazon': { $package_name = 'memcached' $package_provider = undef $service_name = 'memcached' $service_hasstatus = true $dev_package_name = 'libmemcached-devel' $config_file = '/etc/sysconfig/memcached' $config_tmpl = "${module_name}/memcached_sysconfig.erb" $user = 'memcached' $logfile = '/var/log/memcached.log' $use_registry = false $use_svcprop = false } default: { fail("Unsupported platform: ${::osfamily}/${::operatingsystem}") } } } } } saz-memcached-3.1.0/metadata.json0000644000372000037200000000211513225233463016271 0ustar travistravis{ "name": "saz-memcached", "version": "3.1.0", "author": "saz", "summary": "Manage memcached via Puppet", "license": "Apache-2.0", "source": "git://github.com/saz/puppet-memcached.git", "project_page": "https://github.com/saz/puppet-memcached", "issues_url": "https://github.com/saz/puppet-memcached/issues", "dependencies": [ { "name": "puppetlabs/stdlib", "version_requirement": ">= 4.13.1 < 6.0.0" }, { "name": "puppetlabs/firewall", "version_requirement": ">= 0.1.0 < 2.0.0" } ], "data_provider": null, "description": "Manage memcached via Puppet", "requirements": [ { "name": "puppet", "version_requirement": ">= 4.0.0 < 5.0.0" } ], "operatingsystem_support": [ { "operatingsystem": "RedHat" }, { "operatingsystem": "CentOS" }, { "operatingsystem": "OracleLinux" }, { "operatingsystem": "Scientific" }, { "operatingsystem": "Debian" }, { "operatingsystem": "Ubuntu" }, { "operatingsystem": "Windows" } ] } saz-memcached-3.1.0/spec/0000755000372000037200000000000013225233463014551 5ustar travistravissaz-memcached-3.1.0/spec/classes/0000755000372000037200000000000013225233463016206 5ustar travistravissaz-memcached-3.1.0/spec/classes/init_spec.rb0000644000372000037200000002603013225233334020506 0ustar travistravisrequire 'spec_helper' describe 'memcached' do let :default_params do { package_ensure: 'present', logfile: '/var/log/memcached.log', lock_memory: false, listen_ip: '127.0.0.1', tcp_port: 11_211, udp_port: 11_211, user: 'nobody', max_connections: 8192, install_dev: false, processorcount: 1, use_sasl: false, large_mem_pages: false, pidfile: '/var/run/memcached.pid' } end describe 'with manage_firewall parameter' do %w[Debian RedHat].each do |osfam| context "on osfamily #{osfam}" do let(:facts) do { osfamily: osfam, memorysize: '1000 MB', processorcount: '1' } end context 'with manage_firewall set to true' do let(:params) { { manage_firewall: true } } it { is_expected.to contain_class('memcached') } it { is_expected.to contain_firewall('100_tcp_11211_for_memcached') } it { is_expected.to contain_firewall('100_udp_11211_for_memcached') } end context 'with manage_firewall set to false' do let(:params) { { manage_firewall: false } } it { is_expected.to contain_class('memcached') } it { is_expected.not_to contain_firewall('100_tcp_11211_for_memcached') } it { is_expected.not_to contain_firewall('100_udp_11211_for_memcached') } end context 'with manage_firewall set to an invalid type (array)' do let(:params) { { manage_firewall: %w[invalid type] } } it do expect do is_expected.to contain_class('memcached') end.to raise_error(Puppet::Error) end end end end end let :default_params do { package_ensure: 'present', logfile: '/var/log/memcached.log', lock_memory: false, listen_ip: '127.0.0.1', tcp_port: 11_211, udp_port: 11_211, user: 'nobody', max_connections: 8192, install_dev: false, processorcount: 1, use_sasl: false, large_mem_pages: false, pidfile: '/var/run/memcached.pid', disable_cachedump: false } end [{}, { package_ensure: 'latest', logfile: '/var/log/memcached.log', max_memory: 2, lock_memory: true, listen_ip: '127.0.0.1', tcp_port: 11_212, udp_port: 11_213, user: 'somebdy', max_connections: 8193, verbosity: 'vvv', processorcount: 3, use_sasl: true, large_mem_pages: true, extended_opts: %w[lru_crawler lru_maintainer] }, { package_ensure: 'present', logfile: '/var/log/memcached.log', max_memory: '20%', lock_memory: false, listen_ip: '127.0.0.1', tcp_port: 11_212, udp_port: 11_213, user: 'somebdy', max_connections: 8193, verbosity: 'vvv', install_dev: true, processorcount: 1, extended_opts: %w[lru_crawler lru_maintainer], disable_cachedump: true }, { pidfile: '/var/log/memcached.pid', disable_cachedump: true }, { package_ensure: 'absent', install_dev: true }, { service_manage: false }].each do |param_set| describe "when #{param_set == {} ? 'using default' : 'specifying'} class parameters" do let :param_hash do default_params.merge(param_set) end let :params do param_set end ['Debian'].each do |osfamily| let :facts do { osfamily: osfamily, memorysize: '1000 MB', processorcount: '1' } end describe "on supported osfamily: #{osfamily}" do it { is_expected.to compile.with_all_deps } it { is_expected.to contain_class('memcached') } it { is_expected.to contain_class('memcached::params') } it { is_expected.to contain_package('memcached').with_ensure(param_hash[:package_ensure]) } it { is_expected.not_to contain_firewall('100_tcp_11211_for_memcached') } it { is_expected.not_to contain_firewall('100_udp_11211_for_memcached') } it do if param_hash[:install_dev] is_expected.to contain_package('libmemcached-dev').with_ensure(param_hash[:package_ensure]) end end it do is_expected.to contain_file('/etc/memcached.conf').with( 'owner' => 'root', 'group' => 0 ) end it do if param_hash[:service_manage] == false is_expected.not_to contain_service('memcached') elsif param_hash[:package_ensure] == 'absent' is_expected.to contain_service('memcached').with( 'ensure' => 'stopped', 'enable' => false ) else is_expected.to contain_service('memcached').with( 'ensure' => 'running', 'enable' => true, 'hasrestart' => true, 'hasstatus' => false ) end end it 'compiles the template based on the class parameters' do content = param_value( catalogue, 'file', '/etc/memcached.conf', 'content' ) expected_lines = [ "logfile #{param_hash[:logfile]}", "-p #{param_hash[:tcp_port]}", "-U #{param_hash[:udp_port]}", "-u #{param_hash[:user]}", "-c #{param_hash[:max_connections]}", "-t #{param_hash[:processorcount]}" ] if param_hash[:max_memory] if param_hash[:max_memory].is_a?(String) && param_hash[:max_memory].end_with?('%') expected_lines.push('-m 200') else expected_lines.push("-m #{param_hash[:max_memory]}") end else expected_lines.push('-m 950') end if param_hash[:listen_ip] != '' expected_lines.push("-l #{param_hash[:listen_ip]}") end expected_lines.push('-k') if param_hash[:lock_memory] if param_hash[:pidfile] expected_lines.push("-P #{param_hash[:pidfile]}") end expected_lines.push('-vvv') if param_hash[:verbosity] expected_lines.push('-S') if param_hash[:use_sasl] expected_lines.push('-L') if param_hash[:large_mem_pages] expected_lines.push('-X') if param_hash[:disable_cachedump] == true if param_hash[:extended_opts] expected_lines.push('-o lru_crawler,lru_maintainer') end (content.split("\n") & expected_lines).should =~ expected_lines end end end ['Redhat'].each do |_osfamily| describe 'on supported platform' do it 'fails' do end end end end end context 'with osfamily = Solaris' do let :facts do { osfamily: 'Solaris', memorysize: '1000 MB', processorcount: '1' } end describe 'when using default class parameters' do let :param_hash do default_params end let :params do {} end it { is_expected.to contain_class('memcached::params') } it { is_expected.to contain_package('memcached').with_ensure('present') } it { is_expected.not_to contain_firewall('100_tcp_11211_for_memcached') } it { is_expected.not_to contain_firewall('100_udp_11211_for_memcached') } it do is_expected.to contain_service('memcached').with( 'ensure' => 'running', 'enable' => true, 'hasrestart' => true, 'hasstatus' => false ) end it do is_expected.to contain_svcprop('memcached/options').with( 'fmri' => 'memcached:default', 'property' => 'memcached/options', 'value' => "\"-m\" \"950\" \"-l\" \"127.0.0.1\" \"-p\" \"11211\" \"-U\" \"11211\" \"-u\" \"nobody\" \"-c\" \"8192\" \"-t\" \"1\"\n", 'notify' => 'Service[memcached]' ) end end end context 'with osfamily = FreeBSD' do let :facts do { osfamily: 'FreeBSD', memorysize: '1000 MB', processorcount: '2' } end describe 'when using default class parameters' do let :params do default_params end it { is_expected.to contain_class('memcached::params') } it { is_expected.to contain_package('memcached').with_ensure('present') } it { is_expected.not_to contain_firewall('100_tcp_11211_for_memcached') } it { is_expected.not_to contain_firewall('100_udp_11211_for_memcached') } it do is_expected.to contain_service('memcached').with( 'ensure' => 'running', 'enable' => true, 'hasrestart' => true, 'hasstatus' => false ) end it do is_expected.to contain_file('/etc/rc.conf.d/memcached').with_content( "### MANAGED BY PUPPET\n### DO NOT EDIT\n\n\memcached_enable=\"YES\"\nmemcached_flags=\"-d -u nobody -P /var/run/memcached.pid -t 1 -l 127.0.0.1 -c 8192 -p 11211 -U 11211\"\n" ) end it do is_expected.not_to contain_svcprop('memcached/options').with( 'fmri' => 'memcached:default', 'property' => 'memcached/options', 'value' => '"-m" "950" "-l" "127.0.0.1" "-p" "11211" "-U" "11211" "-u" "nobody" "-c" "8192" "-t" "1"', 'notify' => 'Service[memcached]' ) end end describe 'when using custom class parameters' do let :custom_params do { 'listen_ip' => '127.0.0.1', 'tcp_port' => 9999, 'udp_port' => 9999, 'disable_cachedump' => true } end let :param_hash do default_params.merge(custom_params) end let :params do custom_params end # TODO: figure out how to check the file contents it do is_expected.to contain_file('/etc/rc.conf.d/memcached').with_content( "### MANAGED BY PUPPET\n### DO NOT EDIT\n\n\memcached_enable=\"YES\"\nmemcached_flags=\"-d -u nobody -P /var/run/memcached.pid -t 2 -l 127.0.0.1 -c 8192 -p 9999 -U 9999 -X\"\n" ) end end end context 'with osfamily = Redhat' do let :facts do { osfamily: 'RedHat', memorysize: '1000 MB', processorcount: '4' } end describe 'when using custom class parameters' do let :custom_params do { 'disable_cachedump' => true } end let :param_hash do default_params.merge(custom_params) end let :params do custom_params end it do is_expected.to contain_file('/etc/sysconfig/memcached').with_content( "PORT=\"11211\"\nUSER=\"memcached\"\nMAXCONN=\"8192\"\nCACHESIZE=\"950\"\nOPTIONS=\"-l 127.0.0.1 -U 11211 -X -t 4 >> /var/log/memcached.log 2>&1\"\n" ) end end end end # vim: expandtab shiftwidth=2 softtabstop=2 saz-memcached-3.1.0/spec/spec.opts0000644000372000037200000000005713225233334016411 0ustar travistravis--format s --colour --loadby mtime --backtrace saz-memcached-3.1.0/spec/spec_helper.rb0000644000372000037200000000110613225233334017362 0ustar travistravisrequire 'puppetlabs_spec_helper/module_spec_helper' RSpec.configure do |config| config.hiera_config = 'spec/fixtures/hiera/hiera.yaml' config.before do # Ensure that we don't accidentally cache facts and environment between # test cases. This requires each example group to explicitly load the # facts being exercised with something like # Facter.collection.loader.load(:ipaddress) Facter.clear Facter.clear_messages end config.default_facts = { environment: 'rp_env', memsize: '1000', processorcount: 1, osfamily: 'RedHat' } end saz-memcached-3.1.0/templates/0000755000372000037200000000000013225233463015615 5ustar travistravissaz-memcached-3.1.0/templates/memcached.conf.erb0000644000372000037200000000321513225233334021137 0ustar travistravis# File managed by puppet # Run memcached as a daemon. -d <% if @pidfile -%> # pidfile -P <%= @pidfile %> <% end -%> # Log memcached's output logfile <%= @logfile -%> <% if @verbosity -%> # Verbosity -<%= @verbosity %> <% end -%> # Use MB memory max to use for object storage. -m <%= scope.call_function('memcached::max_memory', [@max_memory]) %> <% if @lock_memory -%> # Lock down all paged memory. There is a limit on how much memory you may lock. -k <% end -%> <% if @use_sasl -%> # Start with SASL support -S <% end -%> <% if @unix_socket -%> # UNIX socket path to listen on -s <%= @unix_socket %> # UNIX socket access mask -a <%= @unix_socket_mask %> <% else -%> <% if @listen_ip -%> # IP to listen on -l <%= @listen_ip %> <% end -%> # TCP port to listen on -p <%= @tcp_port %> # UDP port to listen on -U <%= @udp_port %> <% end -%> # Run daemon as user -u <%= @user %> <% if @large_mem_pages -%> # Try to use large memory pages (if available) -L <% end -%> # Limit the number of simultaneous incoming connections. -c <%= @max_connections %> # Number of threads to use to process incoming requests. -t <%= @processorcount %> <% if @max_item_size -%> # Override the default size of each slab page -I <%= @max_item_size %> <% end -%> <% if @min_item_size -%> # Override the default size of each slab page -n <%= @min_item_size %> <% end -%> <% if @factor -%> # Override the default factor -f <%= @factor %> <% end -%> <% if @auto_removal -%> # Disable automatic removal of items from the cache when out of memory -M <% end -%> <% if @extended_opts -%> -o <%= @extended_opts.join(',') -%> <% end -%> <% if @disable_cachedump -%> -X <% end -%> saz-memcached-3.1.0/templates/memcached_freebsd_rcconf.erb0000644000372000037200000000145713225233334023245 0ustar travistravis### MANAGED BY PUPPET ### DO NOT EDIT <%- enabled = "YES" if !@service_manage enabled = "NO" end flags = [] # required flags flags << "-d -u #{@user} -P #{@pidfile} -t #{@processorcount}" # optional flags if @item_size flags << "-I #{@item_size.to_s}" end if @listen_ip flags << "-l #{@listen_ip}" end if @lock_memory flags << "-k" end if @max_connections flags << "-c #{@max_connections}" end #TODO: wtf do we do with this? #if @logfile #end if @tcp_port flags << "-p #{@tcp_port.to_s}" end if @udp_port flags << "-U #{@udp_port.to_s}" end if @unix_socket flags << "-s #{@unix_socket} -a #{@unix_socket_mask}" end if @verbosity flags << "-#{@verbosity.to_s}" end if @disable_cachedump flags << '-X' end -%> memcached_enable="<%= enabled %>" memcached_flags="<%= flags.join(" ") %>" saz-memcached-3.1.0/templates/memcached_svcprop.erb0000644000372000037200000000332713225233334021773 0ustar travistravis<%- result = [] if @verbosity # Verbosity result << '"-' + @verbosity.to_s + '"' end # Use MB memory max to use for object storage. result << '"-m" "' + scope.call_function('memcached::max_memory', [@max_memory]).to_s + '"' if @lock_memory # Lock down all paged memory. There is a limit on how much memory you may lock. result << '"-k"' end if @use_sasl # Start with SASL support result << '"-S"' end if @unix_socket # UNIX socket path to listen on result << '"-s" "' + @unix_socket + '"' # UNIX socket access mask result << '"-a" "' + @unix_socket_mask + '"' else if @listen_ip # IP to listen on result << '"-l" "' + @listen_ip + '"' end # TCP port to listen on if @tcp_port result << '"-p" "' + @tcp_port.to_s + '"' end # UDP port to listen on if @udp_port result << '"-U" "' + @udp_port.to_s + '"' end end # Run daemon as user result << '"-u" "' + @user + '"' if @large_mem_pages # Try to use large memory pages (if available) result << '"-L"' end # Limit the number of simultaneous incoming connections. result << '"-c" "' + @max_connections.to_s + '"' # Number of threads to use to process incoming requests. result << '"-t" "' + @processorcount.to_s + '"' if @max_item_size # Override the default size of each slab page result << '"-I" "' + @max_item_size.to_s + '"' end if @min_item_size result << '"-n" "' + @min_item_size.to_s + '"' end if @factor result << '"-f" "' + @factor.to_s + '"' end if @auto_removal # Disable automatic removal of items from the cache when out of memory result << '"-M"' end if @extended_opts result << '"-o" "' + @extended_opts.join(',') + '"' end if @disable_cachedump result << '"-X"' end -%> <%= result.join(' ') %> saz-memcached-3.1.0/templates/memcached_sysconfig.erb0000644000372000037200000000303413225233334022276 0ustar travistravis<%- result = [] if @verbosity result << '-' + @verbosity.to_s end if @lock_memory result << '-k' end if @listen_ip result << '-l ' + @listen_ip end if @udp_port result << '-U ' + @udp_port.to_s end if @unix_socket result << '-s ' + @unix_socket.to_s + ' -a ' + @unix_socket_mask.to_s end if @max_item_size result << '-I ' + @max_item_size.to_s end if @min_item_size result << '-n ' + @min_item_size.to_s end if @factor result << '-f ' + @factor.to_s end if @extended_opts result << '-o ' + @extended_opts.join(',') end if @disable_cachedump result << '-X' end result << '-t ' + @processorcount.to_s # log to syslog via logger if @syslog && !@logfile result << '2>&1 |/bin/logger &' # log to log file elsif @logfile && !@syslog result << '>> ' + @logfile + ' 2>&1' end -%> <%- if scope['osfamily'] != 'Suse' -%> PORT="<%= @tcp_port %>" USER="<%= @user %>" MAXCONN="<%= @max_connections %>" CACHESIZE="<%= scope.call_function('memcached::max_memory', [@max_memory]) %>" OPTIONS="<%= result.join(' ') %>" <%- else -%> MEMCACHED_PARAMS="<%= result.join(' ') %>" ## Path: Network/WWW/Memcached ## Description: username memcached should run as ## Type: string ## Default: "memcached" ## Config: memcached # # username memcached should run as # MEMCACHED_USER="<%= @user %>" ## Path: Network/WWW/Memcached ## Description: group memcached should be run as ## Type: string ## Default: "memcached" ## Config: memcached # # group memcached should be run as # MEMCACHED_GROUP="<%= @user %>" <%- end -%> saz-memcached-3.1.0/templates/memcached_windows.erb0000644000372000037200000000137013225233334021765 0ustar travistravis<%- result = [] if @verbosity result << '-' + @verbosity.to_s end if @lock_memory result << '-k' end if @listen_ip result << '-l ' + @listen_ip end if @tcp_port result << '-p ' + @tcp_port.to_s end if @udp_port result << '-U ' + @udp_port.to_s end if @max_item_size result << '-I ' + @max_item_size.to_s end if @min_item_size result << '-n ' + @min_item_size.to_s end if @factor result << '-f ' + @factor.to_s end result << '-t ' + @processorcount if @max_connections result << '-c ' + @max_connections end if @extended_opts result << '-o ' + @extended_opts.join(',') end if @logfile result << '>> ' + @logfile + ' 2>&1' end if @disable_cachedump result << '-X' end -%> c:\memcached\memcached.exe -d runservice <%= result.join(' ') %> saz-memcached-3.1.0/tests/0000755000372000037200000000000013225233463014761 5ustar travistravissaz-memcached-3.1.0/tests/init.pp0000644000372000037200000000002413225233334016256 0ustar travistravisinclude ::memcached saz-memcached-3.1.0/checksums.json0000644000372000037200000000215213225233463016477 0ustar travistravis{ "Gemfile": "8697795aad7ca0ff18a563fb671630f4", "LICENSE": "1322039bbc8e3ff4e74252ec65303861", "README-DEVELOPER": "d45048731ddb158a56a1b26293fb5dbf", "README.md": "303a4339418e27fdd14597fd39a8b5bf", "Rakefile": "0db34b2e6f3b6e6950648814bf11b24c", "lib/puppet/functions/memcached/max_memory.rb": "e964f77d247a39736c2f8f04403326b9", "manifests/init.pp": "2965d7849fd0d172e02adf3ebfa700f2", "manifests/params.pp": "aa34ef20b9dbb95323fa5c7bcb6f8dbb", "metadata.json": "d5b4c9e44766fe5fba0038d15fd83e15", "spec/classes/init_spec.rb": "dddb2aba2d36accb28ab2735e4590e30", "spec/spec.opts": "a600ded995d948e393fbe2320ba8e51c", "spec/spec_helper.rb": "c8a87dbc00da5bcbd1861a2fa7efa0af", "templates/memcached.conf.erb": "0a1778db91d7e5c66053e0e70b7bacaf", "templates/memcached_freebsd_rcconf.erb": "fae5e83f3c886e0390f522f09c07fc7c", "templates/memcached_svcprop.erb": "de071b048c4c7e2c7e018a052d77eb5a", "templates/memcached_sysconfig.erb": "90f68122f6136089ef483c7dde98ffb8", "templates/memcached_windows.erb": "479c25482d90585b6ecfa3d1b14be9dc", "tests/init.pp": "2cd83e4421f8620c6d925bd3299ed2d5" }