saz-memcached-2.8.1/000755 000765 000024 00000000000 12535064111 014161 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/Gemfile000644 000765 000024 00000000517 12530662664 015473 0ustar00sazstaff000000 000000 source "https://rubygems.org" puppetversion = ENV.key?('PUPPET_VERSION') ? "= #{ENV['PUPPET_VERSION']}" : ['>= 3.3'] gem 'puppet', puppetversion gem 'puppetlabs_spec_helper', '>= 0.1.0' gem 'rspec', '< 3.2.0', {"platforms"=>["ruby_18"]} gem 'puppet-lint', '>= 0.3.2' gem 'facter', '>= 1.7.0', "< 1.8.0" gem 'rspec-puppet', '=1.0.1' saz-memcached-2.8.1/LICENSE000644 000765 000024 00000001211 12530662664 015175 0ustar00sazstaff000000 000000 Copyright 2011 Steffen Zieger Copyright 2014 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-2.8.1/README-DEVELOPER000644 000765 000024 00000000432 12530662664 016377 0ustar00sazstaff000000 000000 In 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-2.8.1/README.md000644 000765 000024 00000002616 12530667771 015465 0ustar00sazstaff000000 000000 # 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 ## How to use ### 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 * $item_size = false * $lock_memory = false (WARNING: good if used intelligently, google for -k key) * $listen_ip = '0.0.0.0' * $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-2.8.1/Rakefile000644 000765 000024 00000001251 12530662664 015641 0ustar00sazstaff000000 000000 require 'rubygems' require 'puppetlabs_spec_helper/rake_tasks' require 'puppet-lint/tasks/puppet-lint' PuppetLint.configuration.send('disable_80chars') PuppetLint.configuration.relative = true PuppetLint.configuration.ignore_paths = ["spec/**/*.pp", "pkg/**/*.pp"] desc "Run puppet in noop mode and check for syntax errors." task :validate do Dir['manifests/**/*.pp'].each do |manifest| sh "puppet parser validate --noop #{manifest}" end Dir['spec/**/*.rb','lib/**/*.rb'].each do |ruby_file| sh "ruby -c #{ruby_file}" unless ruby_file =~ /spec\/fixtures/ end Dir['templates/**/*.erb'].each do |template| sh "erb -P -x -T '-' #{template} | ruby -c" end end saz-memcached-2.8.1/checksums.json000644 000765 000024 00000001735 12535064111 017047 0ustar00sazstaff000000 000000 { "Gemfile": "e3862348ae1ca9aebf98f138880db601", "LICENSE": "d42ad7f00d233260ac2fba922b7fd83c", "README-DEVELOPER": "d45048731ddb158a56a1b26293fb5dbf", "README.md": "2b7283f5540df8576f90cf1afd136cbc", "Rakefile": "791f8cad5f4e5d67cd261728d52a5bdf", "lib/puppet/parser/functions/memcached_max_memory.rb": "edc87a9d229013298027a075e3eb8795", "manifests/init.pp": "439ab80209902b9cf20c61049b7be4a9", "manifests/params.pp": "b7e13ad9db1731e103c8a0b37f041b76", "metadata.json": "4774f96927f32d3cbef5595de2ba2765", "spec/classes/memcached_spec.rb": "5c96b78e1bd716c252728ac08fda7641", "spec/spec.opts": "a600ded995d948e393fbe2320ba8e51c", "spec/spec_helper.rb": "3ea886dd135e120afa31e0aab12e85b0", "templates/memcached.conf.erb": "853ac472c6f1ca921921afce43053802", "templates/memcached_sysconfig.erb": "16e8a675e51d28299adcc216c710910b", "templates/memcached_windows.erb": "4df8529a690cfe5b10013237bc320513", "tests/init.pp": "e798f4999ba392f3c0fce0d5290c263f" }saz-memcached-2.8.1/lib/000755 000765 000024 00000000000 12535064111 014727 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/manifests/000755 000765 000024 00000000000 12535064111 016152 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/metadata.json000644 000765 000024 00000002116 12535064111 016634 0ustar00sazstaff000000 000000 { "name": "saz-memcached", "version": "2.8.1", "author": "saz", "summary": "Manage memcached via Puppet", "license": "Apache License, Version 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", "operatingsystem_support": [ { "operatingsystem": "RedHat" }, { "operatingsystem": "CentOS" }, { "operatingsystem": "OracleLinux" }, { "operatingsystem": "Scientific" }, { "operatingsystem": "Debian" }, { "operatingsystem": "Ubuntu" }, { "operatingsystem": "Windows" } ], "requirements": [ { "name": "pe", "version_requirement": ">= 3.2.0 < 3.4.0" }, { "name": "puppet", "version_requirement": "3.x" } ], "description": "Manage memcached via Puppet", "dependencies": [ {"name":"puppetlabs/stdlib","version_requirement":">= 3.2.0"}, {"name":"puppetlabs/firewall","version_requirement":">= 0.1.0"} ] } saz-memcached-2.8.1/spec/000755 000765 000024 00000000000 12535064111 015113 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/templates/000755 000765 000024 00000000000 12535064111 016157 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/tests/000755 000765 000024 00000000000 12535064111 015323 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/tests/init.pp000644 000765 000024 00000000022 12530662664 016635 0ustar00sazstaff000000 000000 include memcached saz-memcached-2.8.1/templates/memcached.conf.erb000644 000765 000024 00000002534 12530671575 021524 0ustar00sazstaff000000 000000 # 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. <% Puppet::Parser::Functions.function('memcached_max_memory') -%> -m <%= scope.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 %> <% 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 @item_size -%> # Override the default size of each slab page -I <%= @item_size %> <% end -%> <% if @auto_removal -%> # Disable automatic removal of items from the cache when out of memory -M <% end -%> saz-memcached-2.8.1/templates/memcached_sysconfig.erb000644 000765 000024 00000002442 12530673601 022652 0ustar00sazstaff000000 000000 <%- 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 @item_size result << '-I ' + @item_size.to_s end result << '-t ' + @processorcount.to_s # log to syslog via logger if @syslog && @logfile.empty? result << '2>&1 |/bin/logger &' # log to log file elsif !@logfile.empty? && !@syslog result << '>> ' + @logfile + ' 2>&1' end -%> <%- if scope['osfamily'] != 'Suse' -%> PORT="<%= @tcp_port %>" USER="<%= @user %>" MAXCONN="<%= @max_connections %>" <% Puppet::Parser::Functions.function('memcached_max_memory') -%> CACHESIZE="<%= scope.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-2.8.1/templates/memcached_windows.erb000644 000765 000024 00000001024 12530662664 022342 0ustar00sazstaff000000 000000 <%- 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 @item_size result << '-I ' + @item_size.to_s end result << '-t ' + @processorcount if @max_connections result << '-c ' + @max_connections end if @logfile result << '>> ' + @logfile + ' 2>&1' end -%> c:\memcached\memcached.exe -d runservice <%= result.join(' ') %> saz-memcached-2.8.1/spec/classes/000755 000765 000024 00000000000 12535064111 016550 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/spec/fixtures/000755 000765 000024 00000000000 12535064111 016764 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/spec/spec.opts000644 000765 000024 00000000057 12530662664 016772 0ustar00sazstaff000000 000000 --format s --colour --loadby mtime --backtrace saz-memcached-2.8.1/spec/spec_helper.rb000644 000765 000024 00000000107 12530662664 017743 0ustar00sazstaff000000 000000 require 'rubygems' require 'puppetlabs_spec_helper/module_spec_helper' saz-memcached-2.8.1/spec/fixtures/manifests/000755 000765 000024 00000000000 12535064111 020755 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/spec/fixtures/modules/000755 000765 000024 00000000000 12535064111 020434 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/spec/classes/memcached_spec.rb000644 000765 000024 00000015115 12530671575 022035 0ustar00sazstaff000000 000000 require 'spec_helper' describe 'memcached' do describe 'with manage_firewall parameter' do ['Debian','RedHat'].each do |osfam| context "on osfamily #{osfam}" do let(:facts) do { :osfamily => osfam, :memorysize => '1000 MB', :processorcount => '1', } end ['true',true].each do |value| context "set to #{value}" do let(:params) { { :manage_firewall => value } } it { should contain_class('memcached') } it { should contain_firewall('100_tcp_11211_for_memcached') } it { should contain_firewall('100_udp_11211_for_memcached') } end end ['false',false].each do |value| context "set to #{value}" do let(:params) { { :manage_firewall => value } } it { should contain_class('memcached') } it { should_not contain_firewall('100_tcp_11211_for_memcached') } it { should_not contain_firewall('100_udp_11211_for_memcached') } end end context 'set to an invalid type (array)' do let(:params) { { :manage_firewall => ['invalid','type'] } } it do expect { should contain_class('memcached') }.to raise_error(Puppet::Error) end end end end end let :default_params do { :package_ensure => 'present', :logfile => '/var/log/memcached.log', :max_memory => false, :item_size => false, :lock_memory => false, :listen_ip => '0.0.0.0', :tcp_port => '11211', :udp_port => '11211', :user => 'nobody', :max_connections => '8192', :install_dev => false, :processorcount => 1, :use_sasl => false, :large_mem_pages => false, } end [ {}, { :package_ensure => 'latest', :logfile => '/var/log/memcached.log', :max_memory => '2', :item_size => false, :lock_memory => true, :listen_ip => '127.0.0.1', :tcp_port => '11212', :udp_port => '11213', :user => 'somebdy', :max_connections => '8193', :verbosity => 'vvv', :processorcount => 3, :use_sasl => true, :large_mem_pages => true, }, { :package_ensure => 'present', :logfile => '/var/log/memcached.log', :max_memory => '20%', :lock_memory => false, :listen_ip => '127.0.0.1', :tcp_port => '11212', :udp_port => '11213', :user => 'somebdy', :max_connections => '8193', :verbosity => 'vvv', :install_dev => true, :processorcount => 1 }, { :listen_ip => '', }, { :pidfile => false, }, { :pidfile => '/var/log/memcached.pid', }, { :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 { should contain_class("memcached::params") } it { should contain_package("memcached").with_ensure(param_hash[:package_ensure]) } it { should_not contain_firewall('100_tcp_11211_for_memcached') } it { should_not contain_firewall('100_udp_11211_for_memcached') } it { if param_hash[:install_dev] should contain_package("libmemcached-dev").with_ensure(param_hash[:package_ensure]) end } it { should contain_file("/etc/memcached.conf").with( 'owner' => 'root', 'group' => 'root' )} it { if param_hash[:service_manage] == false should_not contain_service('memcached') elsif param_hash[:package_ensure] == 'absent' should contain_service("memcached").with( 'ensure' => 'stopped', 'enable' => false ) else should contain_service("memcached").with( 'ensure' => 'running', 'enable' => true, 'hasrestart' => true, 'hasstatus' => false ) end } it 'should compile the template based on the class parameters' do content = param_value( subject, '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].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 if(param_hash[:lock_memory]) expected_lines.push("-k") end if(param_hash[:pidfile]) expected_lines.push("-P #{param_hash[:pidfile]}") end if(param_hash[:verbosity]) expected_lines.push("-vvv") end if(param_hash[:use_sasl]) expected_lines.push("-S") end if(param_hash[:large_mem_pages]) expected_lines.push("-L") end (content.split("\n") & expected_lines).should =~ expected_lines end end end ['Redhat'].each do |osfamily| describe 'on supported platform' do it 'should fail' do end end end end end end # vim: expandtab shiftwidth=2 softtabstop=2 saz-memcached-2.8.1/manifests/init.pp000644 000765 000024 00000006417 12530673601 017473 0ustar00sazstaff000000 000000 # == Class: memcached # # Manage memcached # # == Parameters # [* syslog *] # Boolean. # If true will pipe output to /bin/logger, sends to syslog. # class memcached ( $package_ensure = 'present', $service_manage = true, $logfile = $::memcached::params::logfile, $syslog = false, $pidfile = '/var/run/memcached.pid', $manage_firewall = false, $max_memory = false, $item_size = false, $lock_memory = false, $listen_ip = '0.0.0.0', $tcp_port = 11211, $udp_port = 11211, $user = $::memcached::params::user, $max_connections = '8192', $verbosity = undef, $unix_socket = undef, $install_dev = false, $processorcount = $::processorcount, $service_restart = true, $auto_removal = false, $use_sasl = false, $use_registry = $::memcached::params::use_registry, $registry_key = 'HKLM\System\CurrentControlSet\services\memcached\ImagePath', $large_mem_pages = false ) inherits memcached::params { # validate type and convert string to boolean if necessary if is_string($manage_firewall) { $manage_firewall_bool = str2bool($manage_firewall) } else { $manage_firewall_bool = $manage_firewall } validate_bool($manage_firewall_bool) validate_bool($service_restart) validate_bool($service_manage) validate_bool($syslog) # 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_bool == true { firewall { "100_tcp_${tcp_port}_for_memcached": port => $tcp_port, proto => 'tcp', action => 'accept', } firewall { "100_udp_${udp_port}_for_memcached": port => $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 => 'root', mode => '0644', content => template($memcached::params::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($memcached::params::config_tmpl), notify => $service_notify_real, } } } saz-memcached-2.8.1/manifests/params.pp000644 000765 000024 00000004067 12530667771 020025 0ustar00sazstaff000000 000000 # == 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 } /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 } /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 } 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 } default: { fail("Unsupported platform: ${::osfamily}/${::operatingsystem}") } } } } } saz-memcached-2.8.1/lib/puppet/000755 000765 000024 00000000000 12535064111 016244 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/lib/puppet/parser/000755 000765 000024 00000000000 12535064111 017540 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/lib/puppet/parser/functions/000755 000765 000024 00000000000 12535064111 021550 5ustar00sazstaff000000 000000 saz-memcached-2.8.1/lib/puppet/parser/functions/memcached_max_memory.rb000644 000765 000024 00000002275 12530662664 026262 0ustar00sazstaff000000 000000 module Puppet::Parser::Functions newfunction(:memcached_max_memory, :type => :rvalue, :doc => <<-EOS Calculate max_memory size from fact 'memsize' and passed argument. EOS ) do |arguments| raise(Puppet::ParseError, "memcached_max_memory(): " + "Wrong number of arguments given " + "(#{arguments.size} for 1)") if arguments.size != 1 arg = arguments[0] memsize = lookupvar('memorysize') if arg and !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 = */([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 return result_in_mb end end