No OneTemporary
Actions

Size

30 KB

Subscribers

None

View Options

	diff --git a/manifests/globals.pp b/manifests/globals.pp
	index f3ad15f..5349b3c 100644
	--- a/manifests/globals.pp
	+++ b/manifests/globals.pp
	@@ -1,151 +1,152 @@
	# Class for setting cross-class global overrides. See README.md for more
	# details.
	class postgresql::globals (
	$client_package_name = undef,
	$server_package_name = undef,
	$contrib_package_name = undef,
	$devel_package_name = undef,
	$java_package_name = undef,
	$docs_package_name = undef,
	$perl_package_name = undef,
	$plperl_package_name = undef,
	$plpython_package_name = undef,
	$python_package_name = undef,
	$postgis_package_name = undef,

	$service_name = undef,
	$service_provider = undef,
	$service_status = undef,
	$default_database = undef,

	$validcon_script_path = undef,

	$initdb_path = undef,
	$createdb_path = undef,
	$psql_path = undef,
	$pg_hba_conf_path = undef,
	$pg_ident_conf_path = undef,
	$postgresql_conf_path = undef,
	$recovery_conf_path = undef,
	$default_connect_settings = {},

	$pg_hba_conf_defaults = undef,

	$datadir = undef,
	$confdir = undef,
	$bindir = undef,
	$xlogdir = undef,
	$logdir = undef,
	+ $log_line_prefix = undef,

	$user = undef,
	$group = undef,

	$version = undef,
	$postgis_version = undef,
	$repo_proxy = undef,

	$needs_initdb = undef,

	$encoding = undef,
	$locale = undef,

	$manage_pg_hba_conf = undef,
	$manage_pg_ident_conf = undef,
	$manage_recovery_conf = undef,

	$manage_package_repo = undef,
	) {
	# We are determining this here, because it is needed by the package repo
	# class.
	$default_version = $::osfamily ? {
	/^(RedHat\|Linux)/ => $::operatingsystem ? {
	'Fedora' => $::operatingsystemrelease ? {
	/^(22)$/ => '9.4',
	/^(21)$/ => '9.3',
	/^(18\|19\|20)$/ => '9.2',
	/^(17)$/ => '9.1',
	default => undef,
	},
	'Amazon' => '9.2',
	default => $::operatingsystemrelease ? {
	/^7\./ => '9.2',
	/^6\./ => '8.4',
	/^5\./ => '8.1',
	default => undef,
	},
	default => $::operatingsystemrelease ? {
	/^7\./ => '9.2',
	/^6\./ => '8.4',
	/^5\./ => '8.1',
	default => undef,
	},
	},
	'Debian' => $::operatingsystem ? {
	'Debian' => $::operatingsystemrelease ? {
	/^6\./ => '8.4',
	/^(wheezy\|7\.)/ => '9.1',
	/^(jessie\|8\.)/ => '9.4',
	default => undef,
	},
	'Ubuntu' => $::operatingsystemrelease ? {
	/^(10.04\|10.10\|11.04)$/ => '8.4',
	/^(11.10\|12.04\|12.10\|13.04\|13.10)$/ => '9.1',
	/^(14.04)$/ => '9.3',
	/^(14.10\|15.04\|15.10)$/ => '9.4',
	/^(16.04)$/ => '9.5',
	default => undef,
	},
	default => undef,
	},
	'Archlinux' => $::operatingsystem ? {
	/Archlinux/ => '9.2',
	default => '9.2',
	},
	'FreeBSD' => '93',
	'OpenBSD' => $::operatingsystemrelease ? {
	/5\.6/ => '9.3',
	/5\.[7-9]/ => '9.4',
	},
	'Suse' => $::operatingsystem ? {
	'SLES' => $::operatingsystemrelease ? {
	/11\.[0-4]/ => '91',
	default => '93',
	},
	'OpenSuSE' => $::operatingsystemrelease ? {
	'13.2' => '93',
	},
	default => undef,
	},
	default => undef,
	}
	$globals_version = pick($version, $default_version, 'unknown')
	if($globals_version == 'unknown') {
	fail('No preferred version defined or automatically detected.')
	}

	$default_postgis_version = $globals_version ? {
	'8.1' => '1.3.6',
	'8.4' => '1.5',
	'9.0' => '1.5',
	'9.1' => '1.5',
	'91' => '1.5',
	'9.2' => '2.0',
	'9.3' => '2.1',
	'93' => '2.1',
	'9.4' => '2.1',
	'9.5' => '2.2',
	default => undef,
	}
	$globals_postgis_version = $postgis_version ? {
	undef => $default_postgis_version,
	default => $postgis_version,
	}

	# Setup of the repo only makes sense globally, so we are doing this here.
	if($manage_package_repo) {
	class { 'postgresql::repo':
	version => $globals_version,
	proxy => $repo_proxy,
	}
	}
	}
	diff --git a/manifests/params.pp b/manifests/params.pp
	index cabe9d9..60331f8 100644
	--- a/manifests/params.pp
	+++ b/manifests/params.pp
	@@ -1,272 +1,273 @@
	# PRIVATE CLASS: do not use directly
	class postgresql::params inherits postgresql::globals {
	$version = $postgresql::globals::globals_version
	$postgis_version = $postgresql::globals::globals_postgis_version
	$listen_addresses = 'localhost'
	$port = 5432
	+ $log_line_prefix = '%t '
	$ip_mask_deny_postgres_user = '0.0.0.0/0'
	$ip_mask_allow_all_users = '127.0.0.1/32'
	$ipv4acls = []
	$ipv6acls = []
	$encoding = $postgresql::globals::encoding
	$locale = $postgresql::globals::locale
	$service_ensure = 'running'
	$service_enable = true
	$service_manage = true
	$service_restart_on_change = true
	$service_provider = $postgresql::globals::service_provider
	$manage_pg_hba_conf = pick($manage_pg_hba_conf, true)
	$manage_pg_ident_conf = pick($manage_pg_ident_conf, true)
	$manage_recovery_conf = pick($manage_recovery_conf, false)
	$package_ensure = 'present'

	# Amazon Linux's OS Family is 'Linux', operating system 'Amazon'.
	case $::osfamily {
	'RedHat', 'Linux': {
	$link_pg_config = true
	$user = pick($user, 'postgres')
	$group = pick($group, 'postgres')
	$needs_initdb = pick($needs_initdb, true)
	$version_parts = split($version, '[.]')
	$package_version = "${version_parts[0]}${version_parts[1]}"

	if $version == $postgresql::globals::default_version and $::operatingsystem != 'Amazon' {
	$client_package_name = pick($client_package_name, 'postgresql')
	$server_package_name = pick($server_package_name, 'postgresql-server')
	$contrib_package_name = pick($contrib_package_name,'postgresql-contrib')
	$devel_package_name = pick($devel_package_name, 'postgresql-devel')
	$java_package_name = pick($java_package_name, 'postgresql-jdbc')
	$docs_package_name = pick($docs_package_name, 'postgresql-docs')
	$plperl_package_name = pick($plperl_package_name, 'postgresql-plperl')
	$plpython_package_name = pick($plpython_package_name, 'postgresql-plpython')
	$service_name = pick($service_name, 'postgresql')
	$bindir = pick($bindir, '/usr/bin')
	$datadir = $::operatingsystem ? {
	'Amazon' => pick($datadir, "/var/lib/pgsql${package_version}/data"),
	default => pick($datadir, '/var/lib/pgsql/data'),
	}
	$confdir = pick($confdir, $datadir)
	} else {
	$client_package_name = pick($client_package_name, "postgresql${package_version}")
	$server_package_name = pick($server_package_name, "postgresql${package_version}-server")
	$contrib_package_name = pick($contrib_package_name,"postgresql${package_version}-contrib")
	$devel_package_name = pick($devel_package_name, "postgresql${package_version}-devel")
	$java_package_name = pick($java_package_name, "postgresql${package_version}-jdbc")
	$docs_package_name = pick($docs_package_name, "postgresql${package_version}-docs")
	$plperl_package_name = pick($plperl_package_name, "postgresql${package_version}-plperl")
	$plpython_package_name = pick($plpython_package_name, "postgresql${package_version}-plpython")
	$service_name = $::operatingsystem ? {
	'Amazon' => pick($service_name, "postgresql${version_parts[0]}${version_parts[1]}"),
	default => pick($service_name, "postgresql-${version}"),
	}
	$bindir = $::operatingsystem ? {
	'Amazon' => pick($bindir, '/usr/bin'),
	default => pick($bindir, "/usr/pgsql-${version}/bin"),
	}
	$datadir = $::operatingsystem ? {
	'Amazon' => pick($datadir, "/var/lib/pgsql${package_version}/data"),
	default => pick($datadir, "/var/lib/pgsql/${version}/data"),
	}
	$confdir = pick($confdir, $datadir)
	}
	$psql_path = pick($psql_path, "${bindir}/psql")

	$service_status = $service_status
	$service_reload = "service ${service_name} reload"
	$perl_package_name = pick($perl_package_name, 'perl-DBD-Pg')
	$python_package_name = pick($python_package_name, 'python-psycopg2')

	if $postgresql::globals::postgis_package_name {
	$postgis_package_name = $postgresql::globals::postgis_package_name
	} elsif $::operatingsystemrelease =~ /^5\./ {
	$postgis_package_name = 'postgis'
	} elsif $postgis_version and versioncmp($postgis_version, '2') < 0 {
	$postgis_package_name = "postgis${package_version}"
	} else {
	$postgis_package_name = "postgis2_${package_version}"
	}
	}

	'Archlinux': {
	$link_pg_config = true
	$needs_initdb = pick($needs_initdb, true)
	$user = pick($user, 'postgres')
	$group = pick($group, 'postgres')

	# Archlinux doesn't have a client-package but has a libs package which
	# pulls in postgresql server
	$client_package_name = pick($client_package_name, 'postgresql')
	$server_package_name = pick($server_package_name, 'postgresql-libs')
	$java_package_name = pick($java_package_name, 'postgresql-jdbc')
	# Archlinux doesn't have develop packages
	$devel_package_name = pick($devel_package_name, 'postgresql-devel')
	# Archlinux does have postgresql-contrib but it isn't maintained
	$contrib_package_name = pick($contrib_package_name,'undef')
	# Archlinux postgresql package provides plperl
	$plperl_package_name = pick($plperl_package_name, 'undef')
	$plpython_package_name = pick($plpython_package_name, 'undef')
	$service_name = pick($service_name, 'postgresql')
	$bindir = pick($bindir, '/usr/bin')
	$datadir = pick($datadir, '/var/lib/postgres/data')
	$confdir = pick($confdir, $datadir)
	$psql_path = pick($psql_path, "${bindir}/psql")

	$service_status = $service_status
	$service_reload = "systemctl reload ${service_name}"
	$python_package_name = pick($python_package_name, 'python-psycopg2')
	# Archlinux does not have a perl::DBD::Pg package
	$perl_package_name = pick($perl_package_name, 'undef')
	}

	'Debian': {
	$link_pg_config = false
	$user = pick($user, 'postgres')
	$group = pick($group, 'postgres')

	if $postgresql::globals::manage_package_repo == true {
	$needs_initdb = pick($needs_initdb, true)
	$service_name = pick($service_name, 'postgresql')
	} else {
	$needs_initdb = pick($needs_initdb, false)
	$service_name = $::operatingsystem ? {
	'Debian' => pick($service_name, 'postgresql'),
	'Ubuntu' => $::lsbmajdistrelease ? {
	/^10/ => pick($service_name, "postgresql-${version}"),
	default => pick($service_name, 'postgresql'),
	},
	default => undef
	}
	}

	$client_package_name = pick($client_package_name, "postgresql-client-${version}")
	$server_package_name = pick($server_package_name, "postgresql-${version}")
	$contrib_package_name = pick($contrib_package_name, "postgresql-contrib-${version}")
	if $postgis_version and versioncmp($postgis_version, '2') < 0 {
	$postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis")
	} else {
	$postgis_package_name = pick($postgis_package_name, "postgresql-${version}-postgis-${postgis_version}")
	}
	$devel_package_name = pick($devel_package_name, 'libpq-dev')
	$java_package_name = pick($java_package_name, 'libpostgresql-jdbc-java')
	$perl_package_name = pick($perl_package_name, 'libdbd-pg-perl')
	$plperl_package_name = pick($plperl_package_name, "postgresql-plperl-${version}")
	$plpython_package_name = pick($plpython_package_name, "postgresql-plpython-${version}")
	$python_package_name = pick($python_package_name, 'python-psycopg2')

	$bindir = pick($bindir, "/usr/lib/postgresql/${version}/bin")
	$datadir = pick($datadir, "/var/lib/postgresql/${version}/main")
	$confdir = pick($confdir, "/etc/postgresql/${version}/main")
	if $::operatingsystem == 'Debian' and versioncmp($::operatingsystemrelease, '8.0') >= 0 {
	# Jessie uses systemd
	$service_status = pick($service_status, "/usr/sbin/service ${service_name}@*-main status")
	} elsif $::operatingsystem == 'Ubuntu' and versioncmp($::operatingsystemrelease, '15.04') >= 0 {
	# Ubuntu releases since vivid use systemd
	$service_status = pick($service_status, "/usr/sbin/service ${service_name} status")
	} else {
	$service_status = pick($service_status, "/etc/init.d/${service_name} status \| /bin/egrep -q 'Running clusters: .+\|online'")
	}
	$service_reload = "service ${service_name} reload"
	$psql_path = pick($psql_path, '/usr/bin/psql')
	}

	'FreeBSD': {
	$link_pg_config = true
	$user = pick($user, 'pgsql')
	$group = pick($group, 'pgsql')

	$client_package_name = pick($client_package_name, "databases/postgresql${version}-client")
	$server_package_name = pick($server_package_name, "databases/postgresql${version}-server")
	$contrib_package_name = pick($contrib_package_name, "databases/postgresql${version}-contrib")
	$devel_package_name = pick($devel_package_name, 'databases/postgresql-libpqxx3')
	$java_package_name = pick($java_package_name, 'databases/postgresql-jdbc')
	$perl_package_name = pick($plperl_package_name, 'databases/p5-DBD-Pg')
	$plperl_package_name = pick($plperl_package_name, "databases/postgresql${version}-plperl")
	$python_package_name = pick($python_package_name, 'databases/py-psycopg2')

	$service_name = pick($service_name, 'postgresql')
	$bindir = pick($bindir, '/usr/local/bin')
	$datadir = pick($datadir, '/usr/local/pgsql/data')
	$confdir = pick($confdir, $datadir)
	$service_status = pick($service_status, "/usr/local/etc/rc.d/${service_name} onestatus")
	$service_reload = "service ${service_name} reload"
	$psql_path = pick($psql_path, "${bindir}/psql")

	$needs_initdb = pick($needs_initdb, true)
	}

	'OpenBSD': {
	$user = pick($user, '_postgresql')
	$group = pick($group, '_postgresql')

	$client_package_name = pick($client_package_name, 'postgresql-client')
	$server_package_name = pick($server_package_name, 'postgresql-server')
	$contrib_package_name = pick($contrib_package_name, 'postgresql-contrib')
	$devel_package_name = pick($devel_package_name, 'postgresql-client')
	$java_package_name = pick($java_package_name, 'postgresql-jdbc')
	$perl_package_name = pick($perl_package_name, 'databases/p5-DBD-Pg')
	$plperl_package_name = undef
	$python_package_name = pick($python_package_name, 'py-psycopg2')

	$service_name = pick($service_name, 'postgresql')
	$bindir = pick($bindir, '/usr/local/bin')
	$datadir = pick($datadir, '/var/postgresql/data')
	$confdir = pick($confdir, $datadir)
	$service_status = pick($service_status, "/etc/rc.d/${service_name} check")
	$service_reload = "/etc/rc.d/${service_name} reload"
	$psql_path = pick($psql_path, "${bindir}/psql")

	$needs_initdb = pick($needs_initdb, true)
	}

	'Suse': {
	$link_pg_config = true
	$user = pick($user, 'postgres')
	$group = pick($group, 'postgres')

	$client_package_name = pick($client_package_name, "postgresql${version}")
	$server_package_name = pick($server_package_name, "postgresql${version}-server")
	$contrib_package_name = pick($contrib_package_name, "postgresql${version}-contrib")
	$devel_package_name = pick($devel_package_name, "postgresql${version}-devel")
	$java_package_name = pick($java_package_name, "postgresql${version}-jdbc")
	$perl_package_name = pick($plperl_package_name, 'perl-DBD-Pg')
	$plperl_package_name = pick($plperl_package_name, "postgresql${version}-plperl")
	$python_package_name = pick($python_package_name, 'python-psycopg2')

	$service_name = pick($service_name, 'postgresql')
	$bindir = pick($bindir, "/usr/lib/postgresql${version}/bin")
	$datadir = pick($datadir, '/var/lib/pgsql/data')
	$confdir = pick($confdir, $datadir)
	$service_status = pick($service_status, "/etc/init.d/${service_name} status")
	$service_reload = "/etc/init.d/${service_name} reload"
	$psql_path = pick($psql_path, "${bindir}/psql")

	$needs_initdb = pick($needs_initdb, true)
	}

	default: {
	$link_pg_config = true
	$psql_path = pick($psql_path, "${bindir}/psql")

	# Since we can't determine defaults on our own, we rely on users setting
	# parameters with the postgresql::globals class. Here we are checking
	# that the mandatory minimum is set for the module to operate.
	$err_prefix = "Module ${module_name} does not provide defaults for osfamily: ${::osfamily} operatingsystem: ${::operatingsystem}; please specify a value for ${module_name}::globals::"
	if ($needs_initdb == undef) { fail("${err_prefix}needs_initdb") }
	if ($service_name == undef) { fail("${err_prefix}service_name") }
	if ($client_package_name == undef) { fail("${err_prefix}client_package_name") }
	if ($server_package_name == undef) { fail("${err_prefix}server_package_name") }
	if ($bindir == undef) { fail("${err_prefix}bindir") }
	if ($datadir == undef) { fail("${err_prefix}datadir") }
	if ($confdir == undef) { fail("${err_prefix}confdir") }
	}
	}

	$validcon_script_path = pick($validcon_script_path, '/usr/local/bin/validate_postgresql_connection.sh')
	$initdb_path = pick($initdb_path, "${bindir}/initdb")
	$pg_hba_conf_path = pick($pg_hba_conf_path, "${confdir}/pg_hba.conf")
	$pg_hba_conf_defaults = pick($pg_hba_conf_defaults, true)
	$pg_ident_conf_path = pick($pg_ident_conf_path, "${confdir}/pg_ident.conf")
	$postgresql_conf_path = pick($postgresql_conf_path, "${confdir}/postgresql.conf")
	$recovery_conf_path = pick($recovery_conf_path, "${datadir}/recovery.conf")
	$default_database = pick($default_database, 'postgres')
	}
	diff --git a/manifests/server.pp b/manifests/server.pp
	index 99b87fd..f4fa2f4 100644
	--- a/manifests/server.pp
	+++ b/manifests/server.pp
	@@ -1,81 +1,83 @@
	# This installs a PostgreSQL server. See README.md for more details.
	class postgresql::server (
	$postgres_password = undef,

	$package_name = $postgresql::params::server_package_name,
	$client_package_name = $postgresql::params::client_package_name,
	$package_ensure = $postgresql::params::package_ensure,

	$plperl_package_name = $postgresql::params::plperl_package_name,
	$plpython_package_name = $postgresql::params::plpython_package_name,

	$service_ensure = $postgresql::params::service_ensure,
	$service_enable = $postgresql::params::service_enable,
	$service_manage = $postgresql::params::service_manage,
	$service_name = $postgresql::params::service_name,
	$service_restart_on_change = $postgresql::params::service_restart_on_change,
	$service_provider = $postgresql::params::service_provider,
	$service_reload = $postgresql::params::service_reload,
	$service_status = $postgresql::params::service_status,
	$default_database = $postgresql::params::default_database,
	$default_connect_settings = $postgresql::globals::default_connect_settings,
	$listen_addresses = $postgresql::params::listen_addresses,
	$port = $postgresql::params::port,
	$ip_mask_deny_postgres_user = $postgresql::params::ip_mask_deny_postgres_user,
	$ip_mask_allow_all_users = $postgresql::params::ip_mask_allow_all_users,
	$ipv4acls = $postgresql::params::ipv4acls,
	$ipv6acls = $postgresql::params::ipv6acls,

	$initdb_path = $postgresql::params::initdb_path,
	$createdb_path = $postgresql::params::createdb_path,
	$psql_path = $postgresql::params::psql_path,
	$pg_hba_conf_path = $postgresql::params::pg_hba_conf_path,
	$pg_ident_conf_path = $postgresql::params::pg_ident_conf_path,
	$postgresql_conf_path = $postgresql::params::postgresql_conf_path,
	$recovery_conf_path = $postgresql::params::recovery_conf_path,

	$datadir = $postgresql::params::datadir,
	$xlogdir = $postgresql::params::xlogdir,
	$logdir = $postgresql::params::logdir,

	+ $log_line_prefix = $postgresql::params::log_line_prefix,
	+
	$pg_hba_conf_defaults = $postgresql::params::pg_hba_conf_defaults,

	$user = $postgresql::params::user,
	$group = $postgresql::params::group,

	$needs_initdb = $postgresql::params::needs_initdb,

	$encoding = $postgresql::params::encoding,
	$locale = $postgresql::params::locale,

	$manage_pg_hba_conf = $postgresql::params::manage_pg_hba_conf,
	$manage_pg_ident_conf = $postgresql::params::manage_pg_ident_conf,
	$manage_recovery_conf = $postgresql::params::manage_recovery_conf,

	#Deprecated
	$version = undef,
	) inherits postgresql::params {
	$pg = 'postgresql::server'

	if $version != undef {
	warning('Passing "version" to postgresql::server is deprecated; please use postgresql::globals instead.')
	$_version = $version
	} else {
	$_version = $postgresql::params::version
	}

	if $createdb_path != undef{
	warning('Passing "createdb_path" to postgresql::server is deprecated, it can be removed safely for the same behaviour')
	}

	# Reload has its own ordering, specified by other defines
	class { "${pg}::reload": require => Class["${pg}::install"] }

	anchor { "${pg}::start": }->
	class { "${pg}::install": }->
	class { "${pg}::initdb": }->
	class { "${pg}::config": }->
	class { "${pg}::service": }->
	class { "${pg}::passwd": }->
	anchor { "${pg}::end": }
	}
	diff --git a/manifests/server/config.pp b/manifests/server/config.pp
	index a1daac8..b00a79b 100644
	--- a/manifests/server/config.pp
	+++ b/manifests/server/config.pp
	@@ -1,185 +1,192 @@
	# PRIVATE CLASS: do not call directly
	class postgresql::server::config {
	$ip_mask_deny_postgres_user = $postgresql::server::ip_mask_deny_postgres_user
	$ip_mask_allow_all_users = $postgresql::server::ip_mask_allow_all_users
	$listen_addresses = $postgresql::server::listen_addresses
	$port = $postgresql::server::port
	$ipv4acls = $postgresql::server::ipv4acls
	$ipv6acls = $postgresql::server::ipv6acls
	$pg_hba_conf_path = $postgresql::server::pg_hba_conf_path
	$pg_ident_conf_path = $postgresql::server::pg_ident_conf_path
	$postgresql_conf_path = $postgresql::server::postgresql_conf_path
	$recovery_conf_path = $postgresql::server::recovery_conf_path
	$pg_hba_conf_defaults = $postgresql::server::pg_hba_conf_defaults
	$user = $postgresql::server::user
	$group = $postgresql::server::group
	$version = $postgresql::server::_version
	$manage_pg_hba_conf = $postgresql::server::manage_pg_hba_conf
	$manage_pg_ident_conf = $postgresql::server::manage_pg_ident_conf
	$manage_recovery_conf = $postgresql::server::manage_recovery_conf
	$datadir = $postgresql::server::datadir
	$logdir = $postgresql::server::logdir
	$service_name = $postgresql::server::service_name
	+ $log_line_prefix = $postgresql::server::log_line_prefix

	if ($manage_pg_hba_conf == true) {
	# Prepare the main pg_hba file
	concat { $pg_hba_conf_path:
	owner => $user,
	group => $group,
	mode => '0640',
	warn => true,
	notify => Class['postgresql::server::reload'],
	}

	if $pg_hba_conf_defaults {
	Postgresql::Server::Pg_hba_rule {
	database => 'all',
	user => 'all',
	}

	# Lets setup the base rules
	$local_auth_option = $version ? {
	'8.1' => 'sameuser',
	default => undef,
	}
	postgresql::server::pg_hba_rule { 'local access as postgres user':
	type => 'local',
	user => $user,
	auth_method => 'ident',
	auth_option => $local_auth_option,
	order => '001',
	}
	postgresql::server::pg_hba_rule { 'local access to database with same name':
	type => 'local',
	auth_method => 'ident',
	auth_option => $local_auth_option,
	order => '002',
	}
	postgresql::server::pg_hba_rule { 'allow localhost TCP access to postgresql user':
	type => 'host',
	user => $user,
	address => '127.0.0.1/32',
	auth_method => 'md5',
	order => '003',
	}
	postgresql::server::pg_hba_rule { 'deny access to postgresql user':
	type => 'host',
	user => $user,
	address => $ip_mask_deny_postgres_user,
	auth_method => 'reject',
	order => '004',
	}

	postgresql::server::pg_hba_rule { 'allow access to all users':
	type => 'host',
	address => $ip_mask_allow_all_users,
	auth_method => 'md5',
	order => '100',
	}
	postgresql::server::pg_hba_rule { 'allow access to ipv6 localhost':
	type => 'host',
	address => '::1/128',
	auth_method => 'md5',
	order => '101',
	}
	}

	# ipv4acls are passed as an array of rule strings, here we transform
	# them into a resources hash, and pass the result to create_resources
	$ipv4acl_resources = postgresql_acls_to_resources_hash($ipv4acls,
	'ipv4acls', 10)
	create_resources('postgresql::server::pg_hba_rule', $ipv4acl_resources)


	# ipv6acls are passed as an array of rule strings, here we transform
	# them into a resources hash, and pass the result to create_resources
	$ipv6acl_resources = postgresql_acls_to_resources_hash($ipv6acls,
	'ipv6acls', 102)
	create_resources('postgresql::server::pg_hba_rule', $ipv6acl_resources)
	}

	# We must set a "listen_addresses" line in the postgresql.conf if we
	# want to allow any connections from remote hosts.
	postgresql::server::config_entry { 'listen_addresses':
	value => $listen_addresses,
	}
	postgresql::server::config_entry { 'port':
	value => $port,
	}
	postgresql::server::config_entry { 'data_directory':
	value => $datadir,
	}
	if $logdir {
	postgresql::server::config_entry { 'log_directory':
	value => $logdir,
	}

	}
	+ # Allow timestamps in log by default
	+ if $log_line_prefix {
	+ postgresql::server::config_entry {'log_line_prefix':
	+ value => $log_line_prefix,
	+ }
	+ }

	# RedHat-based systems hardcode some PG* variables in the init script, and need to be overriden
	# in /etc/sysconfig/pgsql/postgresql. Create a blank file so we can manage it with augeas later.
	if ($::osfamily == 'RedHat') and ($::operatingsystemrelease !~ /^7/) and ($::operatingsystem != 'Fedora') {
	file { '/etc/sysconfig/pgsql/postgresql':
	ensure => present,
	replace => false,
	}

	# The init script from the packages of the postgresql.org repository
	# sources an alternate sysconfig file.
	# I. e. /etc/sysconfig/pgsql/postgresql-9.3 for PostgreSQL 9.3
	# Link to the sysconfig file set by this puppet module
	file { "/etc/sysconfig/pgsql/postgresql-${version}":
	ensure => link,
	target => '/etc/sysconfig/pgsql/postgresql',
	require => File[ '/etc/sysconfig/pgsql/postgresql' ],
	}

	}


	if ($manage_pg_ident_conf == true) {
	concat { $pg_ident_conf_path:
	owner => $user,
	group => $group,
	force => true, # do not crash if there is no pg_ident_rules
	mode => '0640',
	warn => true,
	notify => Class['postgresql::server::reload'],
	}
	}

	if ($manage_recovery_conf == true) {
	concat { $recovery_conf_path:
	owner => $user,
	group => $group,
	force => true, # do not crash if there is no recovery conf file
	mode => '0640',
	warn => true,
	notify => Class['postgresql::server::reload'],
	}
	}

	if $::osfamily == 'RedHat' {
	if $::operatingsystemrelease =~ /^7/ or $::operatingsystem == 'Fedora' {
	# Template uses:
	# - $::operatingsystem
	# - $service_name
	# - $port
	# - $datadir
	file { 'systemd-override':
	ensure => present,
	path => "/etc/systemd/system/${service_name}.service",
	owner => root,
	group => root,
	content => template('postgresql/systemd-override.erb'),
	notify => [ Exec['restart-systemd'], Class['postgresql::server::service'] ],
	before => Class['postgresql::server::reload'],
	}
	exec { 'restart-systemd':
	command => 'systemctl daemon-reload',
	refreshonly => true,
	path => '/bin:/usr/bin:/usr/local/bin'
	}
	}
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Mon, Aug 18, 9:51 PM (2 w, 1 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3291860

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions