repository_name
stringclasses 316
values | func_path_in_repository
stringlengths 6
223
| func_name
stringlengths 1
134
| language
stringclasses 1
value | func_code_string
stringlengths 57
65.5k
| func_documentation_string
stringlengths 1
46.3k
| split_name
stringclasses 1
value | func_code_url
stringlengths 91
315
| called_functions
listlengths 1
156
⌀ | enclosing_scope
stringlengths 2
1.48M
|
|---|---|---|---|---|---|---|---|---|---|
saltstack/salt
|
salt/cli/salt.py
|
SaltCMD._progress_ret
|
python
|
def _progress_ret(self, progress, out):
'''
Print progress events
'''
import salt.output
# Get the progress bar
if not hasattr(self, 'progress_bar'):
try:
self.progress_bar = salt.output.get_progress(self.config, out, progress)
except Exception:
raise LoaderError('\nWARNING: Install the `progressbar` python package. '
'Requested job was still run but output cannot be displayed.\n')
salt.output.update_progress(self.config, progress, self.progress_bar, out)
|
Print progress events
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/cli/salt.py#L350-L362
| null |
class SaltCMD(salt.utils.parsers.SaltCMDOptionParser):
'''
The execution of a salt command happens here
'''
def run(self):
'''
Execute the salt command line
'''
import salt.client
self.parse_args()
if self.config['log_level'] not in ('quiet', ):
# Setup file logging!
self.setup_logfile_logger()
verify_log(self.config)
try:
# We don't need to bail on config file permission errors
# if the CLI process is run with the -a flag
skip_perm_errors = self.options.eauth != ''
self.local_client = salt.client.get_local_client(
self.get_config_file_path(),
skip_perm_errors=skip_perm_errors,
auto_reconnect=True)
except SaltClientError as exc:
self.exit(2, '{0}\n'.format(exc))
return
if self.options.batch or self.options.static:
# _run_batch() will handle all output and
# exit with the appropriate error condition
# Execution will not continue past this point
# in batch mode.
self._run_batch()
return
if self.options.preview_target:
minion_list = self._preview_target()
self._output_ret(minion_list, self.config.get('output', 'nested'))
return
if self.options.timeout <= 0:
self.options.timeout = self.local_client.opts['timeout']
kwargs = {
'tgt': self.config['tgt'],
'fun': self.config['fun'],
'arg': self.config['arg'],
'timeout': self.options.timeout,
'show_timeout': self.options.show_timeout,
'show_jid': self.options.show_jid}
if 'token' in self.config:
import salt.utils.files
try:
with salt.utils.files.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
kwargs['key'] = fp_.readline()
except IOError:
kwargs['token'] = self.config['token']
kwargs['delimiter'] = self.options.delimiter
if self.selected_target_option:
kwargs['tgt_type'] = self.selected_target_option
else:
kwargs['tgt_type'] = 'glob'
# If batch_safe_limit is set, check minions matching target and
# potentially switch to batch execution
if self.options.batch_safe_limit > 1:
if len(self._preview_target()) >= self.options.batch_safe_limit:
salt.utils.stringutils.print_cli('\nNOTICE: Too many minions targeted, switching to batch execution.')
self.options.batch = self.options.batch_safe_size
self._run_batch()
return
if getattr(self.options, 'return'):
kwargs['ret'] = getattr(self.options, 'return')
if getattr(self.options, 'return_config'):
kwargs['ret_config'] = getattr(self.options, 'return_config')
if getattr(self.options, 'return_kwargs'):
kwargs['ret_kwargs'] = yamlify_arg(
getattr(self.options, 'return_kwargs'))
if getattr(self.options, 'module_executors'):
kwargs['module_executors'] = yamlify_arg(getattr(self.options, 'module_executors'))
if getattr(self.options, 'executor_opts'):
kwargs['executor_opts'] = yamlify_arg(getattr(self.options, 'executor_opts'))
if getattr(self.options, 'metadata'):
kwargs['metadata'] = yamlify_arg(
getattr(self.options, 'metadata'))
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in kwargs and 'key' not in kwargs and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
kwargs['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
kwargs.update(res)
kwargs['eauth'] = self.options.eauth
if self.config['async']:
jid = self.local_client.cmd_async(**kwargs)
salt.utils.stringutils.print_cli('Executed command with job ID: {0}'.format(jid))
return
# local will be None when there was an error
if not self.local_client:
return
retcodes = []
errors = []
try:
if self.options.subset:
cmd_func = self.local_client.cmd_subset
kwargs['sub'] = self.options.subset
kwargs['cli'] = True
else:
cmd_func = self.local_client.cmd_cli
if self.options.progress:
kwargs['progress'] = True
self.config['progress'] = True
ret = {}
for progress in cmd_func(**kwargs):
out = 'progress'
try:
self._progress_ret(progress, out)
except LoaderError as exc:
raise SaltSystemExit(exc)
if 'return_count' not in progress:
ret.update(progress)
self._progress_end(out)
self._print_returns_summary(ret)
elif self.config['fun'] == 'sys.doc':
ret = {}
out = ''
for full_ret in self.local_client.cmd_cli(**kwargs):
ret_, out, retcode = self._format_ret(full_ret)
ret.update(ret_)
self._output_ret(ret, out, retcode=retcode)
else:
if self.options.verbose:
kwargs['verbose'] = True
ret = {}
for full_ret in cmd_func(**kwargs):
try:
ret_, out, retcode = self._format_ret(full_ret)
retcodes.append(retcode)
self._output_ret(ret_, out, retcode=retcode)
ret.update(full_ret)
except KeyError:
errors.append(full_ret)
# Returns summary
if self.config['cli_summary'] is True:
if self.config['fun'] != 'sys.doc':
if self.options.output is None:
self._print_returns_summary(ret)
self._print_errors_summary(errors)
# NOTE: Return code is set here based on if all minions
# returned 'ok' with a retcode of 0.
# This is the final point before the 'salt' cmd returns,
# which is why we set the retcode here.
if not all(exit_code == salt.defaults.exitcodes.EX_OK for exit_code in retcodes):
sys.stderr.write('ERROR: Minions returned with non-zero exit code\n')
sys.exit(salt.defaults.exitcodes.EX_GENERIC)
except (AuthenticationError,
AuthorizationError,
SaltInvocationError,
EauthAuthenticationError,
SaltClientError) as exc:
ret = six.text_type(exc)
self._output_ret(ret, '', retcode=1)
def _preview_target(self):
'''
Return a list of minions from a given target
'''
return self.local_client.gather_minions(self.config['tgt'], self.selected_target_option or 'glob')
def _run_batch(self):
import salt.cli.batch
eauth = {}
if 'token' in self.config:
eauth['token'] = self.config['token']
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in eauth and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
eauth['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
eauth.update(res)
eauth['eauth'] = self.options.eauth
if self.options.static:
if not self.options.batch:
self.config['batch'] = '100%'
try:
batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)
except SaltClientError:
sys.exit(2)
ret = {}
for res in batch.run():
ret.update(res)
self._output_ret(ret, '')
else:
try:
self.config['batch'] = self.options.batch
batch = salt.cli.batch.Batch(self.config, eauth=eauth, parser=self.options)
except SaltClientError:
# We will print errors to the console further down the stack
sys.exit(1)
# Printing the output is already taken care of in run() itself
retcode = 0
for res in batch.run():
for ret in six.itervalues(res):
job_retcode = salt.utils.job.get_retcode(ret)
if job_retcode > retcode:
# Exit with the highest retcode we find
retcode = job_retcode
sys.exit(retcode)
def _print_errors_summary(self, errors):
if errors:
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('---------------------------')
salt.utils.stringutils.print_cli('Errors')
salt.utils.stringutils.print_cli('---------------------------')
for error in errors:
salt.utils.stringutils.print_cli(self._format_error(error))
def _print_returns_summary(self, ret):
'''
Display returns summary
'''
return_counter = 0
not_return_counter = 0
not_return_minions = []
not_response_minions = []
not_connected_minions = []
failed_minions = []
for each_minion in ret:
minion_ret = ret[each_minion]
if isinstance(minion_ret, dict) and 'ret' in minion_ret:
minion_ret = ret[each_minion].get('ret')
if (
isinstance(minion_ret, six.string_types)
and minion_ret.startswith("Minion did not return")
):
if "Not connected" in minion_ret:
not_connected_minions.append(each_minion)
elif "No response" in minion_ret:
not_response_minions.append(each_minion)
not_return_counter += 1
not_return_minions.append(each_minion)
else:
return_counter += 1
if self._get_retcode(ret[each_minion]):
failed_minions.append(each_minion)
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('Summary')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
salt.utils.stringutils.print_cli('# of minions returned: {0}'.format(return_counter))
salt.utils.stringutils.print_cli('# of minions that did not return: {0}'.format(not_return_counter))
salt.utils.stringutils.print_cli('# of minions with errors: {0}'.format(len(failed_minions)))
if self.options.verbose:
if not_connected_minions:
salt.utils.stringutils.print_cli('Minions not connected: {0}'.format(" ".join(not_connected_minions)))
if not_response_minions:
salt.utils.stringutils.print_cli('Minions not responding: {0}'.format(" ".join(not_response_minions)))
if failed_minions:
salt.utils.stringutils.print_cli('Minions with failures: {0}'.format(" ".join(failed_minions)))
salt.utils.stringutils.print_cli('-------------------------------------------')
def _progress_end(self, out):
import salt.output
salt.output.progress_end(self.progress_bar)
def _output_ret(self, ret, out, retcode=0):
'''
Print the output from a single return to the terminal
'''
import salt.output
# Handle special case commands
if self.config['fun'] == 'sys.doc' and not isinstance(ret, Exception):
self._print_docs(ret)
else:
# Determine the proper output method and run it
salt.output.display_output(ret,
out=out,
opts=self.config,
_retcode=retcode)
if not ret:
sys.stderr.write('ERROR: No return received\n')
sys.exit(2)
def _format_ret(self, full_ret):
'''
Take the full return data and format it to simple output
'''
ret = {}
out = ''
retcode = 0
for key, data in six.iteritems(full_ret):
ret[key] = data['ret']
if 'out' in data:
out = data['out']
ret_retcode = self._get_retcode(data)
if ret_retcode > retcode:
retcode = ret_retcode
return ret, out, retcode
def _get_retcode(self, ret):
'''
Determine a retcode for a given return
'''
retcode = 0
# if there is a dict with retcode, use that
if isinstance(ret, dict) and ret.get('retcode', 0) != 0:
if isinstance(ret.get('retcode', 0), dict):
return max(six.itervalues(ret.get('retcode', {0: 0})))
return ret['retcode']
# if its a boolean, False means 1
elif isinstance(ret, bool) and not ret:
return 1
return retcode
def _format_error(self, minion_error):
for minion, error_doc in six.iteritems(minion_error):
error = 'Minion [{0}] encountered exception \'{1}\''.format(minion, error_doc['message'])
return error
def _print_docs(self, ret):
'''
Print out the docstrings for all of the functions on the minions
'''
import salt.output
docs = {}
if not ret:
self.exit(2, 'No minions found to gather docs from\n')
if isinstance(ret, six.string_types):
self.exit(2, '{0}\n'.format(ret))
for host in ret:
if isinstance(ret[host], six.string_types) \
and (ret[host].startswith("Minion did not return")
or ret[host] == 'VALUE_TRIMMED'):
continue
for fun in ret[host]:
if fun not in docs and ret[host][fun]:
docs[fun] = ret[host][fun]
if self.options.output:
for fun in sorted(docs):
salt.output.display_output({fun: docs[fun]}, 'nested', self.config)
else:
for fun in sorted(docs):
salt.utils.stringutils.print_cli('{0}:'.format(fun))
salt.utils.stringutils.print_cli(docs[fun])
salt.utils.stringutils.print_cli('')
|
saltstack/salt
|
salt/cli/salt.py
|
SaltCMD._output_ret
|
python
|
def _output_ret(self, ret, out, retcode=0):
'''
Print the output from a single return to the terminal
'''
import salt.output
# Handle special case commands
if self.config['fun'] == 'sys.doc' and not isinstance(ret, Exception):
self._print_docs(ret)
else:
# Determine the proper output method and run it
salt.output.display_output(ret,
out=out,
opts=self.config,
_retcode=retcode)
if not ret:
sys.stderr.write('ERROR: No return received\n')
sys.exit(2)
|
Print the output from a single return to the terminal
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/cli/salt.py#L364-L380
| null |
class SaltCMD(salt.utils.parsers.SaltCMDOptionParser):
'''
The execution of a salt command happens here
'''
def run(self):
'''
Execute the salt command line
'''
import salt.client
self.parse_args()
if self.config['log_level'] not in ('quiet', ):
# Setup file logging!
self.setup_logfile_logger()
verify_log(self.config)
try:
# We don't need to bail on config file permission errors
# if the CLI process is run with the -a flag
skip_perm_errors = self.options.eauth != ''
self.local_client = salt.client.get_local_client(
self.get_config_file_path(),
skip_perm_errors=skip_perm_errors,
auto_reconnect=True)
except SaltClientError as exc:
self.exit(2, '{0}\n'.format(exc))
return
if self.options.batch or self.options.static:
# _run_batch() will handle all output and
# exit with the appropriate error condition
# Execution will not continue past this point
# in batch mode.
self._run_batch()
return
if self.options.preview_target:
minion_list = self._preview_target()
self._output_ret(minion_list, self.config.get('output', 'nested'))
return
if self.options.timeout <= 0:
self.options.timeout = self.local_client.opts['timeout']
kwargs = {
'tgt': self.config['tgt'],
'fun': self.config['fun'],
'arg': self.config['arg'],
'timeout': self.options.timeout,
'show_timeout': self.options.show_timeout,
'show_jid': self.options.show_jid}
if 'token' in self.config:
import salt.utils.files
try:
with salt.utils.files.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
kwargs['key'] = fp_.readline()
except IOError:
kwargs['token'] = self.config['token']
kwargs['delimiter'] = self.options.delimiter
if self.selected_target_option:
kwargs['tgt_type'] = self.selected_target_option
else:
kwargs['tgt_type'] = 'glob'
# If batch_safe_limit is set, check minions matching target and
# potentially switch to batch execution
if self.options.batch_safe_limit > 1:
if len(self._preview_target()) >= self.options.batch_safe_limit:
salt.utils.stringutils.print_cli('\nNOTICE: Too many minions targeted, switching to batch execution.')
self.options.batch = self.options.batch_safe_size
self._run_batch()
return
if getattr(self.options, 'return'):
kwargs['ret'] = getattr(self.options, 'return')
if getattr(self.options, 'return_config'):
kwargs['ret_config'] = getattr(self.options, 'return_config')
if getattr(self.options, 'return_kwargs'):
kwargs['ret_kwargs'] = yamlify_arg(
getattr(self.options, 'return_kwargs'))
if getattr(self.options, 'module_executors'):
kwargs['module_executors'] = yamlify_arg(getattr(self.options, 'module_executors'))
if getattr(self.options, 'executor_opts'):
kwargs['executor_opts'] = yamlify_arg(getattr(self.options, 'executor_opts'))
if getattr(self.options, 'metadata'):
kwargs['metadata'] = yamlify_arg(
getattr(self.options, 'metadata'))
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in kwargs and 'key' not in kwargs and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
kwargs['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
kwargs.update(res)
kwargs['eauth'] = self.options.eauth
if self.config['async']:
jid = self.local_client.cmd_async(**kwargs)
salt.utils.stringutils.print_cli('Executed command with job ID: {0}'.format(jid))
return
# local will be None when there was an error
if not self.local_client:
return
retcodes = []
errors = []
try:
if self.options.subset:
cmd_func = self.local_client.cmd_subset
kwargs['sub'] = self.options.subset
kwargs['cli'] = True
else:
cmd_func = self.local_client.cmd_cli
if self.options.progress:
kwargs['progress'] = True
self.config['progress'] = True
ret = {}
for progress in cmd_func(**kwargs):
out = 'progress'
try:
self._progress_ret(progress, out)
except LoaderError as exc:
raise SaltSystemExit(exc)
if 'return_count' not in progress:
ret.update(progress)
self._progress_end(out)
self._print_returns_summary(ret)
elif self.config['fun'] == 'sys.doc':
ret = {}
out = ''
for full_ret in self.local_client.cmd_cli(**kwargs):
ret_, out, retcode = self._format_ret(full_ret)
ret.update(ret_)
self._output_ret(ret, out, retcode=retcode)
else:
if self.options.verbose:
kwargs['verbose'] = True
ret = {}
for full_ret in cmd_func(**kwargs):
try:
ret_, out, retcode = self._format_ret(full_ret)
retcodes.append(retcode)
self._output_ret(ret_, out, retcode=retcode)
ret.update(full_ret)
except KeyError:
errors.append(full_ret)
# Returns summary
if self.config['cli_summary'] is True:
if self.config['fun'] != 'sys.doc':
if self.options.output is None:
self._print_returns_summary(ret)
self._print_errors_summary(errors)
# NOTE: Return code is set here based on if all minions
# returned 'ok' with a retcode of 0.
# This is the final point before the 'salt' cmd returns,
# which is why we set the retcode here.
if not all(exit_code == salt.defaults.exitcodes.EX_OK for exit_code in retcodes):
sys.stderr.write('ERROR: Minions returned with non-zero exit code\n')
sys.exit(salt.defaults.exitcodes.EX_GENERIC)
except (AuthenticationError,
AuthorizationError,
SaltInvocationError,
EauthAuthenticationError,
SaltClientError) as exc:
ret = six.text_type(exc)
self._output_ret(ret, '', retcode=1)
def _preview_target(self):
'''
Return a list of minions from a given target
'''
return self.local_client.gather_minions(self.config['tgt'], self.selected_target_option or 'glob')
def _run_batch(self):
import salt.cli.batch
eauth = {}
if 'token' in self.config:
eauth['token'] = self.config['token']
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in eauth and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
eauth['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
eauth.update(res)
eauth['eauth'] = self.options.eauth
if self.options.static:
if not self.options.batch:
self.config['batch'] = '100%'
try:
batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)
except SaltClientError:
sys.exit(2)
ret = {}
for res in batch.run():
ret.update(res)
self._output_ret(ret, '')
else:
try:
self.config['batch'] = self.options.batch
batch = salt.cli.batch.Batch(self.config, eauth=eauth, parser=self.options)
except SaltClientError:
# We will print errors to the console further down the stack
sys.exit(1)
# Printing the output is already taken care of in run() itself
retcode = 0
for res in batch.run():
for ret in six.itervalues(res):
job_retcode = salt.utils.job.get_retcode(ret)
if job_retcode > retcode:
# Exit with the highest retcode we find
retcode = job_retcode
sys.exit(retcode)
def _print_errors_summary(self, errors):
if errors:
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('---------------------------')
salt.utils.stringutils.print_cli('Errors')
salt.utils.stringutils.print_cli('---------------------------')
for error in errors:
salt.utils.stringutils.print_cli(self._format_error(error))
def _print_returns_summary(self, ret):
'''
Display returns summary
'''
return_counter = 0
not_return_counter = 0
not_return_minions = []
not_response_minions = []
not_connected_minions = []
failed_minions = []
for each_minion in ret:
minion_ret = ret[each_minion]
if isinstance(minion_ret, dict) and 'ret' in minion_ret:
minion_ret = ret[each_minion].get('ret')
if (
isinstance(minion_ret, six.string_types)
and minion_ret.startswith("Minion did not return")
):
if "Not connected" in minion_ret:
not_connected_minions.append(each_minion)
elif "No response" in minion_ret:
not_response_minions.append(each_minion)
not_return_counter += 1
not_return_minions.append(each_minion)
else:
return_counter += 1
if self._get_retcode(ret[each_minion]):
failed_minions.append(each_minion)
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('Summary')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
salt.utils.stringutils.print_cli('# of minions returned: {0}'.format(return_counter))
salt.utils.stringutils.print_cli('# of minions that did not return: {0}'.format(not_return_counter))
salt.utils.stringutils.print_cli('# of minions with errors: {0}'.format(len(failed_minions)))
if self.options.verbose:
if not_connected_minions:
salt.utils.stringutils.print_cli('Minions not connected: {0}'.format(" ".join(not_connected_minions)))
if not_response_minions:
salt.utils.stringutils.print_cli('Minions not responding: {0}'.format(" ".join(not_response_minions)))
if failed_minions:
salt.utils.stringutils.print_cli('Minions with failures: {0}'.format(" ".join(failed_minions)))
salt.utils.stringutils.print_cli('-------------------------------------------')
def _progress_end(self, out):
import salt.output
salt.output.progress_end(self.progress_bar)
def _progress_ret(self, progress, out):
'''
Print progress events
'''
import salt.output
# Get the progress bar
if not hasattr(self, 'progress_bar'):
try:
self.progress_bar = salt.output.get_progress(self.config, out, progress)
except Exception:
raise LoaderError('\nWARNING: Install the `progressbar` python package. '
'Requested job was still run but output cannot be displayed.\n')
salt.output.update_progress(self.config, progress, self.progress_bar, out)
def _format_ret(self, full_ret):
'''
Take the full return data and format it to simple output
'''
ret = {}
out = ''
retcode = 0
for key, data in six.iteritems(full_ret):
ret[key] = data['ret']
if 'out' in data:
out = data['out']
ret_retcode = self._get_retcode(data)
if ret_retcode > retcode:
retcode = ret_retcode
return ret, out, retcode
def _get_retcode(self, ret):
'''
Determine a retcode for a given return
'''
retcode = 0
# if there is a dict with retcode, use that
if isinstance(ret, dict) and ret.get('retcode', 0) != 0:
if isinstance(ret.get('retcode', 0), dict):
return max(six.itervalues(ret.get('retcode', {0: 0})))
return ret['retcode']
# if its a boolean, False means 1
elif isinstance(ret, bool) and not ret:
return 1
return retcode
def _format_error(self, minion_error):
for minion, error_doc in six.iteritems(minion_error):
error = 'Minion [{0}] encountered exception \'{1}\''.format(minion, error_doc['message'])
return error
def _print_docs(self, ret):
'''
Print out the docstrings for all of the functions on the minions
'''
import salt.output
docs = {}
if not ret:
self.exit(2, 'No minions found to gather docs from\n')
if isinstance(ret, six.string_types):
self.exit(2, '{0}\n'.format(ret))
for host in ret:
if isinstance(ret[host], six.string_types) \
and (ret[host].startswith("Minion did not return")
or ret[host] == 'VALUE_TRIMMED'):
continue
for fun in ret[host]:
if fun not in docs and ret[host][fun]:
docs[fun] = ret[host][fun]
if self.options.output:
for fun in sorted(docs):
salt.output.display_output({fun: docs[fun]}, 'nested', self.config)
else:
for fun in sorted(docs):
salt.utils.stringutils.print_cli('{0}:'.format(fun))
salt.utils.stringutils.print_cli(docs[fun])
salt.utils.stringutils.print_cli('')
|
saltstack/salt
|
salt/cli/salt.py
|
SaltCMD._format_ret
|
python
|
def _format_ret(self, full_ret):
'''
Take the full return data and format it to simple output
'''
ret = {}
out = ''
retcode = 0
for key, data in six.iteritems(full_ret):
ret[key] = data['ret']
if 'out' in data:
out = data['out']
ret_retcode = self._get_retcode(data)
if ret_retcode > retcode:
retcode = ret_retcode
return ret, out, retcode
|
Take the full return data and format it to simple output
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/cli/salt.py#L382-L396
| null |
class SaltCMD(salt.utils.parsers.SaltCMDOptionParser):
'''
The execution of a salt command happens here
'''
def run(self):
'''
Execute the salt command line
'''
import salt.client
self.parse_args()
if self.config['log_level'] not in ('quiet', ):
# Setup file logging!
self.setup_logfile_logger()
verify_log(self.config)
try:
# We don't need to bail on config file permission errors
# if the CLI process is run with the -a flag
skip_perm_errors = self.options.eauth != ''
self.local_client = salt.client.get_local_client(
self.get_config_file_path(),
skip_perm_errors=skip_perm_errors,
auto_reconnect=True)
except SaltClientError as exc:
self.exit(2, '{0}\n'.format(exc))
return
if self.options.batch or self.options.static:
# _run_batch() will handle all output and
# exit with the appropriate error condition
# Execution will not continue past this point
# in batch mode.
self._run_batch()
return
if self.options.preview_target:
minion_list = self._preview_target()
self._output_ret(minion_list, self.config.get('output', 'nested'))
return
if self.options.timeout <= 0:
self.options.timeout = self.local_client.opts['timeout']
kwargs = {
'tgt': self.config['tgt'],
'fun': self.config['fun'],
'arg': self.config['arg'],
'timeout': self.options.timeout,
'show_timeout': self.options.show_timeout,
'show_jid': self.options.show_jid}
if 'token' in self.config:
import salt.utils.files
try:
with salt.utils.files.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
kwargs['key'] = fp_.readline()
except IOError:
kwargs['token'] = self.config['token']
kwargs['delimiter'] = self.options.delimiter
if self.selected_target_option:
kwargs['tgt_type'] = self.selected_target_option
else:
kwargs['tgt_type'] = 'glob'
# If batch_safe_limit is set, check minions matching target and
# potentially switch to batch execution
if self.options.batch_safe_limit > 1:
if len(self._preview_target()) >= self.options.batch_safe_limit:
salt.utils.stringutils.print_cli('\nNOTICE: Too many minions targeted, switching to batch execution.')
self.options.batch = self.options.batch_safe_size
self._run_batch()
return
if getattr(self.options, 'return'):
kwargs['ret'] = getattr(self.options, 'return')
if getattr(self.options, 'return_config'):
kwargs['ret_config'] = getattr(self.options, 'return_config')
if getattr(self.options, 'return_kwargs'):
kwargs['ret_kwargs'] = yamlify_arg(
getattr(self.options, 'return_kwargs'))
if getattr(self.options, 'module_executors'):
kwargs['module_executors'] = yamlify_arg(getattr(self.options, 'module_executors'))
if getattr(self.options, 'executor_opts'):
kwargs['executor_opts'] = yamlify_arg(getattr(self.options, 'executor_opts'))
if getattr(self.options, 'metadata'):
kwargs['metadata'] = yamlify_arg(
getattr(self.options, 'metadata'))
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in kwargs and 'key' not in kwargs and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
kwargs['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
kwargs.update(res)
kwargs['eauth'] = self.options.eauth
if self.config['async']:
jid = self.local_client.cmd_async(**kwargs)
salt.utils.stringutils.print_cli('Executed command with job ID: {0}'.format(jid))
return
# local will be None when there was an error
if not self.local_client:
return
retcodes = []
errors = []
try:
if self.options.subset:
cmd_func = self.local_client.cmd_subset
kwargs['sub'] = self.options.subset
kwargs['cli'] = True
else:
cmd_func = self.local_client.cmd_cli
if self.options.progress:
kwargs['progress'] = True
self.config['progress'] = True
ret = {}
for progress in cmd_func(**kwargs):
out = 'progress'
try:
self._progress_ret(progress, out)
except LoaderError as exc:
raise SaltSystemExit(exc)
if 'return_count' not in progress:
ret.update(progress)
self._progress_end(out)
self._print_returns_summary(ret)
elif self.config['fun'] == 'sys.doc':
ret = {}
out = ''
for full_ret in self.local_client.cmd_cli(**kwargs):
ret_, out, retcode = self._format_ret(full_ret)
ret.update(ret_)
self._output_ret(ret, out, retcode=retcode)
else:
if self.options.verbose:
kwargs['verbose'] = True
ret = {}
for full_ret in cmd_func(**kwargs):
try:
ret_, out, retcode = self._format_ret(full_ret)
retcodes.append(retcode)
self._output_ret(ret_, out, retcode=retcode)
ret.update(full_ret)
except KeyError:
errors.append(full_ret)
# Returns summary
if self.config['cli_summary'] is True:
if self.config['fun'] != 'sys.doc':
if self.options.output is None:
self._print_returns_summary(ret)
self._print_errors_summary(errors)
# NOTE: Return code is set here based on if all minions
# returned 'ok' with a retcode of 0.
# This is the final point before the 'salt' cmd returns,
# which is why we set the retcode here.
if not all(exit_code == salt.defaults.exitcodes.EX_OK for exit_code in retcodes):
sys.stderr.write('ERROR: Minions returned with non-zero exit code\n')
sys.exit(salt.defaults.exitcodes.EX_GENERIC)
except (AuthenticationError,
AuthorizationError,
SaltInvocationError,
EauthAuthenticationError,
SaltClientError) as exc:
ret = six.text_type(exc)
self._output_ret(ret, '', retcode=1)
def _preview_target(self):
'''
Return a list of minions from a given target
'''
return self.local_client.gather_minions(self.config['tgt'], self.selected_target_option or 'glob')
def _run_batch(self):
import salt.cli.batch
eauth = {}
if 'token' in self.config:
eauth['token'] = self.config['token']
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in eauth and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
eauth['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
eauth.update(res)
eauth['eauth'] = self.options.eauth
if self.options.static:
if not self.options.batch:
self.config['batch'] = '100%'
try:
batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)
except SaltClientError:
sys.exit(2)
ret = {}
for res in batch.run():
ret.update(res)
self._output_ret(ret, '')
else:
try:
self.config['batch'] = self.options.batch
batch = salt.cli.batch.Batch(self.config, eauth=eauth, parser=self.options)
except SaltClientError:
# We will print errors to the console further down the stack
sys.exit(1)
# Printing the output is already taken care of in run() itself
retcode = 0
for res in batch.run():
for ret in six.itervalues(res):
job_retcode = salt.utils.job.get_retcode(ret)
if job_retcode > retcode:
# Exit with the highest retcode we find
retcode = job_retcode
sys.exit(retcode)
def _print_errors_summary(self, errors):
if errors:
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('---------------------------')
salt.utils.stringutils.print_cli('Errors')
salt.utils.stringutils.print_cli('---------------------------')
for error in errors:
salt.utils.stringutils.print_cli(self._format_error(error))
def _print_returns_summary(self, ret):
'''
Display returns summary
'''
return_counter = 0
not_return_counter = 0
not_return_minions = []
not_response_minions = []
not_connected_minions = []
failed_minions = []
for each_minion in ret:
minion_ret = ret[each_minion]
if isinstance(minion_ret, dict) and 'ret' in minion_ret:
minion_ret = ret[each_minion].get('ret')
if (
isinstance(minion_ret, six.string_types)
and minion_ret.startswith("Minion did not return")
):
if "Not connected" in minion_ret:
not_connected_minions.append(each_minion)
elif "No response" in minion_ret:
not_response_minions.append(each_minion)
not_return_counter += 1
not_return_minions.append(each_minion)
else:
return_counter += 1
if self._get_retcode(ret[each_minion]):
failed_minions.append(each_minion)
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('Summary')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
salt.utils.stringutils.print_cli('# of minions returned: {0}'.format(return_counter))
salt.utils.stringutils.print_cli('# of minions that did not return: {0}'.format(not_return_counter))
salt.utils.stringutils.print_cli('# of minions with errors: {0}'.format(len(failed_minions)))
if self.options.verbose:
if not_connected_minions:
salt.utils.stringutils.print_cli('Minions not connected: {0}'.format(" ".join(not_connected_minions)))
if not_response_minions:
salt.utils.stringutils.print_cli('Minions not responding: {0}'.format(" ".join(not_response_minions)))
if failed_minions:
salt.utils.stringutils.print_cli('Minions with failures: {0}'.format(" ".join(failed_minions)))
salt.utils.stringutils.print_cli('-------------------------------------------')
def _progress_end(self, out):
import salt.output
salt.output.progress_end(self.progress_bar)
def _progress_ret(self, progress, out):
'''
Print progress events
'''
import salt.output
# Get the progress bar
if not hasattr(self, 'progress_bar'):
try:
self.progress_bar = salt.output.get_progress(self.config, out, progress)
except Exception:
raise LoaderError('\nWARNING: Install the `progressbar` python package. '
'Requested job was still run but output cannot be displayed.\n')
salt.output.update_progress(self.config, progress, self.progress_bar, out)
def _output_ret(self, ret, out, retcode=0):
'''
Print the output from a single return to the terminal
'''
import salt.output
# Handle special case commands
if self.config['fun'] == 'sys.doc' and not isinstance(ret, Exception):
self._print_docs(ret)
else:
# Determine the proper output method and run it
salt.output.display_output(ret,
out=out,
opts=self.config,
_retcode=retcode)
if not ret:
sys.stderr.write('ERROR: No return received\n')
sys.exit(2)
def _get_retcode(self, ret):
'''
Determine a retcode for a given return
'''
retcode = 0
# if there is a dict with retcode, use that
if isinstance(ret, dict) and ret.get('retcode', 0) != 0:
if isinstance(ret.get('retcode', 0), dict):
return max(six.itervalues(ret.get('retcode', {0: 0})))
return ret['retcode']
# if its a boolean, False means 1
elif isinstance(ret, bool) and not ret:
return 1
return retcode
def _format_error(self, minion_error):
for minion, error_doc in six.iteritems(minion_error):
error = 'Minion [{0}] encountered exception \'{1}\''.format(minion, error_doc['message'])
return error
def _print_docs(self, ret):
'''
Print out the docstrings for all of the functions on the minions
'''
import salt.output
docs = {}
if not ret:
self.exit(2, 'No minions found to gather docs from\n')
if isinstance(ret, six.string_types):
self.exit(2, '{0}\n'.format(ret))
for host in ret:
if isinstance(ret[host], six.string_types) \
and (ret[host].startswith("Minion did not return")
or ret[host] == 'VALUE_TRIMMED'):
continue
for fun in ret[host]:
if fun not in docs and ret[host][fun]:
docs[fun] = ret[host][fun]
if self.options.output:
for fun in sorted(docs):
salt.output.display_output({fun: docs[fun]}, 'nested', self.config)
else:
for fun in sorted(docs):
salt.utils.stringutils.print_cli('{0}:'.format(fun))
salt.utils.stringutils.print_cli(docs[fun])
salt.utils.stringutils.print_cli('')
|
saltstack/salt
|
salt/cli/salt.py
|
SaltCMD._get_retcode
|
python
|
def _get_retcode(self, ret):
'''
Determine a retcode for a given return
'''
retcode = 0
# if there is a dict with retcode, use that
if isinstance(ret, dict) and ret.get('retcode', 0) != 0:
if isinstance(ret.get('retcode', 0), dict):
return max(six.itervalues(ret.get('retcode', {0: 0})))
return ret['retcode']
# if its a boolean, False means 1
elif isinstance(ret, bool) and not ret:
return 1
return retcode
|
Determine a retcode for a given return
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/cli/salt.py#L398-L411
| null |
class SaltCMD(salt.utils.parsers.SaltCMDOptionParser):
'''
The execution of a salt command happens here
'''
def run(self):
'''
Execute the salt command line
'''
import salt.client
self.parse_args()
if self.config['log_level'] not in ('quiet', ):
# Setup file logging!
self.setup_logfile_logger()
verify_log(self.config)
try:
# We don't need to bail on config file permission errors
# if the CLI process is run with the -a flag
skip_perm_errors = self.options.eauth != ''
self.local_client = salt.client.get_local_client(
self.get_config_file_path(),
skip_perm_errors=skip_perm_errors,
auto_reconnect=True)
except SaltClientError as exc:
self.exit(2, '{0}\n'.format(exc))
return
if self.options.batch or self.options.static:
# _run_batch() will handle all output and
# exit with the appropriate error condition
# Execution will not continue past this point
# in batch mode.
self._run_batch()
return
if self.options.preview_target:
minion_list = self._preview_target()
self._output_ret(minion_list, self.config.get('output', 'nested'))
return
if self.options.timeout <= 0:
self.options.timeout = self.local_client.opts['timeout']
kwargs = {
'tgt': self.config['tgt'],
'fun': self.config['fun'],
'arg': self.config['arg'],
'timeout': self.options.timeout,
'show_timeout': self.options.show_timeout,
'show_jid': self.options.show_jid}
if 'token' in self.config:
import salt.utils.files
try:
with salt.utils.files.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
kwargs['key'] = fp_.readline()
except IOError:
kwargs['token'] = self.config['token']
kwargs['delimiter'] = self.options.delimiter
if self.selected_target_option:
kwargs['tgt_type'] = self.selected_target_option
else:
kwargs['tgt_type'] = 'glob'
# If batch_safe_limit is set, check minions matching target and
# potentially switch to batch execution
if self.options.batch_safe_limit > 1:
if len(self._preview_target()) >= self.options.batch_safe_limit:
salt.utils.stringutils.print_cli('\nNOTICE: Too many minions targeted, switching to batch execution.')
self.options.batch = self.options.batch_safe_size
self._run_batch()
return
if getattr(self.options, 'return'):
kwargs['ret'] = getattr(self.options, 'return')
if getattr(self.options, 'return_config'):
kwargs['ret_config'] = getattr(self.options, 'return_config')
if getattr(self.options, 'return_kwargs'):
kwargs['ret_kwargs'] = yamlify_arg(
getattr(self.options, 'return_kwargs'))
if getattr(self.options, 'module_executors'):
kwargs['module_executors'] = yamlify_arg(getattr(self.options, 'module_executors'))
if getattr(self.options, 'executor_opts'):
kwargs['executor_opts'] = yamlify_arg(getattr(self.options, 'executor_opts'))
if getattr(self.options, 'metadata'):
kwargs['metadata'] = yamlify_arg(
getattr(self.options, 'metadata'))
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in kwargs and 'key' not in kwargs and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
kwargs['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
kwargs.update(res)
kwargs['eauth'] = self.options.eauth
if self.config['async']:
jid = self.local_client.cmd_async(**kwargs)
salt.utils.stringutils.print_cli('Executed command with job ID: {0}'.format(jid))
return
# local will be None when there was an error
if not self.local_client:
return
retcodes = []
errors = []
try:
if self.options.subset:
cmd_func = self.local_client.cmd_subset
kwargs['sub'] = self.options.subset
kwargs['cli'] = True
else:
cmd_func = self.local_client.cmd_cli
if self.options.progress:
kwargs['progress'] = True
self.config['progress'] = True
ret = {}
for progress in cmd_func(**kwargs):
out = 'progress'
try:
self._progress_ret(progress, out)
except LoaderError as exc:
raise SaltSystemExit(exc)
if 'return_count' not in progress:
ret.update(progress)
self._progress_end(out)
self._print_returns_summary(ret)
elif self.config['fun'] == 'sys.doc':
ret = {}
out = ''
for full_ret in self.local_client.cmd_cli(**kwargs):
ret_, out, retcode = self._format_ret(full_ret)
ret.update(ret_)
self._output_ret(ret, out, retcode=retcode)
else:
if self.options.verbose:
kwargs['verbose'] = True
ret = {}
for full_ret in cmd_func(**kwargs):
try:
ret_, out, retcode = self._format_ret(full_ret)
retcodes.append(retcode)
self._output_ret(ret_, out, retcode=retcode)
ret.update(full_ret)
except KeyError:
errors.append(full_ret)
# Returns summary
if self.config['cli_summary'] is True:
if self.config['fun'] != 'sys.doc':
if self.options.output is None:
self._print_returns_summary(ret)
self._print_errors_summary(errors)
# NOTE: Return code is set here based on if all minions
# returned 'ok' with a retcode of 0.
# This is the final point before the 'salt' cmd returns,
# which is why we set the retcode here.
if not all(exit_code == salt.defaults.exitcodes.EX_OK for exit_code in retcodes):
sys.stderr.write('ERROR: Minions returned with non-zero exit code\n')
sys.exit(salt.defaults.exitcodes.EX_GENERIC)
except (AuthenticationError,
AuthorizationError,
SaltInvocationError,
EauthAuthenticationError,
SaltClientError) as exc:
ret = six.text_type(exc)
self._output_ret(ret, '', retcode=1)
def _preview_target(self):
'''
Return a list of minions from a given target
'''
return self.local_client.gather_minions(self.config['tgt'], self.selected_target_option or 'glob')
def _run_batch(self):
import salt.cli.batch
eauth = {}
if 'token' in self.config:
eauth['token'] = self.config['token']
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in eauth and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
eauth['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
eauth.update(res)
eauth['eauth'] = self.options.eauth
if self.options.static:
if not self.options.batch:
self.config['batch'] = '100%'
try:
batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)
except SaltClientError:
sys.exit(2)
ret = {}
for res in batch.run():
ret.update(res)
self._output_ret(ret, '')
else:
try:
self.config['batch'] = self.options.batch
batch = salt.cli.batch.Batch(self.config, eauth=eauth, parser=self.options)
except SaltClientError:
# We will print errors to the console further down the stack
sys.exit(1)
# Printing the output is already taken care of in run() itself
retcode = 0
for res in batch.run():
for ret in six.itervalues(res):
job_retcode = salt.utils.job.get_retcode(ret)
if job_retcode > retcode:
# Exit with the highest retcode we find
retcode = job_retcode
sys.exit(retcode)
def _print_errors_summary(self, errors):
if errors:
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('---------------------------')
salt.utils.stringutils.print_cli('Errors')
salt.utils.stringutils.print_cli('---------------------------')
for error in errors:
salt.utils.stringutils.print_cli(self._format_error(error))
def _print_returns_summary(self, ret):
'''
Display returns summary
'''
return_counter = 0
not_return_counter = 0
not_return_minions = []
not_response_minions = []
not_connected_minions = []
failed_minions = []
for each_minion in ret:
minion_ret = ret[each_minion]
if isinstance(minion_ret, dict) and 'ret' in minion_ret:
minion_ret = ret[each_minion].get('ret')
if (
isinstance(minion_ret, six.string_types)
and minion_ret.startswith("Minion did not return")
):
if "Not connected" in minion_ret:
not_connected_minions.append(each_minion)
elif "No response" in minion_ret:
not_response_minions.append(each_minion)
not_return_counter += 1
not_return_minions.append(each_minion)
else:
return_counter += 1
if self._get_retcode(ret[each_minion]):
failed_minions.append(each_minion)
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('Summary')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
salt.utils.stringutils.print_cli('# of minions returned: {0}'.format(return_counter))
salt.utils.stringutils.print_cli('# of minions that did not return: {0}'.format(not_return_counter))
salt.utils.stringutils.print_cli('# of minions with errors: {0}'.format(len(failed_minions)))
if self.options.verbose:
if not_connected_minions:
salt.utils.stringutils.print_cli('Minions not connected: {0}'.format(" ".join(not_connected_minions)))
if not_response_minions:
salt.utils.stringutils.print_cli('Minions not responding: {0}'.format(" ".join(not_response_minions)))
if failed_minions:
salt.utils.stringutils.print_cli('Minions with failures: {0}'.format(" ".join(failed_minions)))
salt.utils.stringutils.print_cli('-------------------------------------------')
def _progress_end(self, out):
import salt.output
salt.output.progress_end(self.progress_bar)
def _progress_ret(self, progress, out):
'''
Print progress events
'''
import salt.output
# Get the progress bar
if not hasattr(self, 'progress_bar'):
try:
self.progress_bar = salt.output.get_progress(self.config, out, progress)
except Exception:
raise LoaderError('\nWARNING: Install the `progressbar` python package. '
'Requested job was still run but output cannot be displayed.\n')
salt.output.update_progress(self.config, progress, self.progress_bar, out)
def _output_ret(self, ret, out, retcode=0):
'''
Print the output from a single return to the terminal
'''
import salt.output
# Handle special case commands
if self.config['fun'] == 'sys.doc' and not isinstance(ret, Exception):
self._print_docs(ret)
else:
# Determine the proper output method and run it
salt.output.display_output(ret,
out=out,
opts=self.config,
_retcode=retcode)
if not ret:
sys.stderr.write('ERROR: No return received\n')
sys.exit(2)
def _format_ret(self, full_ret):
'''
Take the full return data and format it to simple output
'''
ret = {}
out = ''
retcode = 0
for key, data in six.iteritems(full_ret):
ret[key] = data['ret']
if 'out' in data:
out = data['out']
ret_retcode = self._get_retcode(data)
if ret_retcode > retcode:
retcode = ret_retcode
return ret, out, retcode
def _format_error(self, minion_error):
for minion, error_doc in six.iteritems(minion_error):
error = 'Minion [{0}] encountered exception \'{1}\''.format(minion, error_doc['message'])
return error
def _print_docs(self, ret):
'''
Print out the docstrings for all of the functions on the minions
'''
import salt.output
docs = {}
if not ret:
self.exit(2, 'No minions found to gather docs from\n')
if isinstance(ret, six.string_types):
self.exit(2, '{0}\n'.format(ret))
for host in ret:
if isinstance(ret[host], six.string_types) \
and (ret[host].startswith("Minion did not return")
or ret[host] == 'VALUE_TRIMMED'):
continue
for fun in ret[host]:
if fun not in docs and ret[host][fun]:
docs[fun] = ret[host][fun]
if self.options.output:
for fun in sorted(docs):
salt.output.display_output({fun: docs[fun]}, 'nested', self.config)
else:
for fun in sorted(docs):
salt.utils.stringutils.print_cli('{0}:'.format(fun))
salt.utils.stringutils.print_cli(docs[fun])
salt.utils.stringutils.print_cli('')
|
saltstack/salt
|
salt/cli/salt.py
|
SaltCMD._print_docs
|
python
|
def _print_docs(self, ret):
'''
Print out the docstrings for all of the functions on the minions
'''
import salt.output
docs = {}
if not ret:
self.exit(2, 'No minions found to gather docs from\n')
if isinstance(ret, six.string_types):
self.exit(2, '{0}\n'.format(ret))
for host in ret:
if isinstance(ret[host], six.string_types) \
and (ret[host].startswith("Minion did not return")
or ret[host] == 'VALUE_TRIMMED'):
continue
for fun in ret[host]:
if fun not in docs and ret[host][fun]:
docs[fun] = ret[host][fun]
if self.options.output:
for fun in sorted(docs):
salt.output.display_output({fun: docs[fun]}, 'nested', self.config)
else:
for fun in sorted(docs):
salt.utils.stringutils.print_cli('{0}:'.format(fun))
salt.utils.stringutils.print_cli(docs[fun])
salt.utils.stringutils.print_cli('')
|
Print out the docstrings for all of the functions on the minions
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/cli/salt.py#L418-L443
| null |
class SaltCMD(salt.utils.parsers.SaltCMDOptionParser):
'''
The execution of a salt command happens here
'''
def run(self):
'''
Execute the salt command line
'''
import salt.client
self.parse_args()
if self.config['log_level'] not in ('quiet', ):
# Setup file logging!
self.setup_logfile_logger()
verify_log(self.config)
try:
# We don't need to bail on config file permission errors
# if the CLI process is run with the -a flag
skip_perm_errors = self.options.eauth != ''
self.local_client = salt.client.get_local_client(
self.get_config_file_path(),
skip_perm_errors=skip_perm_errors,
auto_reconnect=True)
except SaltClientError as exc:
self.exit(2, '{0}\n'.format(exc))
return
if self.options.batch or self.options.static:
# _run_batch() will handle all output and
# exit with the appropriate error condition
# Execution will not continue past this point
# in batch mode.
self._run_batch()
return
if self.options.preview_target:
minion_list = self._preview_target()
self._output_ret(minion_list, self.config.get('output', 'nested'))
return
if self.options.timeout <= 0:
self.options.timeout = self.local_client.opts['timeout']
kwargs = {
'tgt': self.config['tgt'],
'fun': self.config['fun'],
'arg': self.config['arg'],
'timeout': self.options.timeout,
'show_timeout': self.options.show_timeout,
'show_jid': self.options.show_jid}
if 'token' in self.config:
import salt.utils.files
try:
with salt.utils.files.fopen(os.path.join(self.config['cachedir'], '.root_key'), 'r') as fp_:
kwargs['key'] = fp_.readline()
except IOError:
kwargs['token'] = self.config['token']
kwargs['delimiter'] = self.options.delimiter
if self.selected_target_option:
kwargs['tgt_type'] = self.selected_target_option
else:
kwargs['tgt_type'] = 'glob'
# If batch_safe_limit is set, check minions matching target and
# potentially switch to batch execution
if self.options.batch_safe_limit > 1:
if len(self._preview_target()) >= self.options.batch_safe_limit:
salt.utils.stringutils.print_cli('\nNOTICE: Too many minions targeted, switching to batch execution.')
self.options.batch = self.options.batch_safe_size
self._run_batch()
return
if getattr(self.options, 'return'):
kwargs['ret'] = getattr(self.options, 'return')
if getattr(self.options, 'return_config'):
kwargs['ret_config'] = getattr(self.options, 'return_config')
if getattr(self.options, 'return_kwargs'):
kwargs['ret_kwargs'] = yamlify_arg(
getattr(self.options, 'return_kwargs'))
if getattr(self.options, 'module_executors'):
kwargs['module_executors'] = yamlify_arg(getattr(self.options, 'module_executors'))
if getattr(self.options, 'executor_opts'):
kwargs['executor_opts'] = yamlify_arg(getattr(self.options, 'executor_opts'))
if getattr(self.options, 'metadata'):
kwargs['metadata'] = yamlify_arg(
getattr(self.options, 'metadata'))
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in kwargs and 'key' not in kwargs and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
kwargs['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
kwargs.update(res)
kwargs['eauth'] = self.options.eauth
if self.config['async']:
jid = self.local_client.cmd_async(**kwargs)
salt.utils.stringutils.print_cli('Executed command with job ID: {0}'.format(jid))
return
# local will be None when there was an error
if not self.local_client:
return
retcodes = []
errors = []
try:
if self.options.subset:
cmd_func = self.local_client.cmd_subset
kwargs['sub'] = self.options.subset
kwargs['cli'] = True
else:
cmd_func = self.local_client.cmd_cli
if self.options.progress:
kwargs['progress'] = True
self.config['progress'] = True
ret = {}
for progress in cmd_func(**kwargs):
out = 'progress'
try:
self._progress_ret(progress, out)
except LoaderError as exc:
raise SaltSystemExit(exc)
if 'return_count' not in progress:
ret.update(progress)
self._progress_end(out)
self._print_returns_summary(ret)
elif self.config['fun'] == 'sys.doc':
ret = {}
out = ''
for full_ret in self.local_client.cmd_cli(**kwargs):
ret_, out, retcode = self._format_ret(full_ret)
ret.update(ret_)
self._output_ret(ret, out, retcode=retcode)
else:
if self.options.verbose:
kwargs['verbose'] = True
ret = {}
for full_ret in cmd_func(**kwargs):
try:
ret_, out, retcode = self._format_ret(full_ret)
retcodes.append(retcode)
self._output_ret(ret_, out, retcode=retcode)
ret.update(full_ret)
except KeyError:
errors.append(full_ret)
# Returns summary
if self.config['cli_summary'] is True:
if self.config['fun'] != 'sys.doc':
if self.options.output is None:
self._print_returns_summary(ret)
self._print_errors_summary(errors)
# NOTE: Return code is set here based on if all minions
# returned 'ok' with a retcode of 0.
# This is the final point before the 'salt' cmd returns,
# which is why we set the retcode here.
if not all(exit_code == salt.defaults.exitcodes.EX_OK for exit_code in retcodes):
sys.stderr.write('ERROR: Minions returned with non-zero exit code\n')
sys.exit(salt.defaults.exitcodes.EX_GENERIC)
except (AuthenticationError,
AuthorizationError,
SaltInvocationError,
EauthAuthenticationError,
SaltClientError) as exc:
ret = six.text_type(exc)
self._output_ret(ret, '', retcode=1)
def _preview_target(self):
'''
Return a list of minions from a given target
'''
return self.local_client.gather_minions(self.config['tgt'], self.selected_target_option or 'glob')
def _run_batch(self):
import salt.cli.batch
eauth = {}
if 'token' in self.config:
eauth['token'] = self.config['token']
# If using eauth and a token hasn't already been loaded into
# kwargs, prompt the user to enter auth credentials
if 'token' not in eauth and self.options.eauth:
# This is expensive. Don't do it unless we need to.
import salt.auth
resolver = salt.auth.Resolver(self.config)
res = resolver.cli(self.options.eauth)
if self.options.mktoken and res:
tok = resolver.token_cli(
self.options.eauth,
res
)
if tok:
eauth['token'] = tok.get('token', '')
if not res:
sys.stderr.write('ERROR: Authentication failed\n')
sys.exit(2)
eauth.update(res)
eauth['eauth'] = self.options.eauth
if self.options.static:
if not self.options.batch:
self.config['batch'] = '100%'
try:
batch = salt.cli.batch.Batch(self.config, eauth=eauth, quiet=True)
except SaltClientError:
sys.exit(2)
ret = {}
for res in batch.run():
ret.update(res)
self._output_ret(ret, '')
else:
try:
self.config['batch'] = self.options.batch
batch = salt.cli.batch.Batch(self.config, eauth=eauth, parser=self.options)
except SaltClientError:
# We will print errors to the console further down the stack
sys.exit(1)
# Printing the output is already taken care of in run() itself
retcode = 0
for res in batch.run():
for ret in six.itervalues(res):
job_retcode = salt.utils.job.get_retcode(ret)
if job_retcode > retcode:
# Exit with the highest retcode we find
retcode = job_retcode
sys.exit(retcode)
def _print_errors_summary(self, errors):
if errors:
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('---------------------------')
salt.utils.stringutils.print_cli('Errors')
salt.utils.stringutils.print_cli('---------------------------')
for error in errors:
salt.utils.stringutils.print_cli(self._format_error(error))
def _print_returns_summary(self, ret):
'''
Display returns summary
'''
return_counter = 0
not_return_counter = 0
not_return_minions = []
not_response_minions = []
not_connected_minions = []
failed_minions = []
for each_minion in ret:
minion_ret = ret[each_minion]
if isinstance(minion_ret, dict) and 'ret' in minion_ret:
minion_ret = ret[each_minion].get('ret')
if (
isinstance(minion_ret, six.string_types)
and minion_ret.startswith("Minion did not return")
):
if "Not connected" in minion_ret:
not_connected_minions.append(each_minion)
elif "No response" in minion_ret:
not_response_minions.append(each_minion)
not_return_counter += 1
not_return_minions.append(each_minion)
else:
return_counter += 1
if self._get_retcode(ret[each_minion]):
failed_minions.append(each_minion)
salt.utils.stringutils.print_cli('\n')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('Summary')
salt.utils.stringutils.print_cli('-------------------------------------------')
salt.utils.stringutils.print_cli('# of minions targeted: {0}'.format(return_counter + not_return_counter))
salt.utils.stringutils.print_cli('# of minions returned: {0}'.format(return_counter))
salt.utils.stringutils.print_cli('# of minions that did not return: {0}'.format(not_return_counter))
salt.utils.stringutils.print_cli('# of minions with errors: {0}'.format(len(failed_minions)))
if self.options.verbose:
if not_connected_minions:
salt.utils.stringutils.print_cli('Minions not connected: {0}'.format(" ".join(not_connected_minions)))
if not_response_minions:
salt.utils.stringutils.print_cli('Minions not responding: {0}'.format(" ".join(not_response_minions)))
if failed_minions:
salt.utils.stringutils.print_cli('Minions with failures: {0}'.format(" ".join(failed_minions)))
salt.utils.stringutils.print_cli('-------------------------------------------')
def _progress_end(self, out):
import salt.output
salt.output.progress_end(self.progress_bar)
def _progress_ret(self, progress, out):
'''
Print progress events
'''
import salt.output
# Get the progress bar
if not hasattr(self, 'progress_bar'):
try:
self.progress_bar = salt.output.get_progress(self.config, out, progress)
except Exception:
raise LoaderError('\nWARNING: Install the `progressbar` python package. '
'Requested job was still run but output cannot be displayed.\n')
salt.output.update_progress(self.config, progress, self.progress_bar, out)
def _output_ret(self, ret, out, retcode=0):
'''
Print the output from a single return to the terminal
'''
import salt.output
# Handle special case commands
if self.config['fun'] == 'sys.doc' and not isinstance(ret, Exception):
self._print_docs(ret)
else:
# Determine the proper output method and run it
salt.output.display_output(ret,
out=out,
opts=self.config,
_retcode=retcode)
if not ret:
sys.stderr.write('ERROR: No return received\n')
sys.exit(2)
def _format_ret(self, full_ret):
'''
Take the full return data and format it to simple output
'''
ret = {}
out = ''
retcode = 0
for key, data in six.iteritems(full_ret):
ret[key] = data['ret']
if 'out' in data:
out = data['out']
ret_retcode = self._get_retcode(data)
if ret_retcode > retcode:
retcode = ret_retcode
return ret, out, retcode
def _get_retcode(self, ret):
'''
Determine a retcode for a given return
'''
retcode = 0
# if there is a dict with retcode, use that
if isinstance(ret, dict) and ret.get('retcode', 0) != 0:
if isinstance(ret.get('retcode', 0), dict):
return max(six.itervalues(ret.get('retcode', {0: 0})))
return ret['retcode']
# if its a boolean, False means 1
elif isinstance(ret, bool) and not ret:
return 1
return retcode
def _format_error(self, minion_error):
for minion, error_doc in six.iteritems(minion_error):
error = 'Minion [{0}] encountered exception \'{1}\''.format(minion, error_doc['message'])
return error
|
saltstack/salt
|
salt/utils/yamlencoding.py
|
yaml_dquote
|
python
|
def yaml_dquote(text):
'''
Make text into a double-quoted YAML string with correct escaping
for special characters. Includes the opening and closing double
quote characters.
'''
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_double_quoted(six.text_type(text))
return ostream.getvalue()
|
Make text into a double-quoted YAML string with correct escaping
for special characters. Includes the opening and closing double
quote characters.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/utils/yamlencoding.py#L19-L28
| null |
# -*- coding: utf-8 -*-
'''
Functions for adding yaml encoding to the jinja context
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import io
# Import 3rd-party libs
import yaml # pylint: disable=blacklisted-import
from salt.ext import six
# Import salt libs
from salt.utils.decorators.jinja import jinja_filter
@jinja_filter()
@jinja_filter()
def yaml_squote(text):
'''
Make text into a single-quoted YAML string with correct escaping
for special characters. Includes the opening and closing single
quote characters.
'''
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_single_quoted(six.text_type(text))
return ostream.getvalue()
@jinja_filter()
def yaml_encode(data):
'''
A simple YAML encode that can take a single-element datatype and return
a string representation.
'''
yrepr = yaml.representer.SafeRepresenter()
ynode = yrepr.represent_data(data)
if not isinstance(ynode, yaml.ScalarNode):
raise TypeError(
"yaml_encode() only works with YAML scalar data;"
" failed for {0}".format(type(data))
)
tag = ynode.tag.rsplit(':', 1)[-1]
ret = ynode.value
if tag == "str":
ret = yaml_dquote(ynode.value)
return ret
|
saltstack/salt
|
salt/utils/yamlencoding.py
|
yaml_squote
|
python
|
def yaml_squote(text):
'''
Make text into a single-quoted YAML string with correct escaping
for special characters. Includes the opening and closing single
quote characters.
'''
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_single_quoted(six.text_type(text))
return ostream.getvalue()
|
Make text into a single-quoted YAML string with correct escaping
for special characters. Includes the opening and closing single
quote characters.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/utils/yamlencoding.py#L32-L41
| null |
# -*- coding: utf-8 -*-
'''
Functions for adding yaml encoding to the jinja context
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import io
# Import 3rd-party libs
import yaml # pylint: disable=blacklisted-import
from salt.ext import six
# Import salt libs
from salt.utils.decorators.jinja import jinja_filter
@jinja_filter()
def yaml_dquote(text):
'''
Make text into a double-quoted YAML string with correct escaping
for special characters. Includes the opening and closing double
quote characters.
'''
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_double_quoted(six.text_type(text))
return ostream.getvalue()
@jinja_filter()
@jinja_filter()
def yaml_encode(data):
'''
A simple YAML encode that can take a single-element datatype and return
a string representation.
'''
yrepr = yaml.representer.SafeRepresenter()
ynode = yrepr.represent_data(data)
if not isinstance(ynode, yaml.ScalarNode):
raise TypeError(
"yaml_encode() only works with YAML scalar data;"
" failed for {0}".format(type(data))
)
tag = ynode.tag.rsplit(':', 1)[-1]
ret = ynode.value
if tag == "str":
ret = yaml_dquote(ynode.value)
return ret
|
saltstack/salt
|
salt/utils/yamlencoding.py
|
yaml_encode
|
python
|
def yaml_encode(data):
'''
A simple YAML encode that can take a single-element datatype and return
a string representation.
'''
yrepr = yaml.representer.SafeRepresenter()
ynode = yrepr.represent_data(data)
if not isinstance(ynode, yaml.ScalarNode):
raise TypeError(
"yaml_encode() only works with YAML scalar data;"
" failed for {0}".format(type(data))
)
tag = ynode.tag.rsplit(':', 1)[-1]
ret = ynode.value
if tag == "str":
ret = yaml_dquote(ynode.value)
return ret
|
A simple YAML encode that can take a single-element datatype and return
a string representation.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/utils/yamlencoding.py#L45-L64
| null |
# -*- coding: utf-8 -*-
'''
Functions for adding yaml encoding to the jinja context
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import io
# Import 3rd-party libs
import yaml # pylint: disable=blacklisted-import
from salt.ext import six
# Import salt libs
from salt.utils.decorators.jinja import jinja_filter
@jinja_filter()
def yaml_dquote(text):
'''
Make text into a double-quoted YAML string with correct escaping
for special characters. Includes the opening and closing double
quote characters.
'''
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_double_quoted(six.text_type(text))
return ostream.getvalue()
@jinja_filter()
def yaml_squote(text):
'''
Make text into a single-quoted YAML string with correct escaping
for special characters. Includes the opening and closing single
quote characters.
'''
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_single_quoted(six.text_type(text))
return ostream.getvalue()
@jinja_filter()
|
saltstack/salt
|
salt/renderers/nacl.py
|
_decrypt_object
|
python
|
def _decrypt_object(obj, **kwargs):
'''
Recursively try to decrypt any object. If the object is a six.string_types
(string or unicode), and it contains a valid NACLENC pretext, decrypt it,
otherwise keep going until a string is found.
'''
if salt.utils.stringio.is_readable(obj):
return _decrypt_object(obj.getvalue(), **kwargs)
if isinstance(obj, six.string_types):
if re.search(NACL_REGEX, obj) is not None:
return __salt__['nacl.dec'](re.search(NACL_REGEX, obj).group(1), **kwargs)
else:
return obj
elif isinstance(obj, dict):
for key, value in six.iteritems(obj):
obj[key] = _decrypt_object(value, **kwargs)
return obj
elif isinstance(obj, list):
for key, value in enumerate(obj):
obj[key] = _decrypt_object(value, **kwargs)
return obj
else:
return obj
|
Recursively try to decrypt any object. If the object is a six.string_types
(string or unicode), and it contains a valid NACLENC pretext, decrypt it,
otherwise keep going until a string is found.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/renderers/nacl.py#L71-L93
|
[
"def is_readable(obj):\n if six.PY2:\n return isinstance(obj, readable_types)\n else:\n return isinstance(obj, readable_types) and obj.readable()\n",
"def _decrypt_object(obj, **kwargs):\n '''\n Recursively try to decrypt any object. If the object is a six.string_types\n (string or unicode), and it contains a valid NACLENC pretext, decrypt it,\n otherwise keep going until a string is found.\n '''\n if salt.utils.stringio.is_readable(obj):\n return _decrypt_object(obj.getvalue(), **kwargs)\n if isinstance(obj, six.string_types):\n if re.search(NACL_REGEX, obj) is not None:\n return __salt__['nacl.dec'](re.search(NACL_REGEX, obj).group(1), **kwargs)\n else:\n return obj\n elif isinstance(obj, dict):\n for key, value in six.iteritems(obj):\n obj[key] = _decrypt_object(value, **kwargs)\n return obj\n elif isinstance(obj, list):\n for key, value in enumerate(obj):\n obj[key] = _decrypt_object(value, **kwargs)\n return obj\n else:\n return obj\n"
] |
# -*- coding: utf-8 -*-
r'''
Renderer that will decrypt NACL ciphers
Any key in the SLS file can be an NACL cipher, and this renderer will decrypt it
before passing it off to Salt. This allows you to safely store secrets in
source control, in such a way that only your Salt master can decrypt them and
distribute them only to the minions that need them.
The typical use-case would be to use ciphers in your pillar data, and keep a
secret key on your master. You can put the public key in source control so that
developers can add new secrets quickly and easily.
This renderer requires the libsodium library binary and libnacl >= 1.5.1
python package (support for sealed boxes came in 1.5.1 version).
Setup
-----
To set things up, first generate a keypair. On the master, run the following:
.. code-block:: bash
# salt-call --local nacl.keygen sk_file=/root/.nacl
Using encrypted pillar
---------------------
To encrypt secrets, copy the public key to your local machine and run:
.. code-block:: bash
$ salt-call --local nacl.enc datatoenc pk_file=/root/.nacl.pub
To apply the renderer on a file-by-file basis add the following line to the
top of any pillar with nacl encrypted data in it:
.. code-block:: yaml
#!yaml|nacl
Now with your renderer configured, you can include your ciphers in your pillar
data like so:
.. code-block:: yaml
#!yaml|nacl
a-secret: "NACL[MRN3cc+fmdxyQbz6WMF+jq1hKdU5X5BBI7OjK+atvHo1ll+w1gZ7XyWtZVfq9gK9rQaMfkDxmidJKwE0Mw==]"
'''
from __future__ import absolute_import, print_function, unicode_literals
import re
import logging
# Import salt libs
import salt.utils.stringio
import salt.syspaths
# Import 3rd-party libs
import salt.ext.six as six
log = logging.getLogger(__name__)
NACL_REGEX = r'^NACL\[(.*)\]$'
def render(nacl_data, saltenv='base', sls='', argline='', **kwargs):
'''
Decrypt the data to be rendered using the given nacl key or the one given
in config
'''
return _decrypt_object(nacl_data, **kwargs)
|
saltstack/salt
|
salt/pillar/mysql.py
|
ext_pillar
|
python
|
def ext_pillar(minion_id,
pillar,
*args,
**kwargs):
'''
Execute queries against MySQL, merge and return as a dict
'''
return MySQLExtPillar().fetch(minion_id, pillar, *args, **kwargs)
|
Execute queries against MySQL, merge and return as a dict
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/pillar/mysql.py#L140-L147
| null |
# -*- coding: utf-8 -*-
'''
Retrieve Pillar data by doing a MySQL query
MariaDB provides Python support through the MySQL Python package.
Therefore, you may use this module with both MySQL or MariaDB.
This module is a concrete implementation of the sql_base ext_pillar for MySQL.
:maturity: new
:depends: python-mysqldb
:platform: all
Configuring the mysql ext_pillar
================================
Use the 'mysql' key under ext_pillar for configuration of queries.
MySQL configuration of the MySQL returner is being used (mysql.db, mysql.user,
mysql.pass, mysql.port, mysql.host) for database connection info.
Required python modules: MySQLdb
Complete example
================
.. code-block:: yaml
mysql:
user: 'salt'
pass: 'super_secret_password'
db: 'salt_db'
port: 3306
ssl:
cert: /etc/mysql/client-cert.pem
key: /etc/mysql/client-key.pem
ext_pillar:
- mysql:
fromdb:
query: 'SELECT col1,col2,col3,col4,col5,col6,col7
FROM some_random_table
WHERE minion_pattern LIKE %s'
depth: 5
as_list: True
with_lists: [1,3]
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
from contextlib import contextmanager
import logging
# Import Salt libs
from salt.pillar.sql_base import SqlBaseExtPillar
# Set up logging
log = logging.getLogger(__name__)
# Import third party libs
try:
# Trying to import MySQLdb
import MySQLdb
import MySQLdb.cursors
import MySQLdb.converters
except ImportError:
try:
# MySQLdb import failed, try to import PyMySQL
import pymysql
pymysql.install_as_MySQLdb()
import MySQLdb
import MySQLdb.cursors
import MySQLdb.converters
except ImportError:
MySQLdb = None
def __virtual__():
'''
Confirm that a python mysql client is installed.
'''
return bool(MySQLdb), 'No python mysql client installed.' if MySQLdb is None else ''
class MySQLExtPillar(SqlBaseExtPillar):
'''
This class receives and processes the database rows from MySQL.
'''
@classmethod
def _db_name(cls):
return 'MySQL'
def _get_options(self):
'''
Returns options used for the MySQL connection.
'''
defaults = {'host': 'localhost',
'user': 'salt',
'pass': 'salt',
'db': 'salt',
'port': 3306,
'ssl': {}}
_options = {}
_opts = __opts__.get('mysql', {})
for attr in defaults:
if attr not in _opts:
log.debug('Using default for MySQL %s', attr)
_options[attr] = defaults[attr]
continue
_options[attr] = _opts[attr]
return _options
@contextmanager
def _get_cursor(self):
'''
Yield a MySQL cursor
'''
_options = self._get_options()
conn = MySQLdb.connect(host=_options['host'],
user=_options['user'],
passwd=_options['pass'],
db=_options['db'], port=_options['port'],
ssl=_options['ssl'])
cursor = conn.cursor()
try:
yield cursor
except MySQLdb.DatabaseError as err:
log.exception('Error in ext_pillar MySQL: %s', err.args)
finally:
conn.close()
def extract_queries(self, args, kwargs):
'''
This function normalizes the config block into a set of queries we
can use. The return is a list of consistently laid out dicts.
'''
return super(MySQLExtPillar, self).extract_queries(args, kwargs)
|
saltstack/salt
|
salt/pillar/mysql.py
|
MySQLExtPillar._get_options
|
python
|
def _get_options(self):
'''
Returns options used for the MySQL connection.
'''
defaults = {'host': 'localhost',
'user': 'salt',
'pass': 'salt',
'db': 'salt',
'port': 3306,
'ssl': {}}
_options = {}
_opts = __opts__.get('mysql', {})
for attr in defaults:
if attr not in _opts:
log.debug('Using default for MySQL %s', attr)
_options[attr] = defaults[attr]
continue
_options[attr] = _opts[attr]
return _options
|
Returns options used for the MySQL connection.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/pillar/mysql.py#L93-L111
| null |
class MySQLExtPillar(SqlBaseExtPillar):
'''
This class receives and processes the database rows from MySQL.
'''
@classmethod
def _db_name(cls):
return 'MySQL'
@contextmanager
def _get_cursor(self):
'''
Yield a MySQL cursor
'''
_options = self._get_options()
conn = MySQLdb.connect(host=_options['host'],
user=_options['user'],
passwd=_options['pass'],
db=_options['db'], port=_options['port'],
ssl=_options['ssl'])
cursor = conn.cursor()
try:
yield cursor
except MySQLdb.DatabaseError as err:
log.exception('Error in ext_pillar MySQL: %s', err.args)
finally:
conn.close()
def extract_queries(self, args, kwargs):
'''
This function normalizes the config block into a set of queries we
can use. The return is a list of consistently laid out dicts.
'''
return super(MySQLExtPillar, self).extract_queries(args, kwargs)
|
saltstack/salt
|
salt/pillar/mysql.py
|
MySQLExtPillar._get_cursor
|
python
|
def _get_cursor(self):
'''
Yield a MySQL cursor
'''
_options = self._get_options()
conn = MySQLdb.connect(host=_options['host'],
user=_options['user'],
passwd=_options['pass'],
db=_options['db'], port=_options['port'],
ssl=_options['ssl'])
cursor = conn.cursor()
try:
yield cursor
except MySQLdb.DatabaseError as err:
log.exception('Error in ext_pillar MySQL: %s', err.args)
finally:
conn.close()
|
Yield a MySQL cursor
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/pillar/mysql.py#L114-L130
| null |
class MySQLExtPillar(SqlBaseExtPillar):
'''
This class receives and processes the database rows from MySQL.
'''
@classmethod
def _db_name(cls):
return 'MySQL'
def _get_options(self):
'''
Returns options used for the MySQL connection.
'''
defaults = {'host': 'localhost',
'user': 'salt',
'pass': 'salt',
'db': 'salt',
'port': 3306,
'ssl': {}}
_options = {}
_opts = __opts__.get('mysql', {})
for attr in defaults:
if attr not in _opts:
log.debug('Using default for MySQL %s', attr)
_options[attr] = defaults[attr]
continue
_options[attr] = _opts[attr]
return _options
@contextmanager
def extract_queries(self, args, kwargs):
'''
This function normalizes the config block into a set of queries we
can use. The return is a list of consistently laid out dicts.
'''
return super(MySQLExtPillar, self).extract_queries(args, kwargs)
|
saltstack/salt
|
salt/pillar/mysql.py
|
MySQLExtPillar.extract_queries
|
python
|
def extract_queries(self, args, kwargs):
'''
This function normalizes the config block into a set of queries we
can use. The return is a list of consistently laid out dicts.
'''
return super(MySQLExtPillar, self).extract_queries(args, kwargs)
|
This function normalizes the config block into a set of queries we
can use. The return is a list of consistently laid out dicts.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/pillar/mysql.py#L132-L137
|
[
"def extract_queries(self, args, kwargs):\n '''\n This function normalizes the config block into a set of queries we\n can use. The return is a list of consistently laid out dicts.\n '''\n # Please note the function signature is NOT an error. Neither args, nor\n # kwargs should have asterisks. We are passing in a list and dict,\n # rather than receiving variable args. Adding asterisks WILL BREAK the\n # function completely.\n\n # First, this is the query buffer. Contains lists of [base,sql]\n qbuffer = []\n\n # Add on the non-keywords...\n qbuffer.extend([[None, s] for s in args])\n\n # And then the keywords...\n # They aren't in definition order, but they can't conflict each other.\n klist = list(kwargs.keys())\n klist.sort()\n qbuffer.extend([[k, kwargs[k]] for k in klist])\n\n # Filter out values that don't have queries.\n qbuffer = [x for x in qbuffer if (\n (isinstance(x[1], six.string_types) and len(x[1]))\n or\n (isinstance(x[1], (list, tuple)) and (len(x[1]) > 0) and x[1][0])\n or\n (isinstance(x[1], dict) and 'query' in x[1] and len(x[1]['query']))\n )]\n\n # Next, turn the whole buffer into full dicts.\n for qb in qbuffer:\n defaults = {'query': '',\n 'depth': 0,\n 'as_list': False,\n 'with_lists': None,\n 'ignore_null': False\n }\n if isinstance(qb[1], six.string_types):\n defaults['query'] = qb[1]\n elif isinstance(qb[1], (list, tuple)):\n defaults['query'] = qb[1][0]\n if len(qb[1]) > 1:\n defaults['depth'] = qb[1][1]\n # May set 'as_list' from qb[1][2].\n else:\n defaults.update(qb[1])\n if defaults['with_lists'] and isinstance(defaults['with_lists'], six.string_types):\n defaults['with_lists'] = [\n int(i) for i in defaults['with_lists'].split(',')\n ]\n qb[1] = defaults\n\n return qbuffer\n"
] |
class MySQLExtPillar(SqlBaseExtPillar):
'''
This class receives and processes the database rows from MySQL.
'''
@classmethod
def _db_name(cls):
return 'MySQL'
def _get_options(self):
'''
Returns options used for the MySQL connection.
'''
defaults = {'host': 'localhost',
'user': 'salt',
'pass': 'salt',
'db': 'salt',
'port': 3306,
'ssl': {}}
_options = {}
_opts = __opts__.get('mysql', {})
for attr in defaults:
if attr not in _opts:
log.debug('Using default for MySQL %s', attr)
_options[attr] = defaults[attr]
continue
_options[attr] = _opts[attr]
return _options
@contextmanager
def _get_cursor(self):
'''
Yield a MySQL cursor
'''
_options = self._get_options()
conn = MySQLdb.connect(host=_options['host'],
user=_options['user'],
passwd=_options['pass'],
db=_options['db'], port=_options['port'],
ssl=_options['ssl'])
cursor = conn.cursor()
try:
yield cursor
except MySQLdb.DatabaseError as err:
log.exception('Error in ext_pillar MySQL: %s', err.args)
finally:
conn.close()
|
saltstack/salt
|
salt/client/ssh/wrapper/config.py
|
merge
|
python
|
def merge(value,
default='',
omit_opts=False,
omit_master=False,
omit_pillar=False):
'''
Retrieves an option based on key, merging all matches.
Same as ``option()`` except that it merges all matches, rather than taking
the first match.
CLI Example:
.. code-block:: bash
salt '*' config.merge schedule
'''
ret = None
if not omit_opts:
if value in __opts__:
ret = __opts__[value]
if isinstance(ret, six.string_types):
return ret
if not omit_master:
if value in __pillar__.get('master', {}):
tmp = __pillar__['master'][value]
if ret is None:
ret = tmp
if isinstance(ret, six.string_types):
return ret
elif isinstance(ret, dict) and isinstance(tmp, dict):
tmp.update(ret)
ret = tmp
elif (isinstance(ret, (list, tuple)) and
isinstance(tmp, (list, tuple))):
ret = list(ret) + list(tmp)
if not omit_pillar:
if value in __pillar__:
tmp = __pillar__[value]
if ret is None:
ret = tmp
if isinstance(ret, six.string_types):
return ret
elif isinstance(ret, dict) and isinstance(tmp, dict):
tmp.update(ret)
ret = tmp
elif (isinstance(ret, (list, tuple)) and
isinstance(tmp, (list, tuple))):
ret = list(ret) + list(tmp)
if ret is None and value in DEFAULTS:
return DEFAULTS[value]
return ret or default
|
Retrieves an option based on key, merging all matches.
Same as ``option()`` except that it merges all matches, rather than taking
the first match.
CLI Example:
.. code-block:: bash
salt '*' config.merge schedule
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/client/ssh/wrapper/config.py#L134-L185
| null |
# -*- coding: utf-8 -*-
'''
Return config information
'''
# Import python libs
from __future__ import absolute_import, print_function
import re
import os
# Import salt libs
import salt.utils.data
import salt.utils.files
import salt.syspaths as syspaths
# Import 3rd-party libs
from salt.ext import six
# Set up the default values for all systems
DEFAULTS = {'mongo.db': 'salt',
'mongo.host': 'salt',
'mongo.password': '',
'mongo.port': 27017,
'mongo.user': '',
'redis.db': '0',
'redis.host': 'salt',
'redis.port': 6379,
'test.foo': 'unconfigured',
'ca.cert_base_path': '/etc/pki',
'solr.cores': [],
'solr.host': 'localhost',
'solr.port': '8983',
'solr.baseurl': '/solr',
'solr.type': 'master',
'solr.request_timeout': None,
'solr.init_script': '/etc/rc.d/solr',
'solr.dih.import_options': {'clean': False, 'optimize': True,
'commit': True, 'verbose': False},
'solr.backup_path': None,
'solr.num_backups': 1,
'poudriere.config': '/usr/local/etc/poudriere.conf',
'poudriere.config_dir': '/usr/local/etc/poudriere.d',
'ldap.server': 'localhost',
'ldap.port': '389',
'ldap.tls': False,
'ldap.scope': 2,
'ldap.attrs': None,
'ldap.binddn': '',
'ldap.bindpw': '',
'hosts.file': '/etc/hosts',
'aliases.file': '/etc/aliases',
'virt': {'tunnel': False,
'images': os.path.join(syspaths.SRV_ROOT_DIR, 'salt-images')},
}
def backup_mode(backup=''):
'''
Return the backup mode
CLI Example:
.. code-block:: bash
salt '*' config.backup_mode
'''
if backup:
return backup
return option('backup_mode')
def manage_mode(mode):
'''
Return a mode value, normalized to a string
CLI Example:
.. code-block:: bash
salt '*' config.manage_mode
'''
# config.manage_mode should no longer be invoked from the __salt__ dunder
# in Salt code, this function is only being left here for backwards
# compatibility.
return salt.utils.files.normalize_mode(mode)
def valid_fileproto(uri):
'''
Returns a boolean value based on whether or not the URI passed has a valid
remote file protocol designation
CLI Example:
.. code-block:: bash
salt '*' config.valid_fileproto salt://path/to/file
'''
try:
return bool(re.match('^(?:salt|https?|ftp)://', uri))
except Exception:
return False
def option(
value,
default='',
omit_opts=False,
omit_master=False,
omit_pillar=False):
'''
Pass in a generic option and receive the value that will be assigned
CLI Example:
.. code-block:: bash
salt '*' config.option redis.host
'''
if not omit_opts:
if value in __opts__:
return __opts__[value]
if not omit_master:
if value in __pillar__.get('master', {}):
return __pillar__['master'][value]
if not omit_pillar:
if value in __pillar__:
return __pillar__[value]
if value in DEFAULTS:
return DEFAULTS[value]
return default
def get(key, default=''):
'''
.. versionadded: 0.14.0
Attempt to retrieve the named value from opts, pillar, grains of the master
config, if the named value is not available return the passed default.
The default return is an empty string.
The value can also represent a value in a nested dict using a ":" delimiter
for the dict. This means that if a dict looks like this::
{'pkg': {'apache': 'httpd'}}
To retrieve the value associated with the apache key in the pkg dict this
key can be passed::
pkg:apache
This routine traverses these data stores in this order:
- Local minion config (opts)
- Minion's grains
- Minion's pillar
- Master config
CLI Example:
.. code-block:: bash
salt '*' config.get pkg:apache
'''
ret = salt.utils.data.traverse_dict_and_list(__opts__, key, '_|-')
if ret != '_|-':
return ret
ret = salt.utils.data.traverse_dict_and_list(__grains__, key, '_|-')
if ret != '_|-':
return ret
ret = salt.utils.data.traverse_dict_and_list(__pillar__, key, '_|-')
if ret != '_|-':
return ret
ret = salt.utils.data.traverse_dict_and_list(__pillar__.get('master', {}), key, '_|-')
if ret != '_|-':
return ret
return default
def dot_vals(value):
'''
Pass in a configuration value that should be preceded by the module name
and a dot, this will return a list of all read key/value pairs
CLI Example:
.. code-block:: bash
salt '*' config.dot_vals host
'''
ret = {}
for key, val in six.iteritems(__pillar__.get('master', {})):
if key.startswith('{0}.'.format(value)):
ret[key] = val
for key, val in six.iteritems(__opts__):
if key.startswith('{0}.'.format(value)):
ret[key] = val
return ret
|
saltstack/salt
|
salt/client/ssh/wrapper/config.py
|
get
|
python
|
def get(key, default=''):
'''
.. versionadded: 0.14.0
Attempt to retrieve the named value from opts, pillar, grains of the master
config, if the named value is not available return the passed default.
The default return is an empty string.
The value can also represent a value in a nested dict using a ":" delimiter
for the dict. This means that if a dict looks like this::
{'pkg': {'apache': 'httpd'}}
To retrieve the value associated with the apache key in the pkg dict this
key can be passed::
pkg:apache
This routine traverses these data stores in this order:
- Local minion config (opts)
- Minion's grains
- Minion's pillar
- Master config
CLI Example:
.. code-block:: bash
salt '*' config.get pkg:apache
'''
ret = salt.utils.data.traverse_dict_and_list(__opts__, key, '_|-')
if ret != '_|-':
return ret
ret = salt.utils.data.traverse_dict_and_list(__grains__, key, '_|-')
if ret != '_|-':
return ret
ret = salt.utils.data.traverse_dict_and_list(__pillar__, key, '_|-')
if ret != '_|-':
return ret
ret = salt.utils.data.traverse_dict_and_list(__pillar__.get('master', {}), key, '_|-')
if ret != '_|-':
return ret
return default
|
.. versionadded: 0.14.0
Attempt to retrieve the named value from opts, pillar, grains of the master
config, if the named value is not available return the passed default.
The default return is an empty string.
The value can also represent a value in a nested dict using a ":" delimiter
for the dict. This means that if a dict looks like this::
{'pkg': {'apache': 'httpd'}}
To retrieve the value associated with the apache key in the pkg dict this
key can be passed::
pkg:apache
This routine traverses these data stores in this order:
- Local minion config (opts)
- Minion's grains
- Minion's pillar
- Master config
CLI Example:
.. code-block:: bash
salt '*' config.get pkg:apache
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/client/ssh/wrapper/config.py#L188-L231
| null |
# -*- coding: utf-8 -*-
'''
Return config information
'''
# Import python libs
from __future__ import absolute_import, print_function
import re
import os
# Import salt libs
import salt.utils.data
import salt.utils.files
import salt.syspaths as syspaths
# Import 3rd-party libs
from salt.ext import six
# Set up the default values for all systems
DEFAULTS = {'mongo.db': 'salt',
'mongo.host': 'salt',
'mongo.password': '',
'mongo.port': 27017,
'mongo.user': '',
'redis.db': '0',
'redis.host': 'salt',
'redis.port': 6379,
'test.foo': 'unconfigured',
'ca.cert_base_path': '/etc/pki',
'solr.cores': [],
'solr.host': 'localhost',
'solr.port': '8983',
'solr.baseurl': '/solr',
'solr.type': 'master',
'solr.request_timeout': None,
'solr.init_script': '/etc/rc.d/solr',
'solr.dih.import_options': {'clean': False, 'optimize': True,
'commit': True, 'verbose': False},
'solr.backup_path': None,
'solr.num_backups': 1,
'poudriere.config': '/usr/local/etc/poudriere.conf',
'poudriere.config_dir': '/usr/local/etc/poudriere.d',
'ldap.server': 'localhost',
'ldap.port': '389',
'ldap.tls': False,
'ldap.scope': 2,
'ldap.attrs': None,
'ldap.binddn': '',
'ldap.bindpw': '',
'hosts.file': '/etc/hosts',
'aliases.file': '/etc/aliases',
'virt': {'tunnel': False,
'images': os.path.join(syspaths.SRV_ROOT_DIR, 'salt-images')},
}
def backup_mode(backup=''):
'''
Return the backup mode
CLI Example:
.. code-block:: bash
salt '*' config.backup_mode
'''
if backup:
return backup
return option('backup_mode')
def manage_mode(mode):
'''
Return a mode value, normalized to a string
CLI Example:
.. code-block:: bash
salt '*' config.manage_mode
'''
# config.manage_mode should no longer be invoked from the __salt__ dunder
# in Salt code, this function is only being left here for backwards
# compatibility.
return salt.utils.files.normalize_mode(mode)
def valid_fileproto(uri):
'''
Returns a boolean value based on whether or not the URI passed has a valid
remote file protocol designation
CLI Example:
.. code-block:: bash
salt '*' config.valid_fileproto salt://path/to/file
'''
try:
return bool(re.match('^(?:salt|https?|ftp)://', uri))
except Exception:
return False
def option(
value,
default='',
omit_opts=False,
omit_master=False,
omit_pillar=False):
'''
Pass in a generic option and receive the value that will be assigned
CLI Example:
.. code-block:: bash
salt '*' config.option redis.host
'''
if not omit_opts:
if value in __opts__:
return __opts__[value]
if not omit_master:
if value in __pillar__.get('master', {}):
return __pillar__['master'][value]
if not omit_pillar:
if value in __pillar__:
return __pillar__[value]
if value in DEFAULTS:
return DEFAULTS[value]
return default
def merge(value,
default='',
omit_opts=False,
omit_master=False,
omit_pillar=False):
'''
Retrieves an option based on key, merging all matches.
Same as ``option()`` except that it merges all matches, rather than taking
the first match.
CLI Example:
.. code-block:: bash
salt '*' config.merge schedule
'''
ret = None
if not omit_opts:
if value in __opts__:
ret = __opts__[value]
if isinstance(ret, six.string_types):
return ret
if not omit_master:
if value in __pillar__.get('master', {}):
tmp = __pillar__['master'][value]
if ret is None:
ret = tmp
if isinstance(ret, six.string_types):
return ret
elif isinstance(ret, dict) and isinstance(tmp, dict):
tmp.update(ret)
ret = tmp
elif (isinstance(ret, (list, tuple)) and
isinstance(tmp, (list, tuple))):
ret = list(ret) + list(tmp)
if not omit_pillar:
if value in __pillar__:
tmp = __pillar__[value]
if ret is None:
ret = tmp
if isinstance(ret, six.string_types):
return ret
elif isinstance(ret, dict) and isinstance(tmp, dict):
tmp.update(ret)
ret = tmp
elif (isinstance(ret, (list, tuple)) and
isinstance(tmp, (list, tuple))):
ret = list(ret) + list(tmp)
if ret is None and value in DEFAULTS:
return DEFAULTS[value]
return ret or default
def dot_vals(value):
'''
Pass in a configuration value that should be preceded by the module name
and a dot, this will return a list of all read key/value pairs
CLI Example:
.. code-block:: bash
salt '*' config.dot_vals host
'''
ret = {}
for key, val in six.iteritems(__pillar__.get('master', {})):
if key.startswith('{0}.'.format(value)):
ret[key] = val
for key, val in six.iteritems(__opts__):
if key.startswith('{0}.'.format(value)):
ret[key] = val
return ret
|
saltstack/salt
|
salt/states/zabbix_action.py
|
present
|
python
|
def present(name, params, **kwargs):
'''
Creates Zabbix Action object or if differs update it according defined parameters
:param name: Zabbix Action name
:param params: Definition of the Zabbix Action
:param _connection_user: Optional - zabbix user (can also be set in opts or pillar, see module's docstring)
:param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
:param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)
If there is a need to get a value from current zabbix online (e.g. id of a hostgroup you want to put a discovered
system into), put a dictionary with two keys "query_object" and "query_name" instead of the value.
In this example we want to get object id of hostgroup named "Virtual machines" and "Databases".
.. code-block:: yaml
zabbix-action-present:
zabbix_action.present:
- name: VMs
- params:
eventsource: 2
status: 0
filter:
evaltype: 2
conditions:
- conditiontype: 24
operator: 2
value: 'virtual'
- conditiontype: 24
operator: 2
value: 'kvm'
operations:
- operationtype: 2
- operationtype: 4
opgroup:
- groupid:
query_object: hostgroup
query_name: Virtual machines
- groupid:
query_object: hostgroup
query_name: Databases
'''
zabbix_id_mapper = __salt__['zabbix.get_zabbix_id_mapper']()
dry_run = __opts__['test']
ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}
# Create input params substituting functions with their results
params['name'] = name
params['operations'] = params['operations'] if 'operations' in params else []
if 'filter' in params:
params['filter']['conditions'] = params['filter']['conditions'] if 'conditions' in params['filter'] else []
input_params = __salt__['zabbix.substitute_params'](params, **kwargs)
log.info('Zabbix Action: input params: %s', six.text_type(json.dumps(input_params, indent=4)))
search = {'output': 'extend',
'selectOperations': 'extend',
'selectFilter': 'extend',
'filter': {
'name': name
}}
# GET Action object if exists
action_get = __salt__['zabbix.run_query']('action.get', search, **kwargs)
log.info('Zabbix Action: action.get result: %s', six.text_type(json.dumps(action_get, indent=4)))
existing_obj = __salt__['zabbix.substitute_params'](action_get[0], **kwargs) \
if action_get and len(action_get) == 1 else False
if existing_obj:
diff_params = __salt__['zabbix.compare_params'](input_params, existing_obj)
log.info('Zabbix Action: input params: {%s', six.text_type(json.dumps(input_params, indent=4)))
log.info('Zabbix Action: Object comparison result. Differences: %s', six.text_type(diff_params))
if diff_params:
diff_params[zabbix_id_mapper['action']] = existing_obj[zabbix_id_mapper['action']]
# diff_params['name'] = 'VMs' - BUG - https://support.zabbix.com/browse/ZBX-12078
log.info('Zabbix Action: update params: %s', six.text_type(json.dumps(diff_params, indent=4)))
if dry_run:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" would be fixed.'.format(name)
ret['changes'] = {name: {'old': 'Zabbix Action "{0}" differs '
'in following parameters: {1}'.format(name, diff_params),
'new': 'Zabbix Action "{0}" would correspond to definition.'.format(name)}}
else:
action_update = __salt__['zabbix.run_query']('action.update', diff_params, **kwargs)
log.info('Zabbix Action: action.update result: %s', six.text_type(action_update))
if action_update:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" updated.'.format(name)
ret['changes'] = {name: {'old': 'Zabbix Action "{0}" differed '
'in following parameters: {1}'.format(name, diff_params),
'new': 'Zabbix Action "{0}" fixed.'.format(name)}}
else:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" already exists and corresponds to a definition.'.format(name)
else:
if dry_run:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" would be created.'.format(name)
ret['changes'] = {name: {'old': 'Zabbix Action "{0}" does not exist.'.format(name),
'new': 'Zabbix Action "{0}" would be created according definition.'.format(name)}}
else:
# ACTION.CREATE
action_create = __salt__['zabbix.run_query']('action.create', input_params, **kwargs)
log.info('Zabbix Action: action.create result: %s', action_create)
if action_create:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" created.'.format(name)
ret['changes'] = {name: {'old': 'Zabbix Action "{0}" did not exist.'.format(name),
'new': 'Zabbix Action "{0}" created according definition.'.format(name)}}
return ret
|
Creates Zabbix Action object or if differs update it according defined parameters
:param name: Zabbix Action name
:param params: Definition of the Zabbix Action
:param _connection_user: Optional - zabbix user (can also be set in opts or pillar, see module's docstring)
:param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
:param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)
If there is a need to get a value from current zabbix online (e.g. id of a hostgroup you want to put a discovered
system into), put a dictionary with two keys "query_object" and "query_name" instead of the value.
In this example we want to get object id of hostgroup named "Virtual machines" and "Databases".
.. code-block:: yaml
zabbix-action-present:
zabbix_action.present:
- name: VMs
- params:
eventsource: 2
status: 0
filter:
evaltype: 2
conditions:
- conditiontype: 24
operator: 2
value: 'virtual'
- conditiontype: 24
operator: 2
value: 'kvm'
operations:
- operationtype: 2
- operationtype: 4
opgroup:
- groupid:
query_object: hostgroup
query_name: Virtual machines
- groupid:
query_object: hostgroup
query_name: Databases
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/zabbix_action.py#L35-L151
| null |
# -*- coding: utf-8 -*-
'''
.. versionadded:: 2017.7
Management of Zabbix Action object over Zabbix API.
:codeauthor: Jakub Sliva <jakub.sliva@ultimum.io>
'''
from __future__ import absolute_import
from __future__ import unicode_literals
import logging
import json
try:
from salt.ext import six
from salt.exceptions import SaltException
IMPORTS_OK = True
except ImportError:
IMPORTS_OK = False
log = logging.getLogger(__name__)
def __virtual__():
'''
Only make these states available if Zabbix module and run_query function is available
and all 3rd party modules imported.
'''
if 'zabbix.run_query' in __salt__ and IMPORTS_OK:
return True
return False, 'Import zabbix or other needed modules failed.'
def absent(name, **kwargs):
'''
Makes the Zabbix Action to be absent (either does not exist or delete it).
:param name: Zabbix Action name
:param _connection_user: Optional - zabbix user (can also be set in opts or pillar, see module's docstring)
:param _connection_password: Optional - zabbix password (can also be set in opts or pillar, see module's docstring)
:param _connection_url: Optional - url of zabbix frontend (can also be set in opts, pillar, see module's docstring)
.. code-block:: yaml
zabbix-action-absent:
zabbix_action.absent:
- name: Action name
'''
dry_run = __opts__['test']
ret = {'name': name, 'result': False, 'comment': '', 'changes': {}}
try:
object_id = __salt__['zabbix.get_object_id_by_params']('action', {'filter': {'name': name}}, **kwargs)
except SaltException:
object_id = False
if not object_id:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" does not exist.'.format(name)
else:
if dry_run:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" would be deleted.'.format(name)
ret['changes'] = {name: {'old': 'Zabbix Action "{0}" exists.'.format(name),
'new': 'Zabbix Action "{0}" would be deleted.'.format(name)}}
else:
action_delete = __salt__['zabbix.run_query']('action.delete', [object_id], **kwargs)
if action_delete:
ret['result'] = True
ret['comment'] = 'Zabbix Action "{0}" deleted.'.format(name)
ret['changes'] = {name: {'old': 'Zabbix Action "{0}" existed.'.format(name),
'new': 'Zabbix Action "{0}" deleted.'.format(name)}}
return ret
|
saltstack/salt
|
salt/modules/openbsdrcctl_service.py
|
available
|
python
|
def available(name):
'''
Return True if the named service is available.
CLI Example:
.. code-block:: bash
salt '*' service.available sshd
'''
cmd = '{0} get {1}'.format(_cmd(), name)
if __salt__['cmd.retcode'](cmd) == 2:
return False
return True
|
Return True if the named service is available.
CLI Example:
.. code-block:: bash
salt '*' service.available sshd
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/openbsdrcctl_service.py#L54-L67
| null |
# -*- coding: utf-8 -*-
'''
The rcctl service module for OpenBSD
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
import os
# Import salt libs
import salt.utils.path
import salt.utils.decorators as decorators
from salt.exceptions import CommandNotFoundError
__func_alias__ = {
'reload_': 'reload'
}
# Define the module's virtual name
__virtualname__ = 'service'
def __virtual__():
'''
rcctl(8) is only available on OpenBSD.
'''
if __grains__['os'] == 'OpenBSD' and os.path.exists('/usr/sbin/rcctl'):
return __virtualname__
return (False, 'The openbsdpkg execution module cannot be loaded: '
'only available on OpenBSD systems.')
@decorators.memoize
def _cmd():
'''
Return the full path to the rcctl(8) command.
'''
rcctl = salt.utils.path.which('rcctl')
if not rcctl:
raise CommandNotFoundError
return rcctl
def _get_flags(**kwargs):
'''
Return the configured service flags.
'''
flags = kwargs.get('flags',
__salt__['config.option']('service.flags',
default=''))
return flags
def missing(name):
'''
The inverse of service.available.
Return True if the named service is not available.
CLI Example:
.. code-block:: bash
salt '*' service.missing sshd
'''
return not available(name)
def get_all():
'''
Return all installed services.
CLI Example:
.. code-block:: bash
salt '*' service.get_all
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls all'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_disabled():
'''
Return what services are available but not enabled to start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_disabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls off'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_enabled():
'''
Return what services are set to run on boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_enabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls on'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def start(name):
'''
Start the named service.
CLI Example:
.. code-block:: bash
salt '*' service.start <service name>
'''
cmd = '{0} -f start {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def stop(name):
'''
Stop the named service.
CLI Example:
.. code-block:: bash
salt '*' service.stop <service name>
'''
cmd = '{0} stop {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def restart(name):
'''
Restart the named service.
CLI Example:
.. code-block:: bash
salt '*' service.restart <service name>
'''
cmd = '{0} -f restart {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def reload_(name):
'''
Reload the named service.
CLI Example:
.. code-block:: bash
salt '*' service.reload <service name>
'''
cmd = '{0} reload {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def status(name, sig=None):
'''
Return the status for a service, returns a bool whether the service is
running.
CLI Example:
.. code-block:: bash
salt '*' service.status <service name>
'''
if sig:
return bool(__salt__['status.pid'](sig))
cmd = '{0} check {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def enable(name, **kwargs):
'''
Enable the named service to start at boot.
flags : None
Set optional flags to run the service with.
service.flags can be used to change the default flags.
CLI Example:
.. code-block:: bash
salt '*' service.enable <service name>
salt '*' service.enable <service name> flags=<flags>
'''
stat_cmd = '{0} set {1} status on'.format(_cmd(), name)
stat_retcode = __salt__['cmd.retcode'](stat_cmd)
flag_retcode = None
# only (re)set flags for services that have an rc.d(8) script
if os.path.exists('/etc/rc.d/{0}'.format(name)):
flags = _get_flags(**kwargs)
flag_cmd = '{0} set {1} flags {2}'.format(_cmd(), name, flags)
flag_retcode = __salt__['cmd.retcode'](flag_cmd)
return not any([stat_retcode, flag_retcode])
def disable(name, **kwargs):
'''
Disable the named service to not start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.disable <service name>
'''
cmd = '{0} set {1} status off'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def disabled(name):
'''
Return True if the named service is disabled at boot, False otherwise.
CLI Example:
.. code-block:: bash
salt '*' service.disabled <service name>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd) == 0
def enabled(name, **kwargs):
'''
Return True if the named service is enabled at boot and the provided
flags match the configured ones (if any). Return False otherwise.
name
Service name
CLI Example:
.. code-block:: bash
salt '*' service.enabled <service name>
salt '*' service.enabled <service name> flags=<flags>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
if not __salt__['cmd.retcode'](cmd):
# also consider a service disabled if the current flags are different
# than the configured ones so we have a chance to update them
flags = _get_flags(**kwargs)
cur_flags = __salt__['cmd.run_stdout']('{0} get {1} flags'.format(_cmd(), name))
if format(flags) == format(cur_flags):
return True
if not flags:
def_flags = __salt__['cmd.run_stdout']('{0} getdef {1} flags'.format(_cmd(), name))
if format(cur_flags) == format(def_flags):
return True
return False
|
saltstack/salt
|
salt/modules/openbsdrcctl_service.py
|
get_all
|
python
|
def get_all():
'''
Return all installed services.
CLI Example:
.. code-block:: bash
salt '*' service.get_all
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls all'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
|
Return all installed services.
CLI Example:
.. code-block:: bash
salt '*' service.get_all
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/openbsdrcctl_service.py#L84-L98
| null |
# -*- coding: utf-8 -*-
'''
The rcctl service module for OpenBSD
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
import os
# Import salt libs
import salt.utils.path
import salt.utils.decorators as decorators
from salt.exceptions import CommandNotFoundError
__func_alias__ = {
'reload_': 'reload'
}
# Define the module's virtual name
__virtualname__ = 'service'
def __virtual__():
'''
rcctl(8) is only available on OpenBSD.
'''
if __grains__['os'] == 'OpenBSD' and os.path.exists('/usr/sbin/rcctl'):
return __virtualname__
return (False, 'The openbsdpkg execution module cannot be loaded: '
'only available on OpenBSD systems.')
@decorators.memoize
def _cmd():
'''
Return the full path to the rcctl(8) command.
'''
rcctl = salt.utils.path.which('rcctl')
if not rcctl:
raise CommandNotFoundError
return rcctl
def _get_flags(**kwargs):
'''
Return the configured service flags.
'''
flags = kwargs.get('flags',
__salt__['config.option']('service.flags',
default=''))
return flags
def available(name):
'''
Return True if the named service is available.
CLI Example:
.. code-block:: bash
salt '*' service.available sshd
'''
cmd = '{0} get {1}'.format(_cmd(), name)
if __salt__['cmd.retcode'](cmd) == 2:
return False
return True
def missing(name):
'''
The inverse of service.available.
Return True if the named service is not available.
CLI Example:
.. code-block:: bash
salt '*' service.missing sshd
'''
return not available(name)
def get_disabled():
'''
Return what services are available but not enabled to start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_disabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls off'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_enabled():
'''
Return what services are set to run on boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_enabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls on'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def start(name):
'''
Start the named service.
CLI Example:
.. code-block:: bash
salt '*' service.start <service name>
'''
cmd = '{0} -f start {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def stop(name):
'''
Stop the named service.
CLI Example:
.. code-block:: bash
salt '*' service.stop <service name>
'''
cmd = '{0} stop {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def restart(name):
'''
Restart the named service.
CLI Example:
.. code-block:: bash
salt '*' service.restart <service name>
'''
cmd = '{0} -f restart {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def reload_(name):
'''
Reload the named service.
CLI Example:
.. code-block:: bash
salt '*' service.reload <service name>
'''
cmd = '{0} reload {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def status(name, sig=None):
'''
Return the status for a service, returns a bool whether the service is
running.
CLI Example:
.. code-block:: bash
salt '*' service.status <service name>
'''
if sig:
return bool(__salt__['status.pid'](sig))
cmd = '{0} check {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def enable(name, **kwargs):
'''
Enable the named service to start at boot.
flags : None
Set optional flags to run the service with.
service.flags can be used to change the default flags.
CLI Example:
.. code-block:: bash
salt '*' service.enable <service name>
salt '*' service.enable <service name> flags=<flags>
'''
stat_cmd = '{0} set {1} status on'.format(_cmd(), name)
stat_retcode = __salt__['cmd.retcode'](stat_cmd)
flag_retcode = None
# only (re)set flags for services that have an rc.d(8) script
if os.path.exists('/etc/rc.d/{0}'.format(name)):
flags = _get_flags(**kwargs)
flag_cmd = '{0} set {1} flags {2}'.format(_cmd(), name, flags)
flag_retcode = __salt__['cmd.retcode'](flag_cmd)
return not any([stat_retcode, flag_retcode])
def disable(name, **kwargs):
'''
Disable the named service to not start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.disable <service name>
'''
cmd = '{0} set {1} status off'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def disabled(name):
'''
Return True if the named service is disabled at boot, False otherwise.
CLI Example:
.. code-block:: bash
salt '*' service.disabled <service name>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd) == 0
def enabled(name, **kwargs):
'''
Return True if the named service is enabled at boot and the provided
flags match the configured ones (if any). Return False otherwise.
name
Service name
CLI Example:
.. code-block:: bash
salt '*' service.enabled <service name>
salt '*' service.enabled <service name> flags=<flags>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
if not __salt__['cmd.retcode'](cmd):
# also consider a service disabled if the current flags are different
# than the configured ones so we have a chance to update them
flags = _get_flags(**kwargs)
cur_flags = __salt__['cmd.run_stdout']('{0} get {1} flags'.format(_cmd(), name))
if format(flags) == format(cur_flags):
return True
if not flags:
def_flags = __salt__['cmd.run_stdout']('{0} getdef {1} flags'.format(_cmd(), name))
if format(cur_flags) == format(def_flags):
return True
return False
|
saltstack/salt
|
salt/modules/openbsdrcctl_service.py
|
status
|
python
|
def status(name, sig=None):
'''
Return the status for a service, returns a bool whether the service is
running.
CLI Example:
.. code-block:: bash
salt '*' service.status <service name>
'''
if sig:
return bool(__salt__['status.pid'](sig))
cmd = '{0} check {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
|
Return the status for a service, returns a bool whether the service is
running.
CLI Example:
.. code-block:: bash
salt '*' service.status <service name>
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/openbsdrcctl_service.py#L191-L206
| null |
# -*- coding: utf-8 -*-
'''
The rcctl service module for OpenBSD
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
import os
# Import salt libs
import salt.utils.path
import salt.utils.decorators as decorators
from salt.exceptions import CommandNotFoundError
__func_alias__ = {
'reload_': 'reload'
}
# Define the module's virtual name
__virtualname__ = 'service'
def __virtual__():
'''
rcctl(8) is only available on OpenBSD.
'''
if __grains__['os'] == 'OpenBSD' and os.path.exists('/usr/sbin/rcctl'):
return __virtualname__
return (False, 'The openbsdpkg execution module cannot be loaded: '
'only available on OpenBSD systems.')
@decorators.memoize
def _cmd():
'''
Return the full path to the rcctl(8) command.
'''
rcctl = salt.utils.path.which('rcctl')
if not rcctl:
raise CommandNotFoundError
return rcctl
def _get_flags(**kwargs):
'''
Return the configured service flags.
'''
flags = kwargs.get('flags',
__salt__['config.option']('service.flags',
default=''))
return flags
def available(name):
'''
Return True if the named service is available.
CLI Example:
.. code-block:: bash
salt '*' service.available sshd
'''
cmd = '{0} get {1}'.format(_cmd(), name)
if __salt__['cmd.retcode'](cmd) == 2:
return False
return True
def missing(name):
'''
The inverse of service.available.
Return True if the named service is not available.
CLI Example:
.. code-block:: bash
salt '*' service.missing sshd
'''
return not available(name)
def get_all():
'''
Return all installed services.
CLI Example:
.. code-block:: bash
salt '*' service.get_all
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls all'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_disabled():
'''
Return what services are available but not enabled to start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_disabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls off'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_enabled():
'''
Return what services are set to run on boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_enabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls on'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def start(name):
'''
Start the named service.
CLI Example:
.. code-block:: bash
salt '*' service.start <service name>
'''
cmd = '{0} -f start {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def stop(name):
'''
Stop the named service.
CLI Example:
.. code-block:: bash
salt '*' service.stop <service name>
'''
cmd = '{0} stop {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def restart(name):
'''
Restart the named service.
CLI Example:
.. code-block:: bash
salt '*' service.restart <service name>
'''
cmd = '{0} -f restart {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def reload_(name):
'''
Reload the named service.
CLI Example:
.. code-block:: bash
salt '*' service.reload <service name>
'''
cmd = '{0} reload {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def enable(name, **kwargs):
'''
Enable the named service to start at boot.
flags : None
Set optional flags to run the service with.
service.flags can be used to change the default flags.
CLI Example:
.. code-block:: bash
salt '*' service.enable <service name>
salt '*' service.enable <service name> flags=<flags>
'''
stat_cmd = '{0} set {1} status on'.format(_cmd(), name)
stat_retcode = __salt__['cmd.retcode'](stat_cmd)
flag_retcode = None
# only (re)set flags for services that have an rc.d(8) script
if os.path.exists('/etc/rc.d/{0}'.format(name)):
flags = _get_flags(**kwargs)
flag_cmd = '{0} set {1} flags {2}'.format(_cmd(), name, flags)
flag_retcode = __salt__['cmd.retcode'](flag_cmd)
return not any([stat_retcode, flag_retcode])
def disable(name, **kwargs):
'''
Disable the named service to not start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.disable <service name>
'''
cmd = '{0} set {1} status off'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def disabled(name):
'''
Return True if the named service is disabled at boot, False otherwise.
CLI Example:
.. code-block:: bash
salt '*' service.disabled <service name>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd) == 0
def enabled(name, **kwargs):
'''
Return True if the named service is enabled at boot and the provided
flags match the configured ones (if any). Return False otherwise.
name
Service name
CLI Example:
.. code-block:: bash
salt '*' service.enabled <service name>
salt '*' service.enabled <service name> flags=<flags>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
if not __salt__['cmd.retcode'](cmd):
# also consider a service disabled if the current flags are different
# than the configured ones so we have a chance to update them
flags = _get_flags(**kwargs)
cur_flags = __salt__['cmd.run_stdout']('{0} get {1} flags'.format(_cmd(), name))
if format(flags) == format(cur_flags):
return True
if not flags:
def_flags = __salt__['cmd.run_stdout']('{0} getdef {1} flags'.format(_cmd(), name))
if format(cur_flags) == format(def_flags):
return True
return False
|
saltstack/salt
|
salt/modules/openbsdrcctl_service.py
|
enable
|
python
|
def enable(name, **kwargs):
'''
Enable the named service to start at boot.
flags : None
Set optional flags to run the service with.
service.flags can be used to change the default flags.
CLI Example:
.. code-block:: bash
salt '*' service.enable <service name>
salt '*' service.enable <service name> flags=<flags>
'''
stat_cmd = '{0} set {1} status on'.format(_cmd(), name)
stat_retcode = __salt__['cmd.retcode'](stat_cmd)
flag_retcode = None
# only (re)set flags for services that have an rc.d(8) script
if os.path.exists('/etc/rc.d/{0}'.format(name)):
flags = _get_flags(**kwargs)
flag_cmd = '{0} set {1} flags {2}'.format(_cmd(), name, flags)
flag_retcode = __salt__['cmd.retcode'](flag_cmd)
return not any([stat_retcode, flag_retcode])
|
Enable the named service to start at boot.
flags : None
Set optional flags to run the service with.
service.flags can be used to change the default flags.
CLI Example:
.. code-block:: bash
salt '*' service.enable <service name>
salt '*' service.enable <service name> flags=<flags>
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/openbsdrcctl_service.py#L209-L235
|
[
"def _get_flags(**kwargs):\n '''\n Return the configured service flags.\n '''\n flags = kwargs.get('flags',\n __salt__['config.option']('service.flags',\n default=''))\n return flags\n"
] |
# -*- coding: utf-8 -*-
'''
The rcctl service module for OpenBSD
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
import os
# Import salt libs
import salt.utils.path
import salt.utils.decorators as decorators
from salt.exceptions import CommandNotFoundError
__func_alias__ = {
'reload_': 'reload'
}
# Define the module's virtual name
__virtualname__ = 'service'
def __virtual__():
'''
rcctl(8) is only available on OpenBSD.
'''
if __grains__['os'] == 'OpenBSD' and os.path.exists('/usr/sbin/rcctl'):
return __virtualname__
return (False, 'The openbsdpkg execution module cannot be loaded: '
'only available on OpenBSD systems.')
@decorators.memoize
def _cmd():
'''
Return the full path to the rcctl(8) command.
'''
rcctl = salt.utils.path.which('rcctl')
if not rcctl:
raise CommandNotFoundError
return rcctl
def _get_flags(**kwargs):
'''
Return the configured service flags.
'''
flags = kwargs.get('flags',
__salt__['config.option']('service.flags',
default=''))
return flags
def available(name):
'''
Return True if the named service is available.
CLI Example:
.. code-block:: bash
salt '*' service.available sshd
'''
cmd = '{0} get {1}'.format(_cmd(), name)
if __salt__['cmd.retcode'](cmd) == 2:
return False
return True
def missing(name):
'''
The inverse of service.available.
Return True if the named service is not available.
CLI Example:
.. code-block:: bash
salt '*' service.missing sshd
'''
return not available(name)
def get_all():
'''
Return all installed services.
CLI Example:
.. code-block:: bash
salt '*' service.get_all
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls all'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_disabled():
'''
Return what services are available but not enabled to start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_disabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls off'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_enabled():
'''
Return what services are set to run on boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_enabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls on'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def start(name):
'''
Start the named service.
CLI Example:
.. code-block:: bash
salt '*' service.start <service name>
'''
cmd = '{0} -f start {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def stop(name):
'''
Stop the named service.
CLI Example:
.. code-block:: bash
salt '*' service.stop <service name>
'''
cmd = '{0} stop {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def restart(name):
'''
Restart the named service.
CLI Example:
.. code-block:: bash
salt '*' service.restart <service name>
'''
cmd = '{0} -f restart {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def reload_(name):
'''
Reload the named service.
CLI Example:
.. code-block:: bash
salt '*' service.reload <service name>
'''
cmd = '{0} reload {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def status(name, sig=None):
'''
Return the status for a service, returns a bool whether the service is
running.
CLI Example:
.. code-block:: bash
salt '*' service.status <service name>
'''
if sig:
return bool(__salt__['status.pid'](sig))
cmd = '{0} check {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def disable(name, **kwargs):
'''
Disable the named service to not start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.disable <service name>
'''
cmd = '{0} set {1} status off'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def disabled(name):
'''
Return True if the named service is disabled at boot, False otherwise.
CLI Example:
.. code-block:: bash
salt '*' service.disabled <service name>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd) == 0
def enabled(name, **kwargs):
'''
Return True if the named service is enabled at boot and the provided
flags match the configured ones (if any). Return False otherwise.
name
Service name
CLI Example:
.. code-block:: bash
salt '*' service.enabled <service name>
salt '*' service.enabled <service name> flags=<flags>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
if not __salt__['cmd.retcode'](cmd):
# also consider a service disabled if the current flags are different
# than the configured ones so we have a chance to update them
flags = _get_flags(**kwargs)
cur_flags = __salt__['cmd.run_stdout']('{0} get {1} flags'.format(_cmd(), name))
if format(flags) == format(cur_flags):
return True
if not flags:
def_flags = __salt__['cmd.run_stdout']('{0} getdef {1} flags'.format(_cmd(), name))
if format(cur_flags) == format(def_flags):
return True
return False
|
saltstack/salt
|
salt/modules/openbsdrcctl_service.py
|
enabled
|
python
|
def enabled(name, **kwargs):
'''
Return True if the named service is enabled at boot and the provided
flags match the configured ones (if any). Return False otherwise.
name
Service name
CLI Example:
.. code-block:: bash
salt '*' service.enabled <service name>
salt '*' service.enabled <service name> flags=<flags>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
if not __salt__['cmd.retcode'](cmd):
# also consider a service disabled if the current flags are different
# than the configured ones so we have a chance to update them
flags = _get_flags(**kwargs)
cur_flags = __salt__['cmd.run_stdout']('{0} get {1} flags'.format(_cmd(), name))
if format(flags) == format(cur_flags):
return True
if not flags:
def_flags = __salt__['cmd.run_stdout']('{0} getdef {1} flags'.format(_cmd(), name))
if format(cur_flags) == format(def_flags):
return True
return False
|
Return True if the named service is enabled at boot and the provided
flags match the configured ones (if any). Return False otherwise.
name
Service name
CLI Example:
.. code-block:: bash
salt '*' service.enabled <service name>
salt '*' service.enabled <service name> flags=<flags>
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/openbsdrcctl_service.py#L266-L294
|
[
"def _get_flags(**kwargs):\n '''\n Return the configured service flags.\n '''\n flags = kwargs.get('flags',\n __salt__['config.option']('service.flags',\n default=''))\n return flags\n"
] |
# -*- coding: utf-8 -*-
'''
The rcctl service module for OpenBSD
'''
from __future__ import absolute_import, print_function, unicode_literals
# Import python libs
import os
# Import salt libs
import salt.utils.path
import salt.utils.decorators as decorators
from salt.exceptions import CommandNotFoundError
__func_alias__ = {
'reload_': 'reload'
}
# Define the module's virtual name
__virtualname__ = 'service'
def __virtual__():
'''
rcctl(8) is only available on OpenBSD.
'''
if __grains__['os'] == 'OpenBSD' and os.path.exists('/usr/sbin/rcctl'):
return __virtualname__
return (False, 'The openbsdpkg execution module cannot be loaded: '
'only available on OpenBSD systems.')
@decorators.memoize
def _cmd():
'''
Return the full path to the rcctl(8) command.
'''
rcctl = salt.utils.path.which('rcctl')
if not rcctl:
raise CommandNotFoundError
return rcctl
def _get_flags(**kwargs):
'''
Return the configured service flags.
'''
flags = kwargs.get('flags',
__salt__['config.option']('service.flags',
default=''))
return flags
def available(name):
'''
Return True if the named service is available.
CLI Example:
.. code-block:: bash
salt '*' service.available sshd
'''
cmd = '{0} get {1}'.format(_cmd(), name)
if __salt__['cmd.retcode'](cmd) == 2:
return False
return True
def missing(name):
'''
The inverse of service.available.
Return True if the named service is not available.
CLI Example:
.. code-block:: bash
salt '*' service.missing sshd
'''
return not available(name)
def get_all():
'''
Return all installed services.
CLI Example:
.. code-block:: bash
salt '*' service.get_all
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls all'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_disabled():
'''
Return what services are available but not enabled to start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_disabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls off'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def get_enabled():
'''
Return what services are set to run on boot.
CLI Example:
.. code-block:: bash
salt '*' service.get_enabled
'''
ret = []
service = _cmd()
for svc in __salt__['cmd.run']('{0} ls on'.format(service)).splitlines():
ret.append(svc)
return sorted(ret)
def start(name):
'''
Start the named service.
CLI Example:
.. code-block:: bash
salt '*' service.start <service name>
'''
cmd = '{0} -f start {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def stop(name):
'''
Stop the named service.
CLI Example:
.. code-block:: bash
salt '*' service.stop <service name>
'''
cmd = '{0} stop {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def restart(name):
'''
Restart the named service.
CLI Example:
.. code-block:: bash
salt '*' service.restart <service name>
'''
cmd = '{0} -f restart {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def reload_(name):
'''
Reload the named service.
CLI Example:
.. code-block:: bash
salt '*' service.reload <service name>
'''
cmd = '{0} reload {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def status(name, sig=None):
'''
Return the status for a service, returns a bool whether the service is
running.
CLI Example:
.. code-block:: bash
salt '*' service.status <service name>
'''
if sig:
return bool(__salt__['status.pid'](sig))
cmd = '{0} check {1}'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def enable(name, **kwargs):
'''
Enable the named service to start at boot.
flags : None
Set optional flags to run the service with.
service.flags can be used to change the default flags.
CLI Example:
.. code-block:: bash
salt '*' service.enable <service name>
salt '*' service.enable <service name> flags=<flags>
'''
stat_cmd = '{0} set {1} status on'.format(_cmd(), name)
stat_retcode = __salt__['cmd.retcode'](stat_cmd)
flag_retcode = None
# only (re)set flags for services that have an rc.d(8) script
if os.path.exists('/etc/rc.d/{0}'.format(name)):
flags = _get_flags(**kwargs)
flag_cmd = '{0} set {1} flags {2}'.format(_cmd(), name, flags)
flag_retcode = __salt__['cmd.retcode'](flag_cmd)
return not any([stat_retcode, flag_retcode])
def disable(name, **kwargs):
'''
Disable the named service to not start at boot.
CLI Example:
.. code-block:: bash
salt '*' service.disable <service name>
'''
cmd = '{0} set {1} status off'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd)
def disabled(name):
'''
Return True if the named service is disabled at boot, False otherwise.
CLI Example:
.. code-block:: bash
salt '*' service.disabled <service name>
'''
cmd = '{0} get {1} status'.format(_cmd(), name)
return not __salt__['cmd.retcode'](cmd) == 0
|
saltstack/salt
|
salt/states/netusers.py
|
_expand_users
|
python
|
def _expand_users(device_users, common_users):
'''Creates a longer list of accepted users on the device.'''
expected_users = deepcopy(common_users)
expected_users.update(device_users)
return expected_users
|
Creates a longer list of accepted users on the device.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/netusers.py#L75-L82
| null |
# -*- coding: utf-8 -*-
'''
Network Users
=============
Manage the users configuration on network devices via the NAPALM proxy.
:codeauthor: Mircea Ulinic <mircea@cloudflare.com>
:maturity: new
:depends: napalm
:platform: unix
Dependencies
------------
- :mod:`NAPALM proxy minion <salt.proxy.napalm>`
- :mod:`Users configuration management module <salt.modules.napalm_users>`
.. versionadded:: 2016.11.0
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
log = logging.getLogger(__name__)
# Python std lib
from copy import deepcopy
# salt lib
from salt.utils.json import loads, dumps
from salt.ext import six
# import NAPALM utils
import salt.utils.napalm
# ----------------------------------------------------------------------------------------------------------------------
# state properties
# ----------------------------------------------------------------------------------------------------------------------
__virtualname__ = 'netusers'
# ----------------------------------------------------------------------------------------------------------------------
# global variables
# ----------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
# property functions
# ----------------------------------------------------------------------------------------------------------------------
def __virtual__():
'''
NAPALM library must be installed for this module to work and run in a (proxy) minion.
'''
return salt.utils.napalm.virtual(__opts__, __virtualname__, __file__)
# ----------------------------------------------------------------------------------------------------------------------
# helper functions -- will not be exported
# ----------------------------------------------------------------------------------------------------------------------
def _retrieve_users():
'''Retrieves configured users'''
return __salt__['users.config']()
def _ordered_dict_to_dict(probes):
'''.'''
return loads(dumps(probes))
def _check_users(users):
'''Checks if the input dictionary of users is valid.'''
messg = ''
valid = True
for user, user_details in six.iteritems(users):
if not user_details:
valid = False
messg += 'Please provide details for username {user}.\n'.format(user=user)
continue
if not (isinstance(user_details.get('level'), int) or 0 <= user_details.get('level') <= 15):
# warn!
messg += 'Level must be a integer between 0 and 15 for username {user}. Will assume 0.\n'.format(user=user)
return valid, messg
def _compute_diff(configured, expected):
'''Computes the differences between the actual config and the expected config'''
diff = {
'add': {},
'update': {},
'remove': {}
}
configured_users = set(configured.keys())
expected_users = set(expected.keys())
add_usernames = expected_users - configured_users
remove_usernames = configured_users - expected_users
common_usernames = expected_users & configured_users
add = dict((username, expected.get(username)) for username in add_usernames)
remove = dict((username, configured.get(username)) for username in remove_usernames)
update = {}
for username in common_usernames:
user_configuration = configured.get(username)
user_expected = expected.get(username)
if user_configuration == user_expected:
continue
update[username] = {}
for field, field_value in six.iteritems(user_expected):
if user_configuration.get(field) != field_value:
update[username][field] = field_value
diff.update({
'add': add,
'update': update,
'remove': remove
})
return diff
def _set_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _update_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _delete_users(users):
'''Calls users.delete_users.'''
return __salt__['users.delete_users'](users, commit=False)
# ----------------------------------------------------------------------------------------------------------------------
# callable functions
# ----------------------------------------------------------------------------------------------------------------------
def managed(name, users=None, defaults=None):
'''
Manages the configuration of the users on the device, as specified in the state SLS file. Users not defined in that
file will be remove whilst users not configured on the device, will be added.
SLS Example:
.. code-block:: yaml
netusers_example:
netusers.managed:
- users:
admin:
level: 15
password: $1$knmhgPPv$g8745biu4rb.Zf.IT.F/U1
sshkeys: []
restricted:
level: 1
password: $1$j34j5k4b$4d5SVjTiz1l.Zf.IT.F/K7
martin:
level: 15
password: ''
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg
jonathan:
level: 15
password: ''
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N
CLI Example:
salt 'edge01.kix01' state.sls router.users
Output example (raw python - can be reused in other modules):
.. code-block:: python
{
'netusers_|-netusers_example_|-netusers_example_|-managed': {
'comment': 'Configuration updated!',
'name': 'netusers_example',
'start_time': '10:57:08.678811',
'__id__': 'netusers_example',
'duration': 1620.982,
'__run_num__': 0,
'changes': {
'updated': {
'admin': {
'level': 15
},
'restricted': {
'level': 1
},
'martin': {
'sshkeys': [
'ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg'
]
}
},
'added': {
'jonathan': {
'password': '',
'sshkeys': [
'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N'
],
'level': 15
}
},
'removed': {
}
},
'result': True
}
}
CLI Output:
.. code-block:: bash
edge01.kix01:
----------
ID: netusers_example
Function: netusers.managed
Result: True
Comment: Configuration updated!
Started: 11:03:31.957725
Duration: 1220.435 ms
Changes:
----------
added:
----------
jonathan:
----------
level:
15
password:
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgG
R9zPkHGZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qao
qwpLB15GwLfEXBx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006
xeHh7rv7HtXF6zH3WIdUhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9
xZBq6DBb+sESMS4s7nFcsruMoedb+BAc3aww0naeWpogjSt+We7y2N
removed:
----------
updated:
----------
martin:
----------
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4
vwWHh0wJPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZ
KtCjO8LhbWCa+X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87
Oz1nKsKuNzm2csoUQlJtrmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwx
M570s35Of/vV0zoOccj753sXnpvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t
+wAAAIBURwSPZVElXe+9a43sF6M4ysT7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac
81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v
+zvMmv8KvQgHg
admin:
----------
level:
15
restricted:
----------
level:
1
Summary for edge01.kix01
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 1.220 s
'''
result = False
comment = ''
changes = {}
ret = {
'name': name,
'changes': changes,
'result': result,
'comment': comment
}
users = _ordered_dict_to_dict(users)
defaults = _ordered_dict_to_dict(defaults)
expected_users = _expand_users(users, defaults)
valid, message = _check_users(expected_users)
if not valid: # check and clean
ret['comment'] = 'Please provide a valid configuration: {error}'.format(error=message)
return ret
# ----- Retrieve existing users configuration and determine differences ------------------------------------------->
users_output = _retrieve_users()
if not users_output.get('result'):
ret['comment'] = 'Cannot retrieve users from the device: {reason}'.format(
reason=users_output.get('comment')
)
return ret
configured_users = users_output.get('out', {})
if configured_users == expected_users:
ret.update({
'comment': 'Users already configured as needed.',
'result': True
})
return ret
diff = _compute_diff(configured_users, expected_users)
users_to_add = diff.get('add', {})
users_to_update = diff.get('update', {})
users_to_remove = diff.get('remove', {})
changes = {
'added': users_to_add,
'updated': users_to_update,
'removed': users_to_remove
}
ret.update({
'changes': changes
})
if __opts__['test'] is True:
ret.update({
'result': None,
'comment': 'Testing mode: configuration was not changed!'
})
return ret
# <---- Retrieve existing NTP peers and determine peers to be added/removed --------------------------------------->
# ----- Call _set_users and _delete_users as needed --------------------------------------------------------------->
expected_config_change = False
successfully_changed = True
if users_to_add:
_set = _set_users(users_to_add)
if _set.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot configure new users: {reason}'.format(
reason=_set.get('comment')
)
if users_to_update:
_update = _update_users(users_to_update)
if _update.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot update the users configuration: {reason}'.format(
reason=_update.get('comment')
)
if users_to_remove:
_delete = _delete_users(users_to_remove)
if _delete.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot remove users: {reason}'.format(
reason=_delete.get('comment')
)
# <---- Call _set_users and _delete_users as needed ----------------------------------------------------------------
# ----- Try to commit changes ------------------------------------------------------------------------------------->
if expected_config_change and successfully_changed:
config_result, config_comment = __salt__['net.config_control']()
result = config_result
comment += config_comment
# <---- Try to commit changes --------------------------------------------------------------------------------------
if expected_config_change and result and not comment:
comment = 'Configuration updated!'
ret.update({
'result': result,
'comment': comment
})
return ret
|
saltstack/salt
|
salt/states/netusers.py
|
_check_users
|
python
|
def _check_users(users):
'''Checks if the input dictionary of users is valid.'''
messg = ''
valid = True
for user, user_details in six.iteritems(users):
if not user_details:
valid = False
messg += 'Please provide details for username {user}.\n'.format(user=user)
continue
if not (isinstance(user_details.get('level'), int) or 0 <= user_details.get('level') <= 15):
# warn!
messg += 'Level must be a integer between 0 and 15 for username {user}. Will assume 0.\n'.format(user=user)
return valid, messg
|
Checks if the input dictionary of users is valid.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/netusers.py#L85-L101
| null |
# -*- coding: utf-8 -*-
'''
Network Users
=============
Manage the users configuration on network devices via the NAPALM proxy.
:codeauthor: Mircea Ulinic <mircea@cloudflare.com>
:maturity: new
:depends: napalm
:platform: unix
Dependencies
------------
- :mod:`NAPALM proxy minion <salt.proxy.napalm>`
- :mod:`Users configuration management module <salt.modules.napalm_users>`
.. versionadded:: 2016.11.0
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
log = logging.getLogger(__name__)
# Python std lib
from copy import deepcopy
# salt lib
from salt.utils.json import loads, dumps
from salt.ext import six
# import NAPALM utils
import salt.utils.napalm
# ----------------------------------------------------------------------------------------------------------------------
# state properties
# ----------------------------------------------------------------------------------------------------------------------
__virtualname__ = 'netusers'
# ----------------------------------------------------------------------------------------------------------------------
# global variables
# ----------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
# property functions
# ----------------------------------------------------------------------------------------------------------------------
def __virtual__():
'''
NAPALM library must be installed for this module to work and run in a (proxy) minion.
'''
return salt.utils.napalm.virtual(__opts__, __virtualname__, __file__)
# ----------------------------------------------------------------------------------------------------------------------
# helper functions -- will not be exported
# ----------------------------------------------------------------------------------------------------------------------
def _retrieve_users():
'''Retrieves configured users'''
return __salt__['users.config']()
def _ordered_dict_to_dict(probes):
'''.'''
return loads(dumps(probes))
def _expand_users(device_users, common_users):
'''Creates a longer list of accepted users on the device.'''
expected_users = deepcopy(common_users)
expected_users.update(device_users)
return expected_users
def _compute_diff(configured, expected):
'''Computes the differences between the actual config and the expected config'''
diff = {
'add': {},
'update': {},
'remove': {}
}
configured_users = set(configured.keys())
expected_users = set(expected.keys())
add_usernames = expected_users - configured_users
remove_usernames = configured_users - expected_users
common_usernames = expected_users & configured_users
add = dict((username, expected.get(username)) for username in add_usernames)
remove = dict((username, configured.get(username)) for username in remove_usernames)
update = {}
for username in common_usernames:
user_configuration = configured.get(username)
user_expected = expected.get(username)
if user_configuration == user_expected:
continue
update[username] = {}
for field, field_value in six.iteritems(user_expected):
if user_configuration.get(field) != field_value:
update[username][field] = field_value
diff.update({
'add': add,
'update': update,
'remove': remove
})
return diff
def _set_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _update_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _delete_users(users):
'''Calls users.delete_users.'''
return __salt__['users.delete_users'](users, commit=False)
# ----------------------------------------------------------------------------------------------------------------------
# callable functions
# ----------------------------------------------------------------------------------------------------------------------
def managed(name, users=None, defaults=None):
'''
Manages the configuration of the users on the device, as specified in the state SLS file. Users not defined in that
file will be remove whilst users not configured on the device, will be added.
SLS Example:
.. code-block:: yaml
netusers_example:
netusers.managed:
- users:
admin:
level: 15
password: $1$knmhgPPv$g8745biu4rb.Zf.IT.F/U1
sshkeys: []
restricted:
level: 1
password: $1$j34j5k4b$4d5SVjTiz1l.Zf.IT.F/K7
martin:
level: 15
password: ''
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg
jonathan:
level: 15
password: ''
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N
CLI Example:
salt 'edge01.kix01' state.sls router.users
Output example (raw python - can be reused in other modules):
.. code-block:: python
{
'netusers_|-netusers_example_|-netusers_example_|-managed': {
'comment': 'Configuration updated!',
'name': 'netusers_example',
'start_time': '10:57:08.678811',
'__id__': 'netusers_example',
'duration': 1620.982,
'__run_num__': 0,
'changes': {
'updated': {
'admin': {
'level': 15
},
'restricted': {
'level': 1
},
'martin': {
'sshkeys': [
'ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg'
]
}
},
'added': {
'jonathan': {
'password': '',
'sshkeys': [
'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N'
],
'level': 15
}
},
'removed': {
}
},
'result': True
}
}
CLI Output:
.. code-block:: bash
edge01.kix01:
----------
ID: netusers_example
Function: netusers.managed
Result: True
Comment: Configuration updated!
Started: 11:03:31.957725
Duration: 1220.435 ms
Changes:
----------
added:
----------
jonathan:
----------
level:
15
password:
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgG
R9zPkHGZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qao
qwpLB15GwLfEXBx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006
xeHh7rv7HtXF6zH3WIdUhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9
xZBq6DBb+sESMS4s7nFcsruMoedb+BAc3aww0naeWpogjSt+We7y2N
removed:
----------
updated:
----------
martin:
----------
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4
vwWHh0wJPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZ
KtCjO8LhbWCa+X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87
Oz1nKsKuNzm2csoUQlJtrmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwx
M570s35Of/vV0zoOccj753sXnpvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t
+wAAAIBURwSPZVElXe+9a43sF6M4ysT7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac
81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v
+zvMmv8KvQgHg
admin:
----------
level:
15
restricted:
----------
level:
1
Summary for edge01.kix01
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 1.220 s
'''
result = False
comment = ''
changes = {}
ret = {
'name': name,
'changes': changes,
'result': result,
'comment': comment
}
users = _ordered_dict_to_dict(users)
defaults = _ordered_dict_to_dict(defaults)
expected_users = _expand_users(users, defaults)
valid, message = _check_users(expected_users)
if not valid: # check and clean
ret['comment'] = 'Please provide a valid configuration: {error}'.format(error=message)
return ret
# ----- Retrieve existing users configuration and determine differences ------------------------------------------->
users_output = _retrieve_users()
if not users_output.get('result'):
ret['comment'] = 'Cannot retrieve users from the device: {reason}'.format(
reason=users_output.get('comment')
)
return ret
configured_users = users_output.get('out', {})
if configured_users == expected_users:
ret.update({
'comment': 'Users already configured as needed.',
'result': True
})
return ret
diff = _compute_diff(configured_users, expected_users)
users_to_add = diff.get('add', {})
users_to_update = diff.get('update', {})
users_to_remove = diff.get('remove', {})
changes = {
'added': users_to_add,
'updated': users_to_update,
'removed': users_to_remove
}
ret.update({
'changes': changes
})
if __opts__['test'] is True:
ret.update({
'result': None,
'comment': 'Testing mode: configuration was not changed!'
})
return ret
# <---- Retrieve existing NTP peers and determine peers to be added/removed --------------------------------------->
# ----- Call _set_users and _delete_users as needed --------------------------------------------------------------->
expected_config_change = False
successfully_changed = True
if users_to_add:
_set = _set_users(users_to_add)
if _set.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot configure new users: {reason}'.format(
reason=_set.get('comment')
)
if users_to_update:
_update = _update_users(users_to_update)
if _update.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot update the users configuration: {reason}'.format(
reason=_update.get('comment')
)
if users_to_remove:
_delete = _delete_users(users_to_remove)
if _delete.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot remove users: {reason}'.format(
reason=_delete.get('comment')
)
# <---- Call _set_users and _delete_users as needed ----------------------------------------------------------------
# ----- Try to commit changes ------------------------------------------------------------------------------------->
if expected_config_change and successfully_changed:
config_result, config_comment = __salt__['net.config_control']()
result = config_result
comment += config_comment
# <---- Try to commit changes --------------------------------------------------------------------------------------
if expected_config_change and result and not comment:
comment = 'Configuration updated!'
ret.update({
'result': result,
'comment': comment
})
return ret
|
saltstack/salt
|
salt/states/netusers.py
|
_compute_diff
|
python
|
def _compute_diff(configured, expected):
'''Computes the differences between the actual config and the expected config'''
diff = {
'add': {},
'update': {},
'remove': {}
}
configured_users = set(configured.keys())
expected_users = set(expected.keys())
add_usernames = expected_users - configured_users
remove_usernames = configured_users - expected_users
common_usernames = expected_users & configured_users
add = dict((username, expected.get(username)) for username in add_usernames)
remove = dict((username, configured.get(username)) for username in remove_usernames)
update = {}
for username in common_usernames:
user_configuration = configured.get(username)
user_expected = expected.get(username)
if user_configuration == user_expected:
continue
update[username] = {}
for field, field_value in six.iteritems(user_expected):
if user_configuration.get(field) != field_value:
update[username][field] = field_value
diff.update({
'add': add,
'update': update,
'remove': remove
})
return diff
|
Computes the differences between the actual config and the expected config
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/netusers.py#L104-L141
| null |
# -*- coding: utf-8 -*-
'''
Network Users
=============
Manage the users configuration on network devices via the NAPALM proxy.
:codeauthor: Mircea Ulinic <mircea@cloudflare.com>
:maturity: new
:depends: napalm
:platform: unix
Dependencies
------------
- :mod:`NAPALM proxy minion <salt.proxy.napalm>`
- :mod:`Users configuration management module <salt.modules.napalm_users>`
.. versionadded:: 2016.11.0
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
log = logging.getLogger(__name__)
# Python std lib
from copy import deepcopy
# salt lib
from salt.utils.json import loads, dumps
from salt.ext import six
# import NAPALM utils
import salt.utils.napalm
# ----------------------------------------------------------------------------------------------------------------------
# state properties
# ----------------------------------------------------------------------------------------------------------------------
__virtualname__ = 'netusers'
# ----------------------------------------------------------------------------------------------------------------------
# global variables
# ----------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
# property functions
# ----------------------------------------------------------------------------------------------------------------------
def __virtual__():
'''
NAPALM library must be installed for this module to work and run in a (proxy) minion.
'''
return salt.utils.napalm.virtual(__opts__, __virtualname__, __file__)
# ----------------------------------------------------------------------------------------------------------------------
# helper functions -- will not be exported
# ----------------------------------------------------------------------------------------------------------------------
def _retrieve_users():
'''Retrieves configured users'''
return __salt__['users.config']()
def _ordered_dict_to_dict(probes):
'''.'''
return loads(dumps(probes))
def _expand_users(device_users, common_users):
'''Creates a longer list of accepted users on the device.'''
expected_users = deepcopy(common_users)
expected_users.update(device_users)
return expected_users
def _check_users(users):
'''Checks if the input dictionary of users is valid.'''
messg = ''
valid = True
for user, user_details in six.iteritems(users):
if not user_details:
valid = False
messg += 'Please provide details for username {user}.\n'.format(user=user)
continue
if not (isinstance(user_details.get('level'), int) or 0 <= user_details.get('level') <= 15):
# warn!
messg += 'Level must be a integer between 0 and 15 for username {user}. Will assume 0.\n'.format(user=user)
return valid, messg
def _set_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _update_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _delete_users(users):
'''Calls users.delete_users.'''
return __salt__['users.delete_users'](users, commit=False)
# ----------------------------------------------------------------------------------------------------------------------
# callable functions
# ----------------------------------------------------------------------------------------------------------------------
def managed(name, users=None, defaults=None):
'''
Manages the configuration of the users on the device, as specified in the state SLS file. Users not defined in that
file will be remove whilst users not configured on the device, will be added.
SLS Example:
.. code-block:: yaml
netusers_example:
netusers.managed:
- users:
admin:
level: 15
password: $1$knmhgPPv$g8745biu4rb.Zf.IT.F/U1
sshkeys: []
restricted:
level: 1
password: $1$j34j5k4b$4d5SVjTiz1l.Zf.IT.F/K7
martin:
level: 15
password: ''
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg
jonathan:
level: 15
password: ''
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N
CLI Example:
salt 'edge01.kix01' state.sls router.users
Output example (raw python - can be reused in other modules):
.. code-block:: python
{
'netusers_|-netusers_example_|-netusers_example_|-managed': {
'comment': 'Configuration updated!',
'name': 'netusers_example',
'start_time': '10:57:08.678811',
'__id__': 'netusers_example',
'duration': 1620.982,
'__run_num__': 0,
'changes': {
'updated': {
'admin': {
'level': 15
},
'restricted': {
'level': 1
},
'martin': {
'sshkeys': [
'ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg'
]
}
},
'added': {
'jonathan': {
'password': '',
'sshkeys': [
'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N'
],
'level': 15
}
},
'removed': {
}
},
'result': True
}
}
CLI Output:
.. code-block:: bash
edge01.kix01:
----------
ID: netusers_example
Function: netusers.managed
Result: True
Comment: Configuration updated!
Started: 11:03:31.957725
Duration: 1220.435 ms
Changes:
----------
added:
----------
jonathan:
----------
level:
15
password:
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgG
R9zPkHGZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qao
qwpLB15GwLfEXBx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006
xeHh7rv7HtXF6zH3WIdUhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9
xZBq6DBb+sESMS4s7nFcsruMoedb+BAc3aww0naeWpogjSt+We7y2N
removed:
----------
updated:
----------
martin:
----------
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4
vwWHh0wJPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZ
KtCjO8LhbWCa+X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87
Oz1nKsKuNzm2csoUQlJtrmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwx
M570s35Of/vV0zoOccj753sXnpvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t
+wAAAIBURwSPZVElXe+9a43sF6M4ysT7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac
81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v
+zvMmv8KvQgHg
admin:
----------
level:
15
restricted:
----------
level:
1
Summary for edge01.kix01
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 1.220 s
'''
result = False
comment = ''
changes = {}
ret = {
'name': name,
'changes': changes,
'result': result,
'comment': comment
}
users = _ordered_dict_to_dict(users)
defaults = _ordered_dict_to_dict(defaults)
expected_users = _expand_users(users, defaults)
valid, message = _check_users(expected_users)
if not valid: # check and clean
ret['comment'] = 'Please provide a valid configuration: {error}'.format(error=message)
return ret
# ----- Retrieve existing users configuration and determine differences ------------------------------------------->
users_output = _retrieve_users()
if not users_output.get('result'):
ret['comment'] = 'Cannot retrieve users from the device: {reason}'.format(
reason=users_output.get('comment')
)
return ret
configured_users = users_output.get('out', {})
if configured_users == expected_users:
ret.update({
'comment': 'Users already configured as needed.',
'result': True
})
return ret
diff = _compute_diff(configured_users, expected_users)
users_to_add = diff.get('add', {})
users_to_update = diff.get('update', {})
users_to_remove = diff.get('remove', {})
changes = {
'added': users_to_add,
'updated': users_to_update,
'removed': users_to_remove
}
ret.update({
'changes': changes
})
if __opts__['test'] is True:
ret.update({
'result': None,
'comment': 'Testing mode: configuration was not changed!'
})
return ret
# <---- Retrieve existing NTP peers and determine peers to be added/removed --------------------------------------->
# ----- Call _set_users and _delete_users as needed --------------------------------------------------------------->
expected_config_change = False
successfully_changed = True
if users_to_add:
_set = _set_users(users_to_add)
if _set.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot configure new users: {reason}'.format(
reason=_set.get('comment')
)
if users_to_update:
_update = _update_users(users_to_update)
if _update.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot update the users configuration: {reason}'.format(
reason=_update.get('comment')
)
if users_to_remove:
_delete = _delete_users(users_to_remove)
if _delete.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot remove users: {reason}'.format(
reason=_delete.get('comment')
)
# <---- Call _set_users and _delete_users as needed ----------------------------------------------------------------
# ----- Try to commit changes ------------------------------------------------------------------------------------->
if expected_config_change and successfully_changed:
config_result, config_comment = __salt__['net.config_control']()
result = config_result
comment += config_comment
# <---- Try to commit changes --------------------------------------------------------------------------------------
if expected_config_change and result and not comment:
comment = 'Configuration updated!'
ret.update({
'result': result,
'comment': comment
})
return ret
|
saltstack/salt
|
salt/states/netusers.py
|
managed
|
python
|
def managed(name, users=None, defaults=None):
'''
Manages the configuration of the users on the device, as specified in the state SLS file. Users not defined in that
file will be remove whilst users not configured on the device, will be added.
SLS Example:
.. code-block:: yaml
netusers_example:
netusers.managed:
- users:
admin:
level: 15
password: $1$knmhgPPv$g8745biu4rb.Zf.IT.F/U1
sshkeys: []
restricted:
level: 1
password: $1$j34j5k4b$4d5SVjTiz1l.Zf.IT.F/K7
martin:
level: 15
password: ''
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg
jonathan:
level: 15
password: ''
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N
CLI Example:
salt 'edge01.kix01' state.sls router.users
Output example (raw python - can be reused in other modules):
.. code-block:: python
{
'netusers_|-netusers_example_|-netusers_example_|-managed': {
'comment': 'Configuration updated!',
'name': 'netusers_example',
'start_time': '10:57:08.678811',
'__id__': 'netusers_example',
'duration': 1620.982,
'__run_num__': 0,
'changes': {
'updated': {
'admin': {
'level': 15
},
'restricted': {
'level': 1
},
'martin': {
'sshkeys': [
'ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg'
]
}
},
'added': {
'jonathan': {
'password': '',
'sshkeys': [
'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N'
],
'level': 15
}
},
'removed': {
}
},
'result': True
}
}
CLI Output:
.. code-block:: bash
edge01.kix01:
----------
ID: netusers_example
Function: netusers.managed
Result: True
Comment: Configuration updated!
Started: 11:03:31.957725
Duration: 1220.435 ms
Changes:
----------
added:
----------
jonathan:
----------
level:
15
password:
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgG
R9zPkHGZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qao
qwpLB15GwLfEXBx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006
xeHh7rv7HtXF6zH3WIdUhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9
xZBq6DBb+sESMS4s7nFcsruMoedb+BAc3aww0naeWpogjSt+We7y2N
removed:
----------
updated:
----------
martin:
----------
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4
vwWHh0wJPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZ
KtCjO8LhbWCa+X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87
Oz1nKsKuNzm2csoUQlJtrmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwx
M570s35Of/vV0zoOccj753sXnpvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t
+wAAAIBURwSPZVElXe+9a43sF6M4ysT7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac
81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v
+zvMmv8KvQgHg
admin:
----------
level:
15
restricted:
----------
level:
1
Summary for edge01.kix01
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 1.220 s
'''
result = False
comment = ''
changes = {}
ret = {
'name': name,
'changes': changes,
'result': result,
'comment': comment
}
users = _ordered_dict_to_dict(users)
defaults = _ordered_dict_to_dict(defaults)
expected_users = _expand_users(users, defaults)
valid, message = _check_users(expected_users)
if not valid: # check and clean
ret['comment'] = 'Please provide a valid configuration: {error}'.format(error=message)
return ret
# ----- Retrieve existing users configuration and determine differences ------------------------------------------->
users_output = _retrieve_users()
if not users_output.get('result'):
ret['comment'] = 'Cannot retrieve users from the device: {reason}'.format(
reason=users_output.get('comment')
)
return ret
configured_users = users_output.get('out', {})
if configured_users == expected_users:
ret.update({
'comment': 'Users already configured as needed.',
'result': True
})
return ret
diff = _compute_diff(configured_users, expected_users)
users_to_add = diff.get('add', {})
users_to_update = diff.get('update', {})
users_to_remove = diff.get('remove', {})
changes = {
'added': users_to_add,
'updated': users_to_update,
'removed': users_to_remove
}
ret.update({
'changes': changes
})
if __opts__['test'] is True:
ret.update({
'result': None,
'comment': 'Testing mode: configuration was not changed!'
})
return ret
# <---- Retrieve existing NTP peers and determine peers to be added/removed --------------------------------------->
# ----- Call _set_users and _delete_users as needed --------------------------------------------------------------->
expected_config_change = False
successfully_changed = True
if users_to_add:
_set = _set_users(users_to_add)
if _set.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot configure new users: {reason}'.format(
reason=_set.get('comment')
)
if users_to_update:
_update = _update_users(users_to_update)
if _update.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot update the users configuration: {reason}'.format(
reason=_update.get('comment')
)
if users_to_remove:
_delete = _delete_users(users_to_remove)
if _delete.get('result'):
expected_config_change = True
else: # something went wrong...
successfully_changed = False
comment += 'Cannot remove users: {reason}'.format(
reason=_delete.get('comment')
)
# <---- Call _set_users and _delete_users as needed ----------------------------------------------------------------
# ----- Try to commit changes ------------------------------------------------------------------------------------->
if expected_config_change and successfully_changed:
config_result, config_comment = __salt__['net.config_control']()
result = config_result
comment += config_comment
# <---- Try to commit changes --------------------------------------------------------------------------------------
if expected_config_change and result and not comment:
comment = 'Configuration updated!'
ret.update({
'result': result,
'comment': comment
})
return ret
|
Manages the configuration of the users on the device, as specified in the state SLS file. Users not defined in that
file will be remove whilst users not configured on the device, will be added.
SLS Example:
.. code-block:: yaml
netusers_example:
netusers.managed:
- users:
admin:
level: 15
password: $1$knmhgPPv$g8745biu4rb.Zf.IT.F/U1
sshkeys: []
restricted:
level: 1
password: $1$j34j5k4b$4d5SVjTiz1l.Zf.IT.F/K7
martin:
level: 15
password: ''
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg
jonathan:
level: 15
password: ''
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N
CLI Example:
salt 'edge01.kix01' state.sls router.users
Output example (raw python - can be reused in other modules):
.. code-block:: python
{
'netusers_|-netusers_example_|-netusers_example_|-managed': {
'comment': 'Configuration updated!',
'name': 'netusers_example',
'start_time': '10:57:08.678811',
'__id__': 'netusers_example',
'duration': 1620.982,
'__run_num__': 0,
'changes': {
'updated': {
'admin': {
'level': 15
},
'restricted': {
'level': 1
},
'martin': {
'sshkeys': [
'ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4vwWHh0w
JPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZKtCjO8LhbWCa+
X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87Oz1nKsKuNzm2csoUQlJ
trmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwxM570s35Of/vV0zoOccj753sXn
pvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t+wAAAIBURwSPZVElXe+9a43sF6M4ysT
7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0
bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v+zvMmv8KvQgHg'
]
}
},
'added': {
'jonathan': {
'password': '',
'sshkeys': [
'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgGR9zPkHG
ZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qaoqwpLB15GwLfEX
Bx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006xeHh7rv7HtXF6zH3WId
Uhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9xZBq6DBb+sESMS4s7nFcsruMo
edb+BAc3aww0naeWpogjSt+We7y2N'
],
'level': 15
}
},
'removed': {
}
},
'result': True
}
}
CLI Output:
.. code-block:: bash
edge01.kix01:
----------
ID: netusers_example
Function: netusers.managed
Result: True
Comment: Configuration updated!
Started: 11:03:31.957725
Duration: 1220.435 ms
Changes:
----------
added:
----------
jonathan:
----------
level:
15
password:
sshkeys:
- ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDcgxE6HZF/xjFtIt0thEDKPjFJxW9BpZtTVstYbDgG
R9zPkHGZJT/j345jk345jk453jk43545j35nl3kln34n5kl4ghv3/JzWt/0Js5KZp/51KRNCs9O4t07qao
qwpLB15GwLfEXBx9dW26zc4O+hi6754trxcfghvjbo98765drt/LYIEg0KSQPWyJEK1g31gacbxN7Ab006
xeHh7rv7HtXF6zH3WIdUhq9rtdUag6kYnv6qvjG7sbCyHGYu5vZB7GytnNuVNbZuI+RdFvmHSnErV9HCu9
xZBq6DBb+sESMS4s7nFcsruMoedb+BAc3aww0naeWpogjSt+We7y2N
removed:
----------
updated:
----------
martin:
----------
sshkeys:
- ssh-dss AAAAB3NzaC1kc3MAAACBAK9dP3KariMlM/JmFW9rTSm5cXs4nR0+o6fTHP9o+bOLXMBTP8R4
vwWHh0wJPjQmJYafAqZTnlgi0srGjyifFwPtODppDWLCgLe2M4LXnu3OMqknr54w344zPHP3iFwWxHrBrZ
KtCjO8LhbWCa+X528+i87t6r5e4ersdfxgchvjbknlio87t6r5drcfhgjhbknio8976tycv7t86ftyiu87
Oz1nKsKuNzm2csoUQlJtrmRfpjsOPNookmOz5wG0YxhwDmKeo6fWK+ATk1OiP+QT39fn4G77j8o+e4WAwx
M570s35Of/vV0zoOccj753sXnpvJenvwpM2H6o3a9ALvehAJKWodAgZT7X8+iu786r5drtycghvjbiu78t
+wAAAIBURwSPZVElXe+9a43sF6M4ysT7Xv+6wTsa8q86E3+RYyu8O2ObI2kwNLC3/HTgFniE/YqRG+WJac
81/VHWQNP822gns8RVrWKjqBktmQoEm7z5yy0bkjui78675dytcghvjkoi9y7t867ftcuvhbuu9t78gy/v
+zvMmv8KvQgHg
admin:
----------
level:
15
restricted:
----------
level:
1
Summary for edge01.kix01
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
Total run time: 1.220 s
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/netusers.py#L169-L443
|
[
"def _set_users(users):\n\n '''Calls users.set_users.'''\n\n return __salt__['users.set_users'](users, commit=False)\n",
"def _ordered_dict_to_dict(probes):\n\n '''.'''\n\n return loads(dumps(probes))\n",
"def _compute_diff(configured, expected):\n\n '''Computes the differences between the actual config and the expected config'''\n\n diff = {\n 'add': {},\n 'update': {},\n 'remove': {}\n }\n\n configured_users = set(configured.keys())\n expected_users = set(expected.keys())\n\n add_usernames = expected_users - configured_users\n remove_usernames = configured_users - expected_users\n common_usernames = expected_users & configured_users\n\n add = dict((username, expected.get(username)) for username in add_usernames)\n remove = dict((username, configured.get(username)) for username in remove_usernames)\n update = {}\n\n for username in common_usernames:\n user_configuration = configured.get(username)\n user_expected = expected.get(username)\n if user_configuration == user_expected:\n continue\n update[username] = {}\n for field, field_value in six.iteritems(user_expected):\n if user_configuration.get(field) != field_value:\n update[username][field] = field_value\n\n diff.update({\n 'add': add,\n 'update': update,\n 'remove': remove\n })\n\n return diff\n",
"def _retrieve_users():\n\n '''Retrieves configured users'''\n\n return __salt__['users.config']()\n",
"def _expand_users(device_users, common_users):\n\n '''Creates a longer list of accepted users on the device.'''\n\n expected_users = deepcopy(common_users)\n expected_users.update(device_users)\n\n return expected_users\n",
"def _check_users(users):\n\n '''Checks if the input dictionary of users is valid.'''\n\n messg = ''\n valid = True\n\n for user, user_details in six.iteritems(users):\n if not user_details:\n valid = False\n messg += 'Please provide details for username {user}.\\n'.format(user=user)\n continue\n if not (isinstance(user_details.get('level'), int) or 0 <= user_details.get('level') <= 15):\n # warn!\n messg += 'Level must be a integer between 0 and 15 for username {user}. Will assume 0.\\n'.format(user=user)\n\n return valid, messg\n",
"def _update_users(users):\n\n '''Calls users.set_users.'''\n\n return __salt__['users.set_users'](users, commit=False)\n",
"def _delete_users(users):\n\n '''Calls users.delete_users.'''\n\n return __salt__['users.delete_users'](users, commit=False)\n"
] |
# -*- coding: utf-8 -*-
'''
Network Users
=============
Manage the users configuration on network devices via the NAPALM proxy.
:codeauthor: Mircea Ulinic <mircea@cloudflare.com>
:maturity: new
:depends: napalm
:platform: unix
Dependencies
------------
- :mod:`NAPALM proxy minion <salt.proxy.napalm>`
- :mod:`Users configuration management module <salt.modules.napalm_users>`
.. versionadded:: 2016.11.0
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
log = logging.getLogger(__name__)
# Python std lib
from copy import deepcopy
# salt lib
from salt.utils.json import loads, dumps
from salt.ext import six
# import NAPALM utils
import salt.utils.napalm
# ----------------------------------------------------------------------------------------------------------------------
# state properties
# ----------------------------------------------------------------------------------------------------------------------
__virtualname__ = 'netusers'
# ----------------------------------------------------------------------------------------------------------------------
# global variables
# ----------------------------------------------------------------------------------------------------------------------
# ----------------------------------------------------------------------------------------------------------------------
# property functions
# ----------------------------------------------------------------------------------------------------------------------
def __virtual__():
'''
NAPALM library must be installed for this module to work and run in a (proxy) minion.
'''
return salt.utils.napalm.virtual(__opts__, __virtualname__, __file__)
# ----------------------------------------------------------------------------------------------------------------------
# helper functions -- will not be exported
# ----------------------------------------------------------------------------------------------------------------------
def _retrieve_users():
'''Retrieves configured users'''
return __salt__['users.config']()
def _ordered_dict_to_dict(probes):
'''.'''
return loads(dumps(probes))
def _expand_users(device_users, common_users):
'''Creates a longer list of accepted users on the device.'''
expected_users = deepcopy(common_users)
expected_users.update(device_users)
return expected_users
def _check_users(users):
'''Checks if the input dictionary of users is valid.'''
messg = ''
valid = True
for user, user_details in six.iteritems(users):
if not user_details:
valid = False
messg += 'Please provide details for username {user}.\n'.format(user=user)
continue
if not (isinstance(user_details.get('level'), int) or 0 <= user_details.get('level') <= 15):
# warn!
messg += 'Level must be a integer between 0 and 15 for username {user}. Will assume 0.\n'.format(user=user)
return valid, messg
def _compute_diff(configured, expected):
'''Computes the differences between the actual config and the expected config'''
diff = {
'add': {},
'update': {},
'remove': {}
}
configured_users = set(configured.keys())
expected_users = set(expected.keys())
add_usernames = expected_users - configured_users
remove_usernames = configured_users - expected_users
common_usernames = expected_users & configured_users
add = dict((username, expected.get(username)) for username in add_usernames)
remove = dict((username, configured.get(username)) for username in remove_usernames)
update = {}
for username in common_usernames:
user_configuration = configured.get(username)
user_expected = expected.get(username)
if user_configuration == user_expected:
continue
update[username] = {}
for field, field_value in six.iteritems(user_expected):
if user_configuration.get(field) != field_value:
update[username][field] = field_value
diff.update({
'add': add,
'update': update,
'remove': remove
})
return diff
def _set_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _update_users(users):
'''Calls users.set_users.'''
return __salt__['users.set_users'](users, commit=False)
def _delete_users(users):
'''Calls users.delete_users.'''
return __salt__['users.delete_users'](users, commit=False)
# ----------------------------------------------------------------------------------------------------------------------
# callable functions
# ----------------------------------------------------------------------------------------------------------------------
|
saltstack/salt
|
salt/netapi/rest_cherrypy/tools/websockets.py
|
SynchronizingWebsocket.received_message
|
python
|
def received_message(self, message):
'''
Checks if the client has sent a ready message.
A ready message causes ``send()`` to be called on the
``parent end`` of the pipe.
Clients need to ensure that the pipe assigned to ``self.pipe`` is
the ``parent end`` of a pipe.
This ensures completion of the underlying websocket connection
and can be used to synchronize parallel senders.
'''
if message.data.decode('utf-8') == 'websocket client ready':
self.pipe.send(message)
self.send('server received message', False)
|
Checks if the client has sent a ready message.
A ready message causes ``send()`` to be called on the
``parent end`` of the pipe.
Clients need to ensure that the pipe assigned to ``self.pipe`` is
the ``parent end`` of a pipe.
This ensures completion of the underlying websocket connection
and can be used to synchronize parallel senders.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/netapi/rest_cherrypy/tools/websockets.py#L45-L59
| null |
class SynchronizingWebsocket(WebSocket):
'''
Class to handle requests sent to this websocket connection.
Each instance of this class represents a Salt websocket connection.
Waits to receive a ``ready`` message from the client.
Calls send on it's end of the pipe to signal to the sender on receipt
of ``ready``.
This class also kicks off initial information probing jobs when clients
initially connect. These jobs help gather information about minions, jobs,
and documentation.
'''
def __init__(self, *args, **kwargs): # pylint: disable=E1002
super(SynchronizingWebsocket, self).__init__(*args, **kwargs)
# This pipe needs to represent the parent end of a pipe.
# Clients need to ensure that the pipe assigned to ``self.pipe`` is
# the ``parent end`` of a
# `pipe <https://docs.python.org/2/library/multiprocessing.html#exchanging-objects-between-processes>`_.
self.pipe = None
# The token that we can use to make API calls.
# There are times when we would like to kick off jobs,
# examples include trying to obtain minions connected.
self.token = None
# Options represent ``salt`` options defined in the configs.
self.opts = None
|
saltstack/salt
|
salt/utils/text.py
|
cli_info
|
python
|
def cli_info(data, title='Info'):
'''
Prints an info on CLI with the title.
Useful for infos, general errors etc.
:param data:
:param title:
:return:
'''
wrapper = textwrap.TextWrapper()
wrapper.initial_indent = ' ' * 4
wrapper.subsequent_indent = wrapper.initial_indent
return '{title}:\n\n{text}'.format(title=title, text=wrapper.fill(data))
|
Prints an info on CLI with the title.
Useful for infos, general errors etc.
:param data:
:param title:
:return:
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/utils/text.py#L9-L23
| null |
# coding=utf-8
'''
All text work utilities (formatting messages, layout etc).
'''
from __future__ import absolute_import, unicode_literals, print_function
import textwrap
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
get_users
|
python
|
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
|
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L34-L49
|
[
"def _list_items(action, key, profile=None, subdomain=None, api_key=None):\n '''\n List items belonging to an API call.\n\n This method should be in utils.pagerduty.\n '''\n items = _query(\n profile=profile,\n subdomain=subdomain,\n api_key=api_key,\n action=action\n )\n ret = {}\n for item in items[action]:\n ret[item[key]] = item\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
get_services
|
python
|
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
|
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L52-L67
|
[
"def _list_items(action, key, profile=None, subdomain=None, api_key=None):\n '''\n List items belonging to an API call.\n\n This method should be in utils.pagerduty.\n '''\n items = _query(\n profile=profile,\n subdomain=subdomain,\n api_key=api_key,\n action=action\n )\n ret = {}\n for item in items[action]:\n ret[item[key]] = item\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
get_schedules
|
python
|
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
|
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L70-L85
|
[
"def _list_items(action, key, profile=None, subdomain=None, api_key=None):\n '''\n List items belonging to an API call.\n\n This method should be in utils.pagerduty.\n '''\n items = _query(\n profile=profile,\n subdomain=subdomain,\n api_key=api_key,\n action=action\n )\n ret = {}\n for item in items[action]:\n ret[item[key]] = item\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
get_escalation_policies
|
python
|
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
|
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L88-L103
|
[
"def _list_items(action, key, profile=None, subdomain=None, api_key=None):\n '''\n List items belonging to an API call.\n\n This method should be in utils.pagerduty.\n '''\n items = _query(\n profile=profile,\n subdomain=subdomain,\n api_key=api_key,\n action=action\n )\n ret = {}\n for item in items[action]:\n ret[item[key]] = item\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
_list_items
|
python
|
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
|
List items belonging to an API call.
This method should be in utils.pagerduty.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L106-L121
|
[
"def _query(method='GET', profile=None, url=None, path='api/v1',\n action=None, api_key=None, service=None, params=None,\n data=None, subdomain=None, verify_ssl=True):\n '''\n Query the PagerDuty API.\n\n This method should be in utils.pagerduty.\n\n '''\n\n if profile:\n creds = __salt__['config.option'](profile)\n else:\n creds = {\n 'pagerduty.api_key': api_key,\n 'pagerduty.subdomain': subdomain,\n }\n\n if url is None:\n url = 'https://{0}.pagerduty.com/{1}/{2}'.format(\n creds['pagerduty.subdomain'],\n path,\n action\n )\n\n if params is None:\n params = {}\n\n if data is None:\n data = {}\n\n headers = {\n 'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])\n }\n\n if method != 'GET':\n headers['Content-type'] = 'application/json'\n\n result = requests.request(\n method,\n url,\n headers=headers,\n params=params,\n data=salt.utils.json.dumps(data),\n verify=verify_ssl\n )\n\n if result.text is None or result.text == '':\n return None\n result_json = result.json()\n # if this query supports pagination, loop and fetch all results, merge them together\n if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:\n offset = result_json['offset']\n limit = result_json['limit']\n total = result_json['total']\n while offset + limit < total:\n offset = offset + limit\n limit = 100\n data['offset'] = offset\n data['limit'] = limit\n next_page_results = requests.request(method,\n url,\n headers=headers,\n params=params,\n data=data, # Already serialized above, don't do it again\n verify=verify_ssl).json()\n offset = next_page_results['offset']\n limit = next_page_results['limit']\n # merge results\n for k, v in result_json.items():\n if isinstance(v, list):\n result_json[k] += next_page_results[k]\n return result_json\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
_query
|
python
|
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
|
Query the PagerDuty API.
This method should be in utils.pagerduty.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L124-L196
|
[
"def dumps(obj, **kwargs):\n '''\n .. versionadded:: 2018.3.0\n\n Wraps json.dumps, and assumes that ensure_ascii is False (unless explicitly\n passed as True) for unicode compatibility. Note that setting it to True\n will mess up any unicode characters, as they will be dumped as the string\n literal version of the unicode code point.\n\n On Python 2, encodes the result to a str since json.dumps does not want\n unicode types.\n\n You can pass an alternate json module (loaded via import_json() above)\n using the _json_module argument)\n '''\n json_module = kwargs.pop('_json_module', json)\n orig_enc_func = kwargs.pop('default', lambda x: x)\n\n def _enc_func(obj):\n obj = ThreadLocalProxy.unproxy(obj)\n return orig_enc_func(obj)\n\n if 'ensure_ascii' not in kwargs:\n kwargs['ensure_ascii'] = False\n if six.PY2:\n obj = salt.utils.data.encode(obj)\n return json_module.dumps(obj, default=_enc_func, **kwargs) # future lint: blacklisted-function\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
get_resource
|
python
|
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
|
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L210-L252
|
[
"def _query(method='GET', profile=None, url=None, path='api/v1',\n action=None, api_key=None, service=None, params=None,\n data=None, subdomain=None, verify_ssl=True):\n '''\n Query the PagerDuty API.\n\n This method should be in utils.pagerduty.\n\n '''\n\n if profile:\n creds = __salt__['config.option'](profile)\n else:\n creds = {\n 'pagerduty.api_key': api_key,\n 'pagerduty.subdomain': subdomain,\n }\n\n if url is None:\n url = 'https://{0}.pagerduty.com/{1}/{2}'.format(\n creds['pagerduty.subdomain'],\n path,\n action\n )\n\n if params is None:\n params = {}\n\n if data is None:\n data = {}\n\n headers = {\n 'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])\n }\n\n if method != 'GET':\n headers['Content-type'] = 'application/json'\n\n result = requests.request(\n method,\n url,\n headers=headers,\n params=params,\n data=salt.utils.json.dumps(data),\n verify=verify_ssl\n )\n\n if result.text is None or result.text == '':\n return None\n result_json = result.json()\n # if this query supports pagination, loop and fetch all results, merge them together\n if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:\n offset = result_json['offset']\n limit = result_json['limit']\n total = result_json['total']\n while offset + limit < total:\n offset = offset + limit\n limit = 100\n data['offset'] = offset\n data['limit'] = limit\n next_page_results = requests.request(method,\n url,\n headers=headers,\n params=params,\n data=data, # Already serialized above, don't do it again\n verify=verify_ssl).json()\n offset = next_page_results['offset']\n limit = next_page_results['limit']\n # merge results\n for k, v in result_json.items():\n if isinstance(v, list):\n result_json[k] += next_page_results[k]\n return result_json\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
create_or_update_resource
|
python
|
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
|
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L255-L309
|
[
"def _query(method='GET', profile=None, url=None, path='api/v1',\n action=None, api_key=None, service=None, params=None,\n data=None, subdomain=None, verify_ssl=True):\n '''\n Query the PagerDuty API.\n\n This method should be in utils.pagerduty.\n\n '''\n\n if profile:\n creds = __salt__['config.option'](profile)\n else:\n creds = {\n 'pagerduty.api_key': api_key,\n 'pagerduty.subdomain': subdomain,\n }\n\n if url is None:\n url = 'https://{0}.pagerduty.com/{1}/{2}'.format(\n creds['pagerduty.subdomain'],\n path,\n action\n )\n\n if params is None:\n params = {}\n\n if data is None:\n data = {}\n\n headers = {\n 'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])\n }\n\n if method != 'GET':\n headers['Content-type'] = 'application/json'\n\n result = requests.request(\n method,\n url,\n headers=headers,\n params=params,\n data=salt.utils.json.dumps(data),\n verify=verify_ssl\n )\n\n if result.text is None or result.text == '':\n return None\n result_json = result.json()\n # if this query supports pagination, loop and fetch all results, merge them together\n if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:\n offset = result_json['offset']\n limit = result_json['limit']\n total = result_json['total']\n while offset + limit < total:\n offset = offset + limit\n limit = 100\n data['offset'] = offset\n data['limit'] = limit\n next_page_results = requests.request(method,\n url,\n headers=headers,\n params=params,\n data=data, # Already serialized above, don't do it again\n verify=verify_ssl).json()\n offset = next_page_results['offset']\n limit = next_page_results['limit']\n # merge results\n for k, v in result_json.items():\n if isinstance(v, list):\n result_json[k] += next_page_results[k]\n return result_json\n",
"def _get_resource_id(resource):\n '''\n helper method to find the resource id, since PD API doesn't always return it in the same way\n '''\n if 'id' in resource:\n return resource['id']\n if 'schedule' in resource:\n return resource['schedule']['id']\n return None\n",
"def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):\n '''\n Get any single pagerduty resource by key.\n\n We allow flexible lookup by any of a list of identifier_fields.\n So, for example, you can look up users by email address or name by calling:\n\n get_resource('users', key, ['name', 'email'], ...)\n\n This method is mainly used to translate state sls into pagerduty id's for dependent objects.\n For example, a pagerduty escalation policy contains one or more schedules, which must be passed\n by their pagerduty id. We look up the schedules by name (using this method), and then translate\n the names into id's.\n\n This method is implemented by getting all objects of the resource type (cached into __context__),\n then brute force searching through the list and trying to match any of the identifier_fields.\n The __context__ cache is purged after any create, update or delete to the resource.\n '''\n # cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run\n if 'pagerduty_util.resource_cache' not in __context__:\n __context__['pagerduty_util.resource_cache'] = {}\n if resource_name not in __context__['pagerduty_util.resource_cache']:\n if resource_name == 'services':\n action = resource_name + '?include[]=escalation_policy'\n else:\n action = resource_name\n __context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,\n profile=profile,\n subdomain=subdomain,\n api_key=api_key)[resource_name]\n for resource in __context__['pagerduty_util.resource_cache'][resource_name]:\n for field in identifier_fields:\n if resource[field] == key:\n # PagerDuty's /schedules endpoint returns less data than /schedules/:id.\n # so, now that we found the schedule, we need to get all the data for it.\n if resource_name == 'schedules':\n full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),\n profile=profile,\n subdomain=subdomain,\n api_key=api_key)\n return full_resource_info\n return resource\n return None\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
delete_resource
|
python
|
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
|
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L312-L331
|
[
"def _query(method='GET', profile=None, url=None, path='api/v1',\n action=None, api_key=None, service=None, params=None,\n data=None, subdomain=None, verify_ssl=True):\n '''\n Query the PagerDuty API.\n\n This method should be in utils.pagerduty.\n\n '''\n\n if profile:\n creds = __salt__['config.option'](profile)\n else:\n creds = {\n 'pagerduty.api_key': api_key,\n 'pagerduty.subdomain': subdomain,\n }\n\n if url is None:\n url = 'https://{0}.pagerduty.com/{1}/{2}'.format(\n creds['pagerduty.subdomain'],\n path,\n action\n )\n\n if params is None:\n params = {}\n\n if data is None:\n data = {}\n\n headers = {\n 'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])\n }\n\n if method != 'GET':\n headers['Content-type'] = 'application/json'\n\n result = requests.request(\n method,\n url,\n headers=headers,\n params=params,\n data=salt.utils.json.dumps(data),\n verify=verify_ssl\n )\n\n if result.text is None or result.text == '':\n return None\n result_json = result.json()\n # if this query supports pagination, loop and fetch all results, merge them together\n if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:\n offset = result_json['offset']\n limit = result_json['limit']\n total = result_json['total']\n while offset + limit < total:\n offset = offset + limit\n limit = 100\n data['offset'] = offset\n data['limit'] = limit\n next_page_results = requests.request(method,\n url,\n headers=headers,\n params=params,\n data=data, # Already serialized above, don't do it again\n verify=verify_ssl).json()\n offset = next_page_results['offset']\n limit = next_page_results['limit']\n # merge results\n for k, v in result_json.items():\n if isinstance(v, list):\n result_json[k] += next_page_results[k]\n return result_json\n",
"def _get_resource_id(resource):\n '''\n helper method to find the resource id, since PD API doesn't always return it in the same way\n '''\n if 'id' in resource:\n return resource['id']\n if 'schedule' in resource:\n return resource['schedule']['id']\n return None\n",
"def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):\n '''\n Get any single pagerduty resource by key.\n\n We allow flexible lookup by any of a list of identifier_fields.\n So, for example, you can look up users by email address or name by calling:\n\n get_resource('users', key, ['name', 'email'], ...)\n\n This method is mainly used to translate state sls into pagerduty id's for dependent objects.\n For example, a pagerduty escalation policy contains one or more schedules, which must be passed\n by their pagerduty id. We look up the schedules by name (using this method), and then translate\n the names into id's.\n\n This method is implemented by getting all objects of the resource type (cached into __context__),\n then brute force searching through the list and trying to match any of the identifier_fields.\n The __context__ cache is purged after any create, update or delete to the resource.\n '''\n # cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run\n if 'pagerduty_util.resource_cache' not in __context__:\n __context__['pagerduty_util.resource_cache'] = {}\n if resource_name not in __context__['pagerduty_util.resource_cache']:\n if resource_name == 'services':\n action = resource_name + '?include[]=escalation_policy'\n else:\n action = resource_name\n __context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,\n profile=profile,\n subdomain=subdomain,\n api_key=api_key)[resource_name]\n for resource in __context__['pagerduty_util.resource_cache'][resource_name]:\n for field in identifier_fields:\n if resource[field] == key:\n # PagerDuty's /schedules endpoint returns less data than /schedules/:id.\n # so, now that we found the schedule, we need to get all the data for it.\n if resource_name == 'schedules':\n full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),\n profile=profile,\n subdomain=subdomain,\n api_key=api_key)\n return full_resource_info\n return resource\n return None\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
resource_present
|
python
|
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
|
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L334-L368
|
[
"def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):\n '''\n create or update any pagerduty resource\n Helper method for present().\n\n Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.\n The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and\n should return a dict of data to pass to the PagerDuty update API method, or None if no update\n is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,\n comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.\n\n examples:\n create_or_update_resource(\"user\", [\"id\",\"name\",\"email\"])\n create_or_update_resource(\"escalation_policies\", [\"id\",\"name\"], diff=my_diff_function)\n\n '''\n # try to locate the resource by any of the identifier_fields that are specified in data\n resource = None\n for field in identifier_fields:\n if field in data:\n resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)\n if resource is not None:\n break\n\n if resource is None:\n if __opts__['test']:\n return 'would create'\n # flush the resource_cache, because we're modifying a resource\n del __context__['pagerduty_util.resource_cache'][resource_name]\n # create\n return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)\n else:\n # update\n data_to_update = {}\n # if differencing function is provided, use it\n if diff:\n data_to_update = diff(data, resource)\n # else default to naive key-value walk of the dicts\n else:\n for k, v in data.items():\n if k.startswith('_'):\n continue\n resource_value = resource.get(k, None)\n if resource_value is not None and resource_value != v:\n data_to_update[k] = v\n if data_to_update:\n if __opts__['test']:\n return 'would update'\n # flush the resource_cache, because we're modifying a resource\n del __context__['pagerduty_util.resource_cache'][resource_name]\n resource_id = _get_resource_id(resource)\n return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,\n profile=profile, subdomain=subdomain, api_key=api_key)\n else:\n return True\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
saltstack/salt
|
salt/modules/pagerduty_util.py
|
resource_absent
|
python
|
def resource_absent(resource, identifier_fields, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
for k, v in kwargs.items():
if k not in identifier_fields:
continue
result = delete_resource(resource,
v,
identifier_fields,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is None:
ret['result'] = True
ret['comment'] = '{0} deleted'.format(v)
return ret
elif result is True:
continue
elif __opts__['test']:
ret['comment'] = result
return ret
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
return ret
return ret
|
Generic resource.absent state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls delete_resource() and formats the result as a salt state return value.
example:
resource_absent("users", ["id","name","email"])
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/pagerduty_util.py#L371-L407
|
[
"def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):\n '''\n delete any pagerduty resource\n\n Helper method for absent()\n\n example:\n delete_resource(\"users\", key, [\"id\",\"name\",\"email\"]) # delete by id or name or email\n\n '''\n resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)\n if resource:\n if __opts__['test']:\n return 'would delete'\n # flush the resource_cache, because we're modifying a resource\n del __context__['pagerduty_util.resource_cache'][resource_name]\n resource_id = _get_resource_id(resource)\n return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)\n else:\n return True\n"
] |
# -*- coding: utf-8 -*-
'''
Module for manageing PagerDuty resource
:configuration: This module can be used by specifying the name of a
configuration profile in the minion config, minion pillar, or master
config. The default configuration profile name is 'pagerduty.'
For example:
.. code-block:: yaml
pagerduty:
pagerduty.api_key: F3Rbyjbve43rfFWf2214
pagerduty.subdomain: mysubdomain
For PagerDuty API details, see https://developer.pagerduty.com/documentation/rest
'''
from __future__ import absolute_import, print_function, unicode_literals
import requests
import salt.utils.json
def __virtual__():
'''
No dependencies outside of what Salt itself requires
'''
return True
def get_users(profile='pagerduty', subdomain=None, api_key=None):
'''
List users belonging to this account
CLI Example:
salt myminion pagerduty.get_users
'''
return _list_items(
'users',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_services(profile='pagerduty', subdomain=None, api_key=None):
'''
List services belonging to this account
CLI Example:
salt myminion pagerduty.get_services
'''
return _list_items(
'services',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_schedules(profile='pagerduty', subdomain=None, api_key=None):
'''
List schedules belonging to this account
CLI Example:
salt myminion pagerduty.get_schedules
'''
return _list_items(
'schedules',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
'''
List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies
'''
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
)
def _list_items(action, key, profile=None, subdomain=None, api_key=None):
'''
List items belonging to an API call.
This method should be in utils.pagerduty.
'''
items = _query(
profile=profile,
subdomain=subdomain,
api_key=api_key,
action=action
)
ret = {}
for item in items[action]:
ret[item[key]] = item
return ret
def _query(method='GET', profile=None, url=None, path='api/v1',
action=None, api_key=None, service=None, params=None,
data=None, subdomain=None, verify_ssl=True):
'''
Query the PagerDuty API.
This method should be in utils.pagerduty.
'''
if profile:
creds = __salt__['config.option'](profile)
else:
creds = {
'pagerduty.api_key': api_key,
'pagerduty.subdomain': subdomain,
}
if url is None:
url = 'https://{0}.pagerduty.com/{1}/{2}'.format(
creds['pagerduty.subdomain'],
path,
action
)
if params is None:
params = {}
if data is None:
data = {}
headers = {
'Authorization': 'Token token={0}'.format(creds['pagerduty.api_key'])
}
if method != 'GET':
headers['Content-type'] = 'application/json'
result = requests.request(
method,
url,
headers=headers,
params=params,
data=salt.utils.json.dumps(data),
verify=verify_ssl
)
if result.text is None or result.text == '':
return None
result_json = result.json()
# if this query supports pagination, loop and fetch all results, merge them together
if 'total' in result_json and 'offset' in result_json and 'limit' in result_json:
offset = result_json['offset']
limit = result_json['limit']
total = result_json['total']
while offset + limit < total:
offset = offset + limit
limit = 100
data['offset'] = offset
data['limit'] = limit
next_page_results = requests.request(method,
url,
headers=headers,
params=params,
data=data, # Already serialized above, don't do it again
verify=verify_ssl).json()
offset = next_page_results['offset']
limit = next_page_results['limit']
# merge results
for k, v in result_json.items():
if isinstance(v, list):
result_json[k] += next_page_results[k]
return result_json
def _get_resource_id(resource):
'''
helper method to find the resource id, since PD API doesn't always return it in the same way
'''
if 'id' in resource:
return resource['id']
if 'schedule' in resource:
return resource['schedule']['id']
return None
def get_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
Get any single pagerduty resource by key.
We allow flexible lookup by any of a list of identifier_fields.
So, for example, you can look up users by email address or name by calling:
get_resource('users', key, ['name', 'email'], ...)
This method is mainly used to translate state sls into pagerduty id's for dependent objects.
For example, a pagerduty escalation policy contains one or more schedules, which must be passed
by their pagerduty id. We look up the schedules by name (using this method), and then translate
the names into id's.
This method is implemented by getting all objects of the resource type (cached into __context__),
then brute force searching through the list and trying to match any of the identifier_fields.
The __context__ cache is purged after any create, update or delete to the resource.
'''
# cache the expensive 'get all resources' calls into __context__ so that we do them once per salt run
if 'pagerduty_util.resource_cache' not in __context__:
__context__['pagerduty_util.resource_cache'] = {}
if resource_name not in __context__['pagerduty_util.resource_cache']:
if resource_name == 'services':
action = resource_name + '?include[]=escalation_policy'
else:
action = resource_name
__context__['pagerduty_util.resource_cache'][resource_name] = _query(action=action,
profile=profile,
subdomain=subdomain,
api_key=api_key)[resource_name]
for resource in __context__['pagerduty_util.resource_cache'][resource_name]:
for field in identifier_fields:
if resource[field] == key:
# PagerDuty's /schedules endpoint returns less data than /schedules/:id.
# so, now that we found the schedule, we need to get all the data for it.
if resource_name == 'schedules':
full_resource_info = _query(action='{0}/{1}'.format(resource_name, resource['id']),
profile=profile,
subdomain=subdomain,
api_key=api_key)
return full_resource_info
return resource
return None
def create_or_update_resource(resource_name, identifier_fields, data, diff=None, profile='pagerduty', subdomain=None, api_key=None):
'''
create or update any pagerduty resource
Helper method for present().
Determining if two resources are the same is different for different PD resource, so this method accepts a diff function.
The diff function will be invoked as diff(state_information, object_returned_from_pagerduty), and
should return a dict of data to pass to the PagerDuty update API method, or None if no update
is to be performed. If no diff method is provided, the default behavor is to scan the keys in the state_information,
comparing the matching values in the object_returned_from_pagerduty, and update any values that differ.
examples:
create_or_update_resource("user", ["id","name","email"])
create_or_update_resource("escalation_policies", ["id","name"], diff=my_diff_function)
'''
# try to locate the resource by any of the identifier_fields that are specified in data
resource = None
for field in identifier_fields:
if field in data:
resource = get_resource(resource_name, data[field], identifier_fields, profile, subdomain, api_key)
if resource is not None:
break
if resource is None:
if __opts__['test']:
return 'would create'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
# create
return _query(method='POST', action=resource_name, data=data, profile=profile, subdomain=subdomain, api_key=api_key)
else:
# update
data_to_update = {}
# if differencing function is provided, use it
if diff:
data_to_update = diff(data, resource)
# else default to naive key-value walk of the dicts
else:
for k, v in data.items():
if k.startswith('_'):
continue
resource_value = resource.get(k, None)
if resource_value is not None and resource_value != v:
data_to_update[k] = v
if data_to_update:
if __opts__['test']:
return 'would update'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='PUT', action='{0}/{1}'.format(resource_name, resource_id), data=data_to_update,
profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def delete_resource(resource_name, key, identifier_fields, profile='pagerduty', subdomain=None, api_key=None):
'''
delete any pagerduty resource
Helper method for absent()
example:
delete_resource("users", key, ["id","name","email"]) # delete by id or name or email
'''
resource = get_resource(resource_name, key, identifier_fields, profile, subdomain, api_key)
if resource:
if __opts__['test']:
return 'would delete'
# flush the resource_cache, because we're modifying a resource
del __context__['pagerduty_util.resource_cache'][resource_name]
resource_id = _get_resource_id(resource)
return _query(method='DELETE', action='{0}/{1}'.format(resource_name, resource_id), profile=profile, subdomain=subdomain, api_key=api_key)
else:
return True
def resource_present(resource, identifier_fields, diff=None, profile='pagerduty', subdomain=None, api_key=None, **kwargs):
'''
Generic resource.present state method. Pagerduty state modules should be a thin wrapper over this method,
with a custom diff function.
This method calls create_or_update_resource() and formats the result as a salt state return value.
example:
resource_present("users", ["id","name","email"])
'''
ret = {'name': kwargs['name'],
'changes': {},
'result': None,
'comment': ''}
result = create_or_update_resource(resource,
identifier_fields,
kwargs,
diff=diff,
profile=profile,
subdomain=subdomain,
api_key=api_key)
if result is True:
pass
elif result is None:
ret['result'] = True
elif __opts__['test']:
ret['comment'] = result
elif 'error' in result:
ret['result'] = False
ret['comment'] = result
else:
ret['result'] = True
ret['comment'] = result
return ret
|
saltstack/salt
|
salt/states/nexus.py
|
downloaded
|
python
|
def downloaded(name, artifact, target_dir='/tmp', target_file=None):
'''
Ensures that the artifact from nexus exists at given location. If it doesn't exist, then
it will be downloaded. If it already exists then the checksum of existing file is checked
against checksum in nexus. If it is different then the step will fail.
artifact
Details of the artifact to be downloaded from nexus. Various options are:
- nexus_url: URL of the nexus instance
- repository: Repository in nexus
- artifact_id: Artifact ID
- group_id: Group ID
- packaging: Packaging
- classifier: Classifier
- version: Version
One of the following:
- Version to download
- ``latest`` - Download the latest release of this artifact
- ``latest_snapshot`` - Download the latest snapshot for this artifact
- username: nexus username
- password: nexus password
target_dir
Directory where the artifact should be downloaded. By default it is downloaded to /tmp directory.
target_file
Target file to download artifact to. By default file name is resolved by nexus.
An example to download an artifact to a specific file:
.. code-block:: yaml
jboss_module_downloaded:
nexus.downloaded:
- artifact:
nexus_url: http://nexus.intranet.example.com/repository
repository: 'libs-release-local'
artifact_id: 'module'
group_id: 'com.company.module'
packaging: 'jar'
classifier: 'sources'
version: '1.0'
- target_file: /opt/jboss7/modules/com/company/lib/module.jar
Download artifact to the folder (automatically resolves file name):
.. code-block:: yaml
maven_artifact_downloaded:
nexus.downloaded:
- artifact:
nexus_url: http://nexus.intranet.example.com/repository
repository: 'maven-releases'
artifact_id: 'module'
group_id: 'com.company.module'
packaging: 'zip'
classifier: 'dist'
version: '1.0'
- target_dir: /opt/maven/modules/com/company/release
'''
log.debug(" ======================== STATE: nexus.downloaded (name: %s) ", name)
ret = {'name': name,
'result': True,
'changes': {},
'comment': ''}
try:
fetch_result = __fetch_from_nexus(artifact, target_dir, target_file)
except Exception as exc:
ret['result'] = False
ret['comment'] = six.text_type(exc)
return ret
log.debug("fetch_result=%s", fetch_result)
ret['result'] = fetch_result['status']
ret['comment'] = fetch_result['comment']
ret['changes'] = fetch_result['changes']
log.debug("ret=%s", ret)
return ret
|
Ensures that the artifact from nexus exists at given location. If it doesn't exist, then
it will be downloaded. If it already exists then the checksum of existing file is checked
against checksum in nexus. If it is different then the step will fail.
artifact
Details of the artifact to be downloaded from nexus. Various options are:
- nexus_url: URL of the nexus instance
- repository: Repository in nexus
- artifact_id: Artifact ID
- group_id: Group ID
- packaging: Packaging
- classifier: Classifier
- version: Version
One of the following:
- Version to download
- ``latest`` - Download the latest release of this artifact
- ``latest_snapshot`` - Download the latest snapshot for this artifact
- username: nexus username
- password: nexus password
target_dir
Directory where the artifact should be downloaded. By default it is downloaded to /tmp directory.
target_file
Target file to download artifact to. By default file name is resolved by nexus.
An example to download an artifact to a specific file:
.. code-block:: yaml
jboss_module_downloaded:
nexus.downloaded:
- artifact:
nexus_url: http://nexus.intranet.example.com/repository
repository: 'libs-release-local'
artifact_id: 'module'
group_id: 'com.company.module'
packaging: 'jar'
classifier: 'sources'
version: '1.0'
- target_file: /opt/jboss7/modules/com/company/lib/module.jar
Download artifact to the folder (automatically resolves file name):
.. code-block:: yaml
maven_artifact_downloaded:
nexus.downloaded:
- artifact:
nexus_url: http://nexus.intranet.example.com/repository
repository: 'maven-releases'
artifact_id: 'module'
group_id: 'com.company.module'
packaging: 'zip'
classifier: 'dist'
version: '1.0'
- target_dir: /opt/maven/modules/com/company/release
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/nexus.py#L27-L110
|
[
"def __fetch_from_nexus(artifact, target_dir, target_file):\n nexus_url = artifact['nexus_url']\n repository = artifact['repository']\n group_id = artifact['group_id']\n artifact_id = artifact['artifact_id']\n packaging = artifact['packaging'] if 'packaging' in artifact else 'jar'\n classifier = artifact['classifier'] if 'classifier' in artifact else None\n username = artifact['username'] if 'username' in artifact else None\n password = artifact['password'] if 'password' in artifact else None\n version = artifact['version'] if 'version' in artifact else None\n\n # determine module function to use\n if version == 'latest_snapshot':\n function = 'nexus.get_latest_snapshot'\n version_param = False\n elif version == 'latest':\n function = 'nexus.get_latest_release'\n version_param = False\n elif version.endswith('SNAPSHOT'):\n function = 'nexus.get_snapshot'\n version_param = True\n else:\n function = 'nexus.get_release'\n version_param = True\n\n if version_param:\n fetch_result = __salt__[function](nexus_url=nexus_url,\n repository=repository,\n group_id=group_id,\n artifact_id=artifact_id,\n packaging=packaging,\n classifier=classifier,\n target_dir=target_dir,\n target_file=target_file,\n username=username,\n password=password,\n version=version)\n else:\n fetch_result = __salt__[function](nexus_url=nexus_url,\n repository=repository,\n group_id=group_id,\n artifact_id=artifact_id,\n packaging=packaging,\n classifier=classifier,\n target_dir=target_dir,\n target_file=target_file,\n username=username,\n password=password)\n\n return fetch_result\n"
] |
# -*- coding: utf-8 -*-
'''
This state downloads artifacts from Nexus 3.x.
.. versionadded:: 2018.3.0
'''
# Import python libs
from __future__ import absolute_import, print_function, unicode_literals
import logging
# Import Salt libs
from salt.ext import six
log = logging.getLogger(__name__)
__virtualname__ = 'nexus'
def __virtual__():
'''
Set the virtual name for the module
'''
return __virtualname__
def __fetch_from_nexus(artifact, target_dir, target_file):
nexus_url = artifact['nexus_url']
repository = artifact['repository']
group_id = artifact['group_id']
artifact_id = artifact['artifact_id']
packaging = artifact['packaging'] if 'packaging' in artifact else 'jar'
classifier = artifact['classifier'] if 'classifier' in artifact else None
username = artifact['username'] if 'username' in artifact else None
password = artifact['password'] if 'password' in artifact else None
version = artifact['version'] if 'version' in artifact else None
# determine module function to use
if version == 'latest_snapshot':
function = 'nexus.get_latest_snapshot'
version_param = False
elif version == 'latest':
function = 'nexus.get_latest_release'
version_param = False
elif version.endswith('SNAPSHOT'):
function = 'nexus.get_snapshot'
version_param = True
else:
function = 'nexus.get_release'
version_param = True
if version_param:
fetch_result = __salt__[function](nexus_url=nexus_url,
repository=repository,
group_id=group_id,
artifact_id=artifact_id,
packaging=packaging,
classifier=classifier,
target_dir=target_dir,
target_file=target_file,
username=username,
password=password,
version=version)
else:
fetch_result = __salt__[function](nexus_url=nexus_url,
repository=repository,
group_id=group_id,
artifact_id=artifact_id,
packaging=packaging,
classifier=classifier,
target_dir=target_dir,
target_file=target_file,
username=username,
password=password)
return fetch_result
|
saltstack/salt
|
salt/modules/chronos.py
|
_jobs
|
python
|
def _jobs():
'''
Return the currently configured jobs.
'''
response = salt.utils.http.query(
"{0}/scheduler/jobs".format(_base_url()),
decode_type='json',
decode=True,
)
jobs = {}
for job in response['dict']:
jobs[job.pop('name')] = job
return jobs
|
Return the currently configured jobs.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/chronos.py#L37-L49
|
[
"def _base_url():\n '''\n Return the proxy configured base url.\n '''\n base_url = \"http://locahost:4400\"\n if 'proxy' in __opts__:\n base_url = __opts__['proxy'].get('base_url', base_url)\n return base_url\n"
] |
# -*- coding: utf-8 -*-
'''
Module providing a simple management interface to a chronos cluster.
Currently this only works when run through a proxy minion.
.. versionadded:: 2015.8.2
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
import salt.utils.http
import salt.utils.json
import salt.utils.platform
from salt.exceptions import get_error_message
__proxyenabled__ = ['chronos']
log = logging.getLogger(__file__)
def __virtual__():
# only valid in proxy minions for now
return salt.utils.platform.is_proxy() and 'proxy' in __opts__
def _base_url():
'''
Return the proxy configured base url.
'''
base_url = "http://locahost:4400"
if 'proxy' in __opts__:
base_url = __opts__['proxy'].get('base_url', base_url)
return base_url
def jobs():
'''
Return a list of the currently installed job names.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.jobs
'''
job_names = _jobs().keys()
job_names.sort()
return {'jobs': job_names}
def has_job(name):
'''
Return whether the given job is currently configured.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.has_job my-job
'''
return name in _jobs()
def job(name):
'''
Return the current server configuration for the specified job.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.job my-job
'''
jobs = _jobs()
if name in jobs:
return {'job': jobs[name]}
return None
def update_job(name, config):
'''
Update the specified job with the given configuration.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.update_job my-job '<config yaml>'
'''
if 'name' not in config:
config['name'] = name
data = salt.utils.json.dumps(config)
try:
response = salt.utils.http.query(
"{0}/scheduler/iso8601".format(_base_url()),
method='POST',
data=data,
header_dict={
'Content-Type': 'application/json',
},
)
log.debug('update response: %s', response)
return {'success': True}
except Exception as ex:
log.error('unable to update chronos job: %s', get_error_message(ex))
return {
'exception': {
'message': get_error_message(ex),
}
}
def rm_job(name):
'''
Remove the specified job from the server.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.rm_job my-job
'''
response = salt.utils.http.query(
"{0}/scheduler/job/{1}".format(_base_url(), name),
method='DELETE',
)
return True
|
saltstack/salt
|
salt/modules/chronos.py
|
update_job
|
python
|
def update_job(name, config):
'''
Update the specified job with the given configuration.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.update_job my-job '<config yaml>'
'''
if 'name' not in config:
config['name'] = name
data = salt.utils.json.dumps(config)
try:
response = salt.utils.http.query(
"{0}/scheduler/iso8601".format(_base_url()),
method='POST',
data=data,
header_dict={
'Content-Type': 'application/json',
},
)
log.debug('update response: %s', response)
return {'success': True}
except Exception as ex:
log.error('unable to update chronos job: %s', get_error_message(ex))
return {
'exception': {
'message': get_error_message(ex),
}
}
|
Update the specified job with the given configuration.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.update_job my-job '<config yaml>'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/chronos.py#L96-L126
|
[
"def dumps(obj, **kwargs):\n '''\n .. versionadded:: 2018.3.0\n\n Wraps json.dumps, and assumes that ensure_ascii is False (unless explicitly\n passed as True) for unicode compatibility. Note that setting it to True\n will mess up any unicode characters, as they will be dumped as the string\n literal version of the unicode code point.\n\n On Python 2, encodes the result to a str since json.dumps does not want\n unicode types.\n\n You can pass an alternate json module (loaded via import_json() above)\n using the _json_module argument)\n '''\n json_module = kwargs.pop('_json_module', json)\n orig_enc_func = kwargs.pop('default', lambda x: x)\n\n def _enc_func(obj):\n obj = ThreadLocalProxy.unproxy(obj)\n return orig_enc_func(obj)\n\n if 'ensure_ascii' not in kwargs:\n kwargs['ensure_ascii'] = False\n if six.PY2:\n obj = salt.utils.data.encode(obj)\n return json_module.dumps(obj, default=_enc_func, **kwargs) # future lint: blacklisted-function\n",
"def get_error_message(error):\n '''\n Get human readable message from Python Exception\n '''\n return error.args[0] if error.args else ''\n",
"def _base_url():\n '''\n Return the proxy configured base url.\n '''\n base_url = \"http://locahost:4400\"\n if 'proxy' in __opts__:\n base_url = __opts__['proxy'].get('base_url', base_url)\n return base_url\n"
] |
# -*- coding: utf-8 -*-
'''
Module providing a simple management interface to a chronos cluster.
Currently this only works when run through a proxy minion.
.. versionadded:: 2015.8.2
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
import salt.utils.http
import salt.utils.json
import salt.utils.platform
from salt.exceptions import get_error_message
__proxyenabled__ = ['chronos']
log = logging.getLogger(__file__)
def __virtual__():
# only valid in proxy minions for now
return salt.utils.platform.is_proxy() and 'proxy' in __opts__
def _base_url():
'''
Return the proxy configured base url.
'''
base_url = "http://locahost:4400"
if 'proxy' in __opts__:
base_url = __opts__['proxy'].get('base_url', base_url)
return base_url
def _jobs():
'''
Return the currently configured jobs.
'''
response = salt.utils.http.query(
"{0}/scheduler/jobs".format(_base_url()),
decode_type='json',
decode=True,
)
jobs = {}
for job in response['dict']:
jobs[job.pop('name')] = job
return jobs
def jobs():
'''
Return a list of the currently installed job names.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.jobs
'''
job_names = _jobs().keys()
job_names.sort()
return {'jobs': job_names}
def has_job(name):
'''
Return whether the given job is currently configured.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.has_job my-job
'''
return name in _jobs()
def job(name):
'''
Return the current server configuration for the specified job.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.job my-job
'''
jobs = _jobs()
if name in jobs:
return {'job': jobs[name]}
return None
def rm_job(name):
'''
Remove the specified job from the server.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.rm_job my-job
'''
response = salt.utils.http.query(
"{0}/scheduler/job/{1}".format(_base_url(), name),
method='DELETE',
)
return True
|
saltstack/salt
|
salt/modules/chronos.py
|
rm_job
|
python
|
def rm_job(name):
'''
Remove the specified job from the server.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.rm_job my-job
'''
response = salt.utils.http.query(
"{0}/scheduler/job/{1}".format(_base_url(), name),
method='DELETE',
)
return True
|
Remove the specified job from the server.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.rm_job my-job
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/chronos.py#L129-L143
|
[
"def _base_url():\n '''\n Return the proxy configured base url.\n '''\n base_url = \"http://locahost:4400\"\n if 'proxy' in __opts__:\n base_url = __opts__['proxy'].get('base_url', base_url)\n return base_url\n"
] |
# -*- coding: utf-8 -*-
'''
Module providing a simple management interface to a chronos cluster.
Currently this only works when run through a proxy minion.
.. versionadded:: 2015.8.2
'''
from __future__ import absolute_import, print_function, unicode_literals
import logging
import salt.utils.http
import salt.utils.json
import salt.utils.platform
from salt.exceptions import get_error_message
__proxyenabled__ = ['chronos']
log = logging.getLogger(__file__)
def __virtual__():
# only valid in proxy minions for now
return salt.utils.platform.is_proxy() and 'proxy' in __opts__
def _base_url():
'''
Return the proxy configured base url.
'''
base_url = "http://locahost:4400"
if 'proxy' in __opts__:
base_url = __opts__['proxy'].get('base_url', base_url)
return base_url
def _jobs():
'''
Return the currently configured jobs.
'''
response = salt.utils.http.query(
"{0}/scheduler/jobs".format(_base_url()),
decode_type='json',
decode=True,
)
jobs = {}
for job in response['dict']:
jobs[job.pop('name')] = job
return jobs
def jobs():
'''
Return a list of the currently installed job names.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.jobs
'''
job_names = _jobs().keys()
job_names.sort()
return {'jobs': job_names}
def has_job(name):
'''
Return whether the given job is currently configured.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.has_job my-job
'''
return name in _jobs()
def job(name):
'''
Return the current server configuration for the specified job.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.job my-job
'''
jobs = _jobs()
if name in jobs:
return {'job': jobs[name]}
return None
def update_job(name, config):
'''
Update the specified job with the given configuration.
CLI Example:
.. code-block:: bash
salt chronos-minion-id chronos.update_job my-job '<config yaml>'
'''
if 'name' not in config:
config['name'] = name
data = salt.utils.json.dumps(config)
try:
response = salt.utils.http.query(
"{0}/scheduler/iso8601".format(_base_url()),
method='POST',
data=data,
header_dict={
'Content-Type': 'application/json',
},
)
log.debug('update response: %s', response)
return {'success': True}
except Exception as ex:
log.error('unable to update chronos job: %s', get_error_message(ex))
return {
'exception': {
'message': get_error_message(ex),
}
}
|
saltstack/salt
|
salt/grains/iscsi.py
|
iscsi_iqn
|
python
|
def iscsi_iqn():
'''
Return iSCSI IQN
'''
grains = {}
grains['iscsi_iqn'] = False
if salt.utils.platform.is_linux():
grains['iscsi_iqn'] = _linux_iqn()
elif salt.utils.platform.is_windows():
grains['iscsi_iqn'] = _windows_iqn()
elif salt.utils.platform.is_aix():
grains['iscsi_iqn'] = _aix_iqn()
return grains
|
Return iSCSI IQN
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/grains/iscsi.py#L38-L50
|
[
"def _linux_iqn():\n '''\n Return iSCSI IQN from a Linux host.\n '''\n ret = []\n\n initiator = '/etc/iscsi/initiatorname.iscsi'\n try:\n with salt.utils.files.fopen(initiator, 'r') as _iscsi:\n for line in _iscsi:\n line = line.strip()\n if line.startswith('InitiatorName='):\n ret.append(line.split('=', 1)[1])\n except IOError as ex:\n if ex.errno != errno.ENOENT:\n log.debug(\"Error while accessing '%s': %s\", initiator, ex)\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Grains for iSCSI Qualified Names (IQN).
.. versionadded:: 2018.3.0
To enable these grains set `iscsi_grains: True`.
.. code-block:: yaml
iscsi_grains: True
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import errno
import logging
# Import Salt libs
import salt.modules.cmdmod
import salt.utils.files
import salt.utils.path
import salt.utils.platform
__virtualname__ = 'iscsi'
# Get logging started
log = logging.getLogger(__name__)
def __virtual__():
if __opts__.get('iscsi_grains', False) is False:
return False
else:
return __virtualname__
def _linux_iqn():
'''
Return iSCSI IQN from a Linux host.
'''
ret = []
initiator = '/etc/iscsi/initiatorname.iscsi'
try:
with salt.utils.files.fopen(initiator, 'r') as _iscsi:
for line in _iscsi:
line = line.strip()
if line.startswith('InitiatorName='):
ret.append(line.split('=', 1)[1])
except IOError as ex:
if ex.errno != errno.ENOENT:
log.debug("Error while accessing '%s': %s", initiator, ex)
return ret
def _aix_iqn():
'''
Return iSCSI IQN from an AIX host.
'''
ret = []
aix_cmd = 'lsattr -E -l iscsi0 | grep initiator_name'
aix_ret = salt.modules.cmdmod.run(aix_cmd)
if aix_ret[0].isalpha():
try:
ret.append(aix_ret.split()[1].rstrip())
except IndexError:
pass
return ret
def _windows_iqn():
'''
Return iSCSI IQN from a Windows host.
'''
ret = []
wmic = salt.utils.path.which('wmic')
if not wmic:
return ret
namespace = r'\\root\WMI'
path = 'MSiSCSIInitiator_MethodClass'
get = 'iSCSINodeName'
cmd_ret = salt.modules.cmdmod.run_all(
'{0} /namespace:{1} path {2} get {3} /format:table'
''.format(wmic, namespace, path, get))
for line in cmd_ret['stdout'].splitlines():
if line.startswith('iqn.'):
line = line.rstrip()
ret.append(line.rstrip())
return ret
|
saltstack/salt
|
salt/grains/iscsi.py
|
_linux_iqn
|
python
|
def _linux_iqn():
'''
Return iSCSI IQN from a Linux host.
'''
ret = []
initiator = '/etc/iscsi/initiatorname.iscsi'
try:
with salt.utils.files.fopen(initiator, 'r') as _iscsi:
for line in _iscsi:
line = line.strip()
if line.startswith('InitiatorName='):
ret.append(line.split('=', 1)[1])
except IOError as ex:
if ex.errno != errno.ENOENT:
log.debug("Error while accessing '%s': %s", initiator, ex)
return ret
|
Return iSCSI IQN from a Linux host.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/grains/iscsi.py#L53-L70
|
[
"def fopen(*args, **kwargs):\n '''\n Wrapper around open() built-in to set CLOEXEC on the fd.\n\n This flag specifies that the file descriptor should be closed when an exec\n function is invoked;\n\n When a file descriptor is allocated (as with open or dup), this bit is\n initially cleared on the new file descriptor, meaning that descriptor will\n survive into the new program after exec.\n\n NB! We still have small race condition between open and fcntl.\n '''\n if six.PY3:\n try:\n # Don't permit stdin/stdout/stderr to be opened. The boolean False\n # and True are treated by Python 3's open() as file descriptors 0\n # and 1, respectively.\n if args[0] in (0, 1, 2):\n raise TypeError(\n '{0} is not a permitted file descriptor'.format(args[0])\n )\n except IndexError:\n pass\n binary = None\n # ensure 'binary' mode is always used on Windows in Python 2\n if ((six.PY2 and salt.utils.platform.is_windows() and 'binary' not in kwargs) or\n kwargs.pop('binary', False)):\n if len(args) > 1:\n args = list(args)\n if 'b' not in args[1]:\n args[1] = args[1].replace('t', 'b')\n if 'b' not in args[1]:\n args[1] += 'b'\n elif kwargs.get('mode'):\n if 'b' not in kwargs['mode']:\n kwargs['mode'] = kwargs['mode'].replace('t', 'b')\n if 'b' not in kwargs['mode']:\n kwargs['mode'] += 'b'\n else:\n # the default is to read\n kwargs['mode'] = 'rb'\n elif six.PY3 and 'encoding' not in kwargs:\n # In Python 3, if text mode is used and the encoding\n # is not specified, set the encoding to 'utf-8'.\n binary = False\n if len(args) > 1:\n args = list(args)\n if 'b' in args[1]:\n binary = True\n if kwargs.get('mode', None):\n if 'b' in kwargs['mode']:\n binary = True\n if not binary:\n kwargs['encoding'] = __salt_system_encoding__\n\n if six.PY3 and not binary and not kwargs.get('newline', None):\n kwargs['newline'] = ''\n\n f_handle = open(*args, **kwargs) # pylint: disable=resource-leakage\n\n if is_fcntl_available():\n # modify the file descriptor on systems with fcntl\n # unix and unix-like systems only\n try:\n FD_CLOEXEC = fcntl.FD_CLOEXEC # pylint: disable=C0103\n except AttributeError:\n FD_CLOEXEC = 1 # pylint: disable=C0103\n old_flags = fcntl.fcntl(f_handle.fileno(), fcntl.F_GETFD)\n fcntl.fcntl(f_handle.fileno(), fcntl.F_SETFD, old_flags | FD_CLOEXEC)\n\n return f_handle\n"
] |
# -*- coding: utf-8 -*-
'''
Grains for iSCSI Qualified Names (IQN).
.. versionadded:: 2018.3.0
To enable these grains set `iscsi_grains: True`.
.. code-block:: yaml
iscsi_grains: True
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import errno
import logging
# Import Salt libs
import salt.modules.cmdmod
import salt.utils.files
import salt.utils.path
import salt.utils.platform
__virtualname__ = 'iscsi'
# Get logging started
log = logging.getLogger(__name__)
def __virtual__():
if __opts__.get('iscsi_grains', False) is False:
return False
else:
return __virtualname__
def iscsi_iqn():
'''
Return iSCSI IQN
'''
grains = {}
grains['iscsi_iqn'] = False
if salt.utils.platform.is_linux():
grains['iscsi_iqn'] = _linux_iqn()
elif salt.utils.platform.is_windows():
grains['iscsi_iqn'] = _windows_iqn()
elif salt.utils.platform.is_aix():
grains['iscsi_iqn'] = _aix_iqn()
return grains
def _aix_iqn():
'''
Return iSCSI IQN from an AIX host.
'''
ret = []
aix_cmd = 'lsattr -E -l iscsi0 | grep initiator_name'
aix_ret = salt.modules.cmdmod.run(aix_cmd)
if aix_ret[0].isalpha():
try:
ret.append(aix_ret.split()[1].rstrip())
except IndexError:
pass
return ret
def _windows_iqn():
'''
Return iSCSI IQN from a Windows host.
'''
ret = []
wmic = salt.utils.path.which('wmic')
if not wmic:
return ret
namespace = r'\\root\WMI'
path = 'MSiSCSIInitiator_MethodClass'
get = 'iSCSINodeName'
cmd_ret = salt.modules.cmdmod.run_all(
'{0} /namespace:{1} path {2} get {3} /format:table'
''.format(wmic, namespace, path, get))
for line in cmd_ret['stdout'].splitlines():
if line.startswith('iqn.'):
line = line.rstrip()
ret.append(line.rstrip())
return ret
|
saltstack/salt
|
salt/grains/iscsi.py
|
_aix_iqn
|
python
|
def _aix_iqn():
'''
Return iSCSI IQN from an AIX host.
'''
ret = []
aix_cmd = 'lsattr -E -l iscsi0 | grep initiator_name'
aix_ret = salt.modules.cmdmod.run(aix_cmd)
if aix_ret[0].isalpha():
try:
ret.append(aix_ret.split()[1].rstrip())
except IndexError:
pass
return ret
|
Return iSCSI IQN from an AIX host.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/grains/iscsi.py#L73-L87
|
[
"def run(cmd,\n cwd=None,\n stdin=None,\n runas=None,\n group=None,\n shell=DEFAULT_SHELL,\n python_shell=None,\n env=None,\n clean_env=False,\n template=None,\n rstrip=True,\n umask=None,\n output_encoding=None,\n output_loglevel='debug',\n log_callback=None,\n hide_output=False,\n timeout=None,\n reset_system_locale=True,\n ignore_retcode=False,\n saltenv='base',\n use_vt=False,\n bg=False,\n password=None,\n encoded_cmd=False,\n raise_err=False,\n prepend_path=None,\n success_retcodes=None,\n success_stdout=None,\n success_stderr=None,\n **kwargs):\n r'''\n Execute the passed command and return the output as a string\n\n :param str cmd: The command to run. ex: ``ls -lart /home``\n\n :param str cwd: The directory from which to execute the command. Defaults\n to the home directory of the user specified by ``runas`` (or the user\n under which Salt is running if ``runas`` is not specified).\n\n :param str stdin: A string of standard input can be specified for the\n command to be run using the ``stdin`` parameter. This can be useful in\n cases where sensitive information must be read from standard input.\n\n :param str runas: Specify an alternate user to run the command. The default\n behavior is to run as the user under which Salt is running.\n\n .. warning::\n\n For versions 2018.3.3 and above on macosx while using runas,\n to pass special characters to the command you need to escape\n the characters on the shell.\n\n Example:\n\n .. code-block:: bash\n\n cmd.run 'echo '\\''h=\\\"baz\\\"'\\''' runas=macuser\n\n :param str group: Group to run command as. Not currently supported\n on Windows.\n\n :param str password: Windows only. Required when specifying ``runas``. This\n parameter will be ignored on non-Windows platforms.\n\n .. versionadded:: 2016.3.0\n\n :param str shell: Specify an alternate shell. Defaults to the system's\n default shell.\n\n :param bool python_shell: If ``False``, let python handle the positional\n arguments. Set to ``True`` to use shell features, such as pipes or\n redirection.\n\n :param bool bg: If ``True``, run command in background and do not await or\n deliver it's results\n\n .. versionadded:: 2016.3.0\n\n :param dict env: Environment variables to be set prior to execution.\n\n .. note::\n When passing environment variables on the CLI, they should be\n passed as the string representation of a dictionary.\n\n .. code-block:: bash\n\n salt myminion cmd.run 'some command' env='{\"FOO\": \"bar\"}'\n\n :param bool clean_env: Attempt to clean out all other shell environment\n variables and set only those provided in the 'env' argument to this\n function.\n\n :param str prepend_path: $PATH segment to prepend (trailing ':' not\n necessary) to $PATH\n\n .. versionadded:: 2018.3.0\n\n :param str template: If this setting is applied then the named templating\n engine will be used to render the downloaded file. Currently jinja,\n mako, and wempy are supported.\n\n :param bool rstrip: Strip all whitespace off the end of output before it is\n returned.\n\n :param str umask: The umask (in octal) to use when running the command.\n\n :param str output_encoding: Control the encoding used to decode the\n command's output.\n\n .. note::\n This should not need to be used in most cases. By default, Salt\n will try to use the encoding detected from the system locale, and\n will fall back to UTF-8 if this fails. This should only need to be\n used in cases where the output of the command is encoded in\n something other than the system locale or UTF-8.\n\n To see the encoding Salt has detected from the system locale, check\n the `locale` line in the output of :py:func:`test.versions_report\n <salt.modules.test.versions_report>`.\n\n .. versionadded:: 2018.3.0\n\n :param str output_loglevel: Control the loglevel at which the output from\n the command is logged to the minion log.\n\n .. note::\n The command being run will still be logged at the ``debug``\n loglevel regardless, unless ``quiet`` is used for this value.\n\n :param bool ignore_retcode: If the exit code of the command is nonzero,\n this is treated as an error condition, and the output from the command\n will be logged to the minion log. However, there are some cases where\n programs use the return code for signaling and a nonzero exit code\n doesn't necessarily mean failure. Pass this argument as ``True`` to\n skip logging the output if the command has a nonzero exit code.\n\n :param bool hide_output: If ``True``, suppress stdout and stderr in the\n return data.\n\n .. note::\n This is separate from ``output_loglevel``, which only handles how\n Salt logs to the minion log.\n\n .. versionadded:: 2018.3.0\n\n :param int timeout: A timeout in seconds for the executed process to return.\n\n :param bool use_vt: Use VT utils (saltstack) to stream the command output\n more interactively to the console and the logs. This is experimental.\n\n :param bool encoded_cmd: Specify if the supplied command is encoded.\n Only applies to shell 'powershell'.\n\n :param bool raise_err: If ``True`` and the command has a nonzero exit code,\n a CommandExecutionError exception will be raised.\n\n .. warning::\n This function does not process commands through a shell\n unless the python_shell flag is set to True. This means that any\n shell-specific functionality such as 'echo' or the use of pipes,\n redirection or &&, should either be migrated to cmd.shell or\n have the python_shell=True flag set here.\n\n The use of python_shell=True means that the shell will accept _any_ input\n including potentially malicious commands such as 'good_command;rm -rf /'.\n Be absolutely certain that you have sanitized your input prior to using\n python_shell=True\n\n :param list success_retcodes: This parameter will be allow a list of\n non-zero return codes that should be considered a success. If the\n return code returned from the run matches any in the provided list,\n the return code will be overridden with zero.\n\n .. versionadded:: 2019.2.0\n\n :param list success_stdout: This parameter will be allow a list of\n strings that when found in standard out should be considered a success.\n If stdout returned from the run matches any in the provided list,\n the return code will be overridden with zero.\n\n .. versionadded:: Neon\n\n :param list success_stderr: This parameter will be allow a list of\n strings that when found in standard error should be considered a success.\n If stderr returned from the run matches any in the provided list,\n the return code will be overridden with zero.\n\n .. versionadded:: Neon\n\n :param bool stdin_raw_newlines: False\n If ``True``, Salt will not automatically convert the characters ``\\\\n``\n present in the ``stdin`` value to newlines.\n\n .. versionadded:: 2019.2.0\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' cmd.run \"ls -l | awk '/foo/{print \\\\$2}'\"\n\n The template arg can be set to 'jinja' or another supported template\n engine to render the command arguments before execution.\n For example:\n\n .. code-block:: bash\n\n salt '*' cmd.run template=jinja \"ls -l /tmp/{{grains.id}} | awk '/foo/{print \\\\$2}'\"\n\n Specify an alternate shell with the shell parameter:\n\n .. code-block:: bash\n\n salt '*' cmd.run \"Get-ChildItem C:\\\\ \" shell='powershell'\n\n A string of standard input can be specified for the command to be run using\n the ``stdin`` parameter. This can be useful in cases where sensitive\n information must be read from standard input.\n\n .. code-block:: bash\n\n salt '*' cmd.run \"grep f\" stdin='one\\\\ntwo\\\\nthree\\\\nfour\\\\nfive\\\\n'\n\n If an equal sign (``=``) appears in an argument to a Salt command it is\n interpreted as a keyword argument in the format ``key=val``. That\n processing can be bypassed in order to pass an equal sign through to the\n remote shell command by manually specifying the kwarg:\n\n .. code-block:: bash\n\n salt '*' cmd.run cmd='sed -e s/=/:/g'\n '''\n python_shell = _python_shell_default(python_shell,\n kwargs.get('__pub_jid', ''))\n ret = _run(cmd,\n runas=runas,\n group=group,\n shell=shell,\n python_shell=python_shell,\n cwd=cwd,\n stdin=stdin,\n stderr=subprocess.STDOUT,\n env=env,\n clean_env=clean_env,\n prepend_path=prepend_path,\n template=template,\n rstrip=rstrip,\n umask=umask,\n output_encoding=output_encoding,\n output_loglevel=output_loglevel,\n log_callback=log_callback,\n timeout=timeout,\n reset_system_locale=reset_system_locale,\n ignore_retcode=ignore_retcode,\n saltenv=saltenv,\n use_vt=use_vt,\n bg=bg,\n password=password,\n encoded_cmd=encoded_cmd,\n success_retcodes=success_retcodes,\n success_stdout=success_stdout,\n success_stderr=success_stderr,\n **kwargs)\n\n log_callback = _check_cb(log_callback)\n\n lvl = _check_loglevel(output_loglevel)\n if lvl is not None:\n if not ignore_retcode and ret['retcode'] != 0:\n if lvl < LOG_LEVELS['error']:\n lvl = LOG_LEVELS['error']\n msg = (\n 'Command \\'{0}\\' failed with return code: {1}'.format(\n cmd,\n ret['retcode']\n )\n )\n log.error(log_callback(msg))\n if raise_err:\n raise CommandExecutionError(\n log_callback(ret['stdout'] if not hide_output else '')\n )\n log.log(lvl, 'output: %s', log_callback(ret['stdout']))\n return ret['stdout'] if not hide_output else ''\n"
] |
# -*- coding: utf-8 -*-
'''
Grains for iSCSI Qualified Names (IQN).
.. versionadded:: 2018.3.0
To enable these grains set `iscsi_grains: True`.
.. code-block:: yaml
iscsi_grains: True
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import errno
import logging
# Import Salt libs
import salt.modules.cmdmod
import salt.utils.files
import salt.utils.path
import salt.utils.platform
__virtualname__ = 'iscsi'
# Get logging started
log = logging.getLogger(__name__)
def __virtual__():
if __opts__.get('iscsi_grains', False) is False:
return False
else:
return __virtualname__
def iscsi_iqn():
'''
Return iSCSI IQN
'''
grains = {}
grains['iscsi_iqn'] = False
if salt.utils.platform.is_linux():
grains['iscsi_iqn'] = _linux_iqn()
elif salt.utils.platform.is_windows():
grains['iscsi_iqn'] = _windows_iqn()
elif salt.utils.platform.is_aix():
grains['iscsi_iqn'] = _aix_iqn()
return grains
def _linux_iqn():
'''
Return iSCSI IQN from a Linux host.
'''
ret = []
initiator = '/etc/iscsi/initiatorname.iscsi'
try:
with salt.utils.files.fopen(initiator, 'r') as _iscsi:
for line in _iscsi:
line = line.strip()
if line.startswith('InitiatorName='):
ret.append(line.split('=', 1)[1])
except IOError as ex:
if ex.errno != errno.ENOENT:
log.debug("Error while accessing '%s': %s", initiator, ex)
return ret
def _windows_iqn():
'''
Return iSCSI IQN from a Windows host.
'''
ret = []
wmic = salt.utils.path.which('wmic')
if not wmic:
return ret
namespace = r'\\root\WMI'
path = 'MSiSCSIInitiator_MethodClass'
get = 'iSCSINodeName'
cmd_ret = salt.modules.cmdmod.run_all(
'{0} /namespace:{1} path {2} get {3} /format:table'
''.format(wmic, namespace, path, get))
for line in cmd_ret['stdout'].splitlines():
if line.startswith('iqn.'):
line = line.rstrip()
ret.append(line.rstrip())
return ret
|
saltstack/salt
|
salt/grains/iscsi.py
|
_windows_iqn
|
python
|
def _windows_iqn():
'''
Return iSCSI IQN from a Windows host.
'''
ret = []
wmic = salt.utils.path.which('wmic')
if not wmic:
return ret
namespace = r'\\root\WMI'
path = 'MSiSCSIInitiator_MethodClass'
get = 'iSCSINodeName'
cmd_ret = salt.modules.cmdmod.run_all(
'{0} /namespace:{1} path {2} get {3} /format:table'
''.format(wmic, namespace, path, get))
for line in cmd_ret['stdout'].splitlines():
if line.startswith('iqn.'):
line = line.rstrip()
ret.append(line.rstrip())
return ret
|
Return iSCSI IQN from a Windows host.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/grains/iscsi.py#L90-L114
|
[
"def run_all(cmd,\n cwd=None,\n stdin=None,\n runas=None,\n group=None,\n shell=DEFAULT_SHELL,\n python_shell=None,\n env=None,\n clean_env=False,\n template=None,\n rstrip=True,\n umask=None,\n output_encoding=None,\n output_loglevel='debug',\n log_callback=None,\n hide_output=False,\n timeout=None,\n reset_system_locale=True,\n ignore_retcode=False,\n saltenv='base',\n use_vt=False,\n redirect_stderr=False,\n password=None,\n encoded_cmd=False,\n prepend_path=None,\n success_retcodes=None,\n success_stdout=None,\n success_stderr=None,\n **kwargs):\n '''\n Execute the passed command and return a dict of return data\n\n :param str cmd: The command to run. ex: ``ls -lart /home``\n\n :param str cwd: The directory from which to execute the command. Defaults\n to the home directory of the user specified by ``runas`` (or the user\n under which Salt is running if ``runas`` is not specified).\n\n :param str stdin: A string of standard input can be specified for the\n command to be run using the ``stdin`` parameter. This can be useful in\n cases where sensitive information must be read from standard input.\n\n :param str runas: Specify an alternate user to run the command. The default\n behavior is to run as the user under which Salt is running. If running\n on a Windows minion you must also use the ``password`` argument, and\n the target user account must be in the Administrators group.\n\n .. warning::\n\n For versions 2018.3.3 and above on macosx while using runas,\n to pass special characters to the command you need to escape\n the characters on the shell.\n\n Example:\n\n .. code-block:: bash\n\n cmd.run_all 'echo '\\\\''h=\\\\\"baz\\\\\"'\\\\\\''' runas=macuser\n\n :param str password: Windows only. Required when specifying ``runas``. This\n parameter will be ignored on non-Windows platforms.\n\n .. versionadded:: 2016.3.0\n\n :param str group: Group to run command as. Not currently supported\n on Windows.\n\n :param str shell: Specify an alternate shell. Defaults to the system's\n default shell.\n\n :param bool python_shell: If False, let python handle the positional\n arguments. Set to True to use shell features, such as pipes or\n redirection.\n\n :param dict env: Environment variables to be set prior to execution.\n\n .. note::\n When passing environment variables on the CLI, they should be\n passed as the string representation of a dictionary.\n\n .. code-block:: bash\n\n salt myminion cmd.run_all 'some command' env='{\"FOO\": \"bar\"}'\n\n :param bool clean_env: Attempt to clean out all other shell environment\n variables and set only those provided in the 'env' argument to this\n function.\n\n :param str prepend_path: $PATH segment to prepend (trailing ':' not\n necessary) to $PATH\n\n .. versionadded:: 2018.3.0\n\n :param str template: If this setting is applied then the named templating\n engine will be used to render the downloaded file. Currently jinja,\n mako, and wempy are supported.\n\n :param bool rstrip: Strip all whitespace off the end of output before it is\n returned.\n\n :param str umask: The umask (in octal) to use when running the command.\n\n :param str output_encoding: Control the encoding used to decode the\n command's output.\n\n .. note::\n This should not need to be used in most cases. By default, Salt\n will try to use the encoding detected from the system locale, and\n will fall back to UTF-8 if this fails. This should only need to be\n used in cases where the output of the command is encoded in\n something other than the system locale or UTF-8.\n\n To see the encoding Salt has detected from the system locale, check\n the `locale` line in the output of :py:func:`test.versions_report\n <salt.modules.test.versions_report>`.\n\n .. versionadded:: 2018.3.0\n\n :param str output_loglevel: Control the loglevel at which the output from\n the command is logged to the minion log.\n\n .. note::\n The command being run will still be logged at the ``debug``\n loglevel regardless, unless ``quiet`` is used for this value.\n\n :param bool ignore_retcode: If the exit code of the command is nonzero,\n this is treated as an error condition, and the output from the command\n will be logged to the minion log. However, there are some cases where\n programs use the return code for signaling and a nonzero exit code\n doesn't necessarily mean failure. Pass this argument as ``True`` to\n skip logging the output if the command has a nonzero exit code.\n\n :param bool hide_output: If ``True``, suppress stdout and stderr in the\n return data.\n\n .. note::\n This is separate from ``output_loglevel``, which only handles how\n Salt logs to the minion log.\n\n .. versionadded:: 2018.3.0\n\n :param int timeout: A timeout in seconds for the executed process to\n return.\n\n :param bool use_vt: Use VT utils (saltstack) to stream the command output\n more interactively to the console and the logs. This is experimental.\n\n :param bool encoded_cmd: Specify if the supplied command is encoded.\n Only applies to shell 'powershell'.\n\n .. versionadded:: 2018.3.0\n\n :param bool redirect_stderr: If set to ``True``, then stderr will be\n redirected to stdout. This is helpful for cases where obtaining both\n the retcode and output is desired, but it is not desired to have the\n output separated into both stdout and stderr.\n\n .. versionadded:: 2015.8.2\n\n :param str password: Windows only. Required when specifying ``runas``. This\n parameter will be ignored on non-Windows platforms.\n\n .. versionadded:: 2016.3.0\n\n :param bool bg: If ``True``, run command in background and do not await or\n deliver its results\n\n .. versionadded:: 2016.3.6\n\n :param list success_retcodes: This parameter will be allow a list of\n non-zero return codes that should be considered a success. If the\n return code returned from the run matches any in the provided list,\n the return code will be overridden with zero.\n\n .. versionadded:: 2019.2.0\n\n :param list success_stdout: This parameter will be allow a list of\n strings that when found in standard out should be considered a success.\n If stdout returned from the run matches any in the provided list,\n the return code will be overridden with zero.\n\n .. versionadded:: Neon\n\n :param list success_stderr: This parameter will be allow a list of\n strings that when found in standard error should be considered a success.\n If stderr returned from the run matches any in the provided list,\n the return code will be overridden with zero.\n\n .. versionadded:: Neon\n\n :param bool stdin_raw_newlines: False\n If ``True``, Salt will not automatically convert the characters ``\\\\n``\n present in the ``stdin`` value to newlines.\n\n .. versionadded:: 2019.2.0\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' cmd.run_all \"ls -l | awk '/foo/{print \\\\$2}'\"\n\n The template arg can be set to 'jinja' or another supported template\n engine to render the command arguments before execution.\n For example:\n\n .. code-block:: bash\n\n salt '*' cmd.run_all template=jinja \"ls -l /tmp/{{grains.id}} | awk '/foo/{print \\\\$2}'\"\n\n A string of standard input can be specified for the command to be run using\n the ``stdin`` parameter. This can be useful in cases where sensitive\n information must be read from standard input.\n\n .. code-block:: bash\n\n salt '*' cmd.run_all \"grep f\" stdin='one\\\\ntwo\\\\nthree\\\\nfour\\\\nfive\\\\n'\n '''\n python_shell = _python_shell_default(python_shell,\n kwargs.get('__pub_jid', ''))\n stderr = subprocess.STDOUT if redirect_stderr else subprocess.PIPE\n ret = _run(cmd,\n runas=runas,\n group=group,\n cwd=cwd,\n stdin=stdin,\n stderr=stderr,\n shell=shell,\n python_shell=python_shell,\n env=env,\n clean_env=clean_env,\n prepend_path=prepend_path,\n template=template,\n rstrip=rstrip,\n umask=umask,\n output_encoding=output_encoding,\n output_loglevel=output_loglevel,\n log_callback=log_callback,\n timeout=timeout,\n reset_system_locale=reset_system_locale,\n ignore_retcode=ignore_retcode,\n saltenv=saltenv,\n use_vt=use_vt,\n password=password,\n encoded_cmd=encoded_cmd,\n success_retcodes=success_retcodes,\n success_stdout=success_stdout,\n success_stderr=success_stderr,\n **kwargs)\n\n if hide_output:\n ret['stdout'] = ret['stderr'] = ''\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Grains for iSCSI Qualified Names (IQN).
.. versionadded:: 2018.3.0
To enable these grains set `iscsi_grains: True`.
.. code-block:: yaml
iscsi_grains: True
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import errno
import logging
# Import Salt libs
import salt.modules.cmdmod
import salt.utils.files
import salt.utils.path
import salt.utils.platform
__virtualname__ = 'iscsi'
# Get logging started
log = logging.getLogger(__name__)
def __virtual__():
if __opts__.get('iscsi_grains', False) is False:
return False
else:
return __virtualname__
def iscsi_iqn():
'''
Return iSCSI IQN
'''
grains = {}
grains['iscsi_iqn'] = False
if salt.utils.platform.is_linux():
grains['iscsi_iqn'] = _linux_iqn()
elif salt.utils.platform.is_windows():
grains['iscsi_iqn'] = _windows_iqn()
elif salt.utils.platform.is_aix():
grains['iscsi_iqn'] = _aix_iqn()
return grains
def _linux_iqn():
'''
Return iSCSI IQN from a Linux host.
'''
ret = []
initiator = '/etc/iscsi/initiatorname.iscsi'
try:
with salt.utils.files.fopen(initiator, 'r') as _iscsi:
for line in _iscsi:
line = line.strip()
if line.startswith('InitiatorName='):
ret.append(line.split('=', 1)[1])
except IOError as ex:
if ex.errno != errno.ENOENT:
log.debug("Error while accessing '%s': %s", initiator, ex)
return ret
def _aix_iqn():
'''
Return iSCSI IQN from an AIX host.
'''
ret = []
aix_cmd = 'lsattr -E -l iscsi0 | grep initiator_name'
aix_ret = salt.modules.cmdmod.run(aix_cmd)
if aix_ret[0].isalpha():
try:
ret.append(aix_ret.split()[1].rstrip())
except IndexError:
pass
return ret
|
saltstack/salt
|
salt/modules/ret.py
|
get_jid
|
python
|
def get_jid(returner, jid):
'''
Return the information for a specified job id
CLI Example:
.. code-block:: bash
salt '*' ret.get_jid redis 20421104181954700505
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jid'.format(returner)](jid)
|
Return the information for a specified job id
CLI Example:
.. code-block:: bash
salt '*' ret.get_jid redis 20421104181954700505
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/ret.py#L11-L22
| null |
# -*- coding: utf-8 -*-
'''
Module to integrate with the returner system and retrieve data sent to a salt returner
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import salt libs
import salt.loader
def get_fun(returner, fun):
'''
Return info about last time fun was called on each minion
CLI Example:
.. code-block:: bash
salt '*' ret.get_fun mysql network.interfaces
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_fun'.format(returner)](fun)
def get_jids(returner):
'''
Return a list of all job ids
CLI Example:
.. code-block:: bash
salt '*' ret.get_jids mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jids'.format(returner)]()
def get_minions(returner):
'''
Return a list of all minions
CLI Example:
.. code-block:: bash
salt '*' ret.get_minions mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_minions'.format(returner)]()
|
saltstack/salt
|
salt/modules/ret.py
|
get_fun
|
python
|
def get_fun(returner, fun):
'''
Return info about last time fun was called on each minion
CLI Example:
.. code-block:: bash
salt '*' ret.get_fun mysql network.interfaces
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_fun'.format(returner)](fun)
|
Return info about last time fun was called on each minion
CLI Example:
.. code-block:: bash
salt '*' ret.get_fun mysql network.interfaces
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/ret.py#L25-L36
| null |
# -*- coding: utf-8 -*-
'''
Module to integrate with the returner system and retrieve data sent to a salt returner
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import salt libs
import salt.loader
def get_jid(returner, jid):
'''
Return the information for a specified job id
CLI Example:
.. code-block:: bash
salt '*' ret.get_jid redis 20421104181954700505
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jid'.format(returner)](jid)
def get_jids(returner):
'''
Return a list of all job ids
CLI Example:
.. code-block:: bash
salt '*' ret.get_jids mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jids'.format(returner)]()
def get_minions(returner):
'''
Return a list of all minions
CLI Example:
.. code-block:: bash
salt '*' ret.get_minions mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_minions'.format(returner)]()
|
saltstack/salt
|
salt/modules/ret.py
|
get_jids
|
python
|
def get_jids(returner):
'''
Return a list of all job ids
CLI Example:
.. code-block:: bash
salt '*' ret.get_jids mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jids'.format(returner)]()
|
Return a list of all job ids
CLI Example:
.. code-block:: bash
salt '*' ret.get_jids mysql
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/ret.py#L39-L50
| null |
# -*- coding: utf-8 -*-
'''
Module to integrate with the returner system and retrieve data sent to a salt returner
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import salt libs
import salt.loader
def get_jid(returner, jid):
'''
Return the information for a specified job id
CLI Example:
.. code-block:: bash
salt '*' ret.get_jid redis 20421104181954700505
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jid'.format(returner)](jid)
def get_fun(returner, fun):
'''
Return info about last time fun was called on each minion
CLI Example:
.. code-block:: bash
salt '*' ret.get_fun mysql network.interfaces
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_fun'.format(returner)](fun)
def get_minions(returner):
'''
Return a list of all minions
CLI Example:
.. code-block:: bash
salt '*' ret.get_minions mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_minions'.format(returner)]()
|
saltstack/salt
|
salt/modules/ret.py
|
get_minions
|
python
|
def get_minions(returner):
'''
Return a list of all minions
CLI Example:
.. code-block:: bash
salt '*' ret.get_minions mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_minions'.format(returner)]()
|
Return a list of all minions
CLI Example:
.. code-block:: bash
salt '*' ret.get_minions mysql
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/ret.py#L53-L64
| null |
# -*- coding: utf-8 -*-
'''
Module to integrate with the returner system and retrieve data sent to a salt returner
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import salt libs
import salt.loader
def get_jid(returner, jid):
'''
Return the information for a specified job id
CLI Example:
.. code-block:: bash
salt '*' ret.get_jid redis 20421104181954700505
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jid'.format(returner)](jid)
def get_fun(returner, fun):
'''
Return info about last time fun was called on each minion
CLI Example:
.. code-block:: bash
salt '*' ret.get_fun mysql network.interfaces
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_fun'.format(returner)](fun)
def get_jids(returner):
'''
Return a list of all job ids
CLI Example:
.. code-block:: bash
salt '*' ret.get_jids mysql
'''
returners = salt.loader.returners(__opts__, __salt__)
return returners['{0}.get_jids'.format(returner)]()
|
saltstack/salt
|
salt/beacons/bonjour_announce.py
|
_enforce_txt_record_maxlen
|
python
|
def _enforce_txt_record_maxlen(key, value):
'''
Enforces the TXT record maximum length of 255 characters.
TXT record length includes key, value, and '='.
:param str key: Key of the TXT record
:param str value: Value of the TXT record
:rtype: str
:return: The value of the TXT record. It may be truncated if it exceeds
the maximum permitted length. In case of truncation, '...' is
appended to indicate that the entire value is not present.
'''
# Add 1 for '=' seperator between key and value
if len(key) + len(value) + 1 > 255:
# 255 - 3 ('...') - 1 ('=') = 251
return value[:251 - len(key)] + '...'
return value
|
Enforces the TXT record maximum length of 255 characters.
TXT record length includes key, value, and '='.
:param str key: Key of the TXT record
:param str value: Value of the TXT record
:rtype: str
:return: The value of the TXT record. It may be truncated if it exceeds
the maximum permitted length. In case of truncation, '...' is
appended to indicate that the entire value is not present.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/beacons/bonjour_announce.py#L73-L90
| null |
# -*- coding: utf-8 -*-
'''
Beacon to announce via Bonjour (zeroconf)
'''
# Import Python libs
from __future__ import absolute_import
import atexit
import logging
import select
import time
import salt.utils.stringutils
from salt.ext import six
from salt.ext.six.moves import map
# Import 3rd Party libs
try:
import pybonjour
HAS_PYBONJOUR = True
except ImportError:
HAS_PYBONJOUR = False
log = logging.getLogger(__name__)
__virtualname__ = 'bonjour_announce'
LAST_GRAINS = {}
SD_REF = None
def __virtual__():
if HAS_PYBONJOUR:
return __virtualname__
return False
def _close_sd_ref():
'''
Close the SD_REF object if it isn't NULL
For use with atexit.register
'''
global SD_REF
if SD_REF:
SD_REF.close()
SD_REF = None
def _register_callback(sdRef, flags, errorCode, name, regtype, domain): # pylint: disable=unused-argument
if errorCode != pybonjour.kDNSServiceErr_NoError:
log.error('Bonjour registration failed with error code %s', errorCode)
def validate(config):
'''
Validate the beacon configuration
'''
_config = {}
list(map(_config.update, config))
if not isinstance(config, list):
return False, ('Configuration for bonjour_announce '
'beacon must be a list.')
elif not all(x in _config for x in ('servicetype',
'port',
'txt')):
return False, ('Configuration for bonjour_announce beacon '
'must contain servicetype, port and txt items.')
return True, 'Valid beacon configuration.'
def beacon(config):
'''
Broadcast values via zeroconf
If the announced values are static, it is advised to set run_once: True
(do not poll) on the beacon configuration.
The following are required configuration settings:
- ``servicetype`` - The service type to announce
- ``port`` - The port of the service to announce
- ``txt`` - The TXT record of the service being announced as a dict. Grains
can be used to define TXT values using one of following two formats:
- ``grains.<grain_name>``
- ``grains.<grain_name>[i]`` where i is an integer representing the
index of the grain to use. If the grain is not a list, the index is
ignored.
The following are optional configuration settings:
- ``servicename`` - Set the name of the service. Will use the hostname from
the minion's ``host`` grain if this value is not set.
- ``reset_on_change`` - If ``True`` and there is a change in TXT records
detected, it will stop announcing the service and then restart announcing
the service. This interruption in service announcement may be desirable
if the client relies on changes in the browse records to update its cache
of TXT records. Defaults to ``False``.
- ``reset_wait`` - The number of seconds to wait after announcement stops
announcing and before it restarts announcing in the case where there is a
change in TXT records detected and ``reset_on_change`` is ``True``.
Defaults to ``0``.
- ``copy_grains`` - If ``True``, Salt will copy the grains passed into the
beacon when it backs them up to check for changes on the next iteration.
Normally, instead of copy, it would use straight value assignment. This
will allow detection of changes to grains where the grains are modified
in-place instead of completely replaced. In-place grains changes are not
currently done in the main Salt code but may be done due to a custom
plug-in. Defaults to ``False``.
Example Config
.. code-block:: yaml
beacons:
bonjour_announce:
- run_once: True
- servicetype: _demo._tcp
- port: 1234
- txt:
ProdName: grains.productname
SerialNo: grains.serialnumber
Comments: 'this is a test'
'''
ret = []
changes = {}
txt = {}
global LAST_GRAINS
global SD_REF
_config = {}
list(map(_config.update, config))
if 'servicename' in _config:
servicename = _config['servicename']
else:
servicename = __grains__['host']
# Check for hostname change
if LAST_GRAINS and LAST_GRAINS['host'] != servicename:
changes['servicename'] = servicename
if LAST_GRAINS and _config.get('reset_on_change', False):
# Check for IP address change in the case when we reset on change
if LAST_GRAINS.get('ipv4', []) != __grains__.get('ipv4', []):
changes['ipv4'] = __grains__.get('ipv4', [])
if LAST_GRAINS.get('ipv6', []) != __grains__.get('ipv6', []):
changes['ipv6'] = __grains__.get('ipv6', [])
for item in _config['txt']:
changes_key = 'txt.' + salt.utils.stringutils.to_unicode(item)
if _config['txt'][item].startswith('grains.'):
grain = _config['txt'][item][7:]
grain_index = None
square_bracket = grain.find('[')
if square_bracket != -1 and grain[-1] == ']':
grain_index = int(grain[square_bracket+1:-1])
grain = grain[:square_bracket]
grain_value = __grains__.get(grain, '')
if isinstance(grain_value, list):
if grain_index is not None:
grain_value = grain_value[grain_index]
else:
grain_value = ','.join(grain_value)
txt[item] = _enforce_txt_record_maxlen(item, grain_value)
if LAST_GRAINS and (LAST_GRAINS.get(grain, '') != __grains__.get(grain, '')):
changes[changes_key] = txt[item]
else:
txt[item] = _enforce_txt_record_maxlen(item, _config['txt'][item])
if not LAST_GRAINS:
changes[changes_key] = txt[item]
if changes:
txt_record = pybonjour.TXTRecord(items=txt)
if not LAST_GRAINS:
changes['servicename'] = servicename
changes['servicetype'] = _config['servicetype']
changes['port'] = _config['port']
changes['ipv4'] = __grains__.get('ipv4', [])
changes['ipv6'] = __grains__.get('ipv6', [])
SD_REF = pybonjour.DNSServiceRegister(
name=servicename,
regtype=_config['servicetype'],
port=_config['port'],
txtRecord=txt_record,
callBack=_register_callback)
atexit.register(_close_sd_ref)
ready = select.select([SD_REF], [], [])
if SD_REF in ready[0]:
pybonjour.DNSServiceProcessResult(SD_REF)
elif _config.get('reset_on_change', False) or 'servicename' in changes:
# A change in 'servicename' requires a reset because we can only
# directly update TXT records
SD_REF.close()
SD_REF = None
reset_wait = _config.get('reset_wait', 0)
if reset_wait > 0:
time.sleep(reset_wait)
SD_REF = pybonjour.DNSServiceRegister(
name=servicename,
regtype=_config['servicetype'],
port=_config['port'],
txtRecord=txt_record,
callBack=_register_callback)
ready = select.select([SD_REF], [], [])
if SD_REF in ready[0]:
pybonjour.DNSServiceProcessResult(SD_REF)
else:
txt_record_raw = six.text_type(txt_record).encode('utf-8')
pybonjour.DNSServiceUpdateRecord(
SD_REF,
RecordRef=None,
flags=0,
rdata=txt_record_raw)
ret.append({'tag': 'result', 'changes': changes})
if _config.get('copy_grains', False):
LAST_GRAINS = __grains__.copy()
else:
LAST_GRAINS = __grains__
return ret
|
saltstack/salt
|
salt/beacons/bonjour_announce.py
|
beacon
|
python
|
def beacon(config):
'''
Broadcast values via zeroconf
If the announced values are static, it is advised to set run_once: True
(do not poll) on the beacon configuration.
The following are required configuration settings:
- ``servicetype`` - The service type to announce
- ``port`` - The port of the service to announce
- ``txt`` - The TXT record of the service being announced as a dict. Grains
can be used to define TXT values using one of following two formats:
- ``grains.<grain_name>``
- ``grains.<grain_name>[i]`` where i is an integer representing the
index of the grain to use. If the grain is not a list, the index is
ignored.
The following are optional configuration settings:
- ``servicename`` - Set the name of the service. Will use the hostname from
the minion's ``host`` grain if this value is not set.
- ``reset_on_change`` - If ``True`` and there is a change in TXT records
detected, it will stop announcing the service and then restart announcing
the service. This interruption in service announcement may be desirable
if the client relies on changes in the browse records to update its cache
of TXT records. Defaults to ``False``.
- ``reset_wait`` - The number of seconds to wait after announcement stops
announcing and before it restarts announcing in the case where there is a
change in TXT records detected and ``reset_on_change`` is ``True``.
Defaults to ``0``.
- ``copy_grains`` - If ``True``, Salt will copy the grains passed into the
beacon when it backs them up to check for changes on the next iteration.
Normally, instead of copy, it would use straight value assignment. This
will allow detection of changes to grains where the grains are modified
in-place instead of completely replaced. In-place grains changes are not
currently done in the main Salt code but may be done due to a custom
plug-in. Defaults to ``False``.
Example Config
.. code-block:: yaml
beacons:
bonjour_announce:
- run_once: True
- servicetype: _demo._tcp
- port: 1234
- txt:
ProdName: grains.productname
SerialNo: grains.serialnumber
Comments: 'this is a test'
'''
ret = []
changes = {}
txt = {}
global LAST_GRAINS
global SD_REF
_config = {}
list(map(_config.update, config))
if 'servicename' in _config:
servicename = _config['servicename']
else:
servicename = __grains__['host']
# Check for hostname change
if LAST_GRAINS and LAST_GRAINS['host'] != servicename:
changes['servicename'] = servicename
if LAST_GRAINS and _config.get('reset_on_change', False):
# Check for IP address change in the case when we reset on change
if LAST_GRAINS.get('ipv4', []) != __grains__.get('ipv4', []):
changes['ipv4'] = __grains__.get('ipv4', [])
if LAST_GRAINS.get('ipv6', []) != __grains__.get('ipv6', []):
changes['ipv6'] = __grains__.get('ipv6', [])
for item in _config['txt']:
changes_key = 'txt.' + salt.utils.stringutils.to_unicode(item)
if _config['txt'][item].startswith('grains.'):
grain = _config['txt'][item][7:]
grain_index = None
square_bracket = grain.find('[')
if square_bracket != -1 and grain[-1] == ']':
grain_index = int(grain[square_bracket+1:-1])
grain = grain[:square_bracket]
grain_value = __grains__.get(grain, '')
if isinstance(grain_value, list):
if grain_index is not None:
grain_value = grain_value[grain_index]
else:
grain_value = ','.join(grain_value)
txt[item] = _enforce_txt_record_maxlen(item, grain_value)
if LAST_GRAINS and (LAST_GRAINS.get(grain, '') != __grains__.get(grain, '')):
changes[changes_key] = txt[item]
else:
txt[item] = _enforce_txt_record_maxlen(item, _config['txt'][item])
if not LAST_GRAINS:
changes[changes_key] = txt[item]
if changes:
txt_record = pybonjour.TXTRecord(items=txt)
if not LAST_GRAINS:
changes['servicename'] = servicename
changes['servicetype'] = _config['servicetype']
changes['port'] = _config['port']
changes['ipv4'] = __grains__.get('ipv4', [])
changes['ipv6'] = __grains__.get('ipv6', [])
SD_REF = pybonjour.DNSServiceRegister(
name=servicename,
regtype=_config['servicetype'],
port=_config['port'],
txtRecord=txt_record,
callBack=_register_callback)
atexit.register(_close_sd_ref)
ready = select.select([SD_REF], [], [])
if SD_REF in ready[0]:
pybonjour.DNSServiceProcessResult(SD_REF)
elif _config.get('reset_on_change', False) or 'servicename' in changes:
# A change in 'servicename' requires a reset because we can only
# directly update TXT records
SD_REF.close()
SD_REF = None
reset_wait = _config.get('reset_wait', 0)
if reset_wait > 0:
time.sleep(reset_wait)
SD_REF = pybonjour.DNSServiceRegister(
name=servicename,
regtype=_config['servicetype'],
port=_config['port'],
txtRecord=txt_record,
callBack=_register_callback)
ready = select.select([SD_REF], [], [])
if SD_REF in ready[0]:
pybonjour.DNSServiceProcessResult(SD_REF)
else:
txt_record_raw = six.text_type(txt_record).encode('utf-8')
pybonjour.DNSServiceUpdateRecord(
SD_REF,
RecordRef=None,
flags=0,
rdata=txt_record_raw)
ret.append({'tag': 'result', 'changes': changes})
if _config.get('copy_grains', False):
LAST_GRAINS = __grains__.copy()
else:
LAST_GRAINS = __grains__
return ret
|
Broadcast values via zeroconf
If the announced values are static, it is advised to set run_once: True
(do not poll) on the beacon configuration.
The following are required configuration settings:
- ``servicetype`` - The service type to announce
- ``port`` - The port of the service to announce
- ``txt`` - The TXT record of the service being announced as a dict. Grains
can be used to define TXT values using one of following two formats:
- ``grains.<grain_name>``
- ``grains.<grain_name>[i]`` where i is an integer representing the
index of the grain to use. If the grain is not a list, the index is
ignored.
The following are optional configuration settings:
- ``servicename`` - Set the name of the service. Will use the hostname from
the minion's ``host`` grain if this value is not set.
- ``reset_on_change`` - If ``True`` and there is a change in TXT records
detected, it will stop announcing the service and then restart announcing
the service. This interruption in service announcement may be desirable
if the client relies on changes in the browse records to update its cache
of TXT records. Defaults to ``False``.
- ``reset_wait`` - The number of seconds to wait after announcement stops
announcing and before it restarts announcing in the case where there is a
change in TXT records detected and ``reset_on_change`` is ``True``.
Defaults to ``0``.
- ``copy_grains`` - If ``True``, Salt will copy the grains passed into the
beacon when it backs them up to check for changes on the next iteration.
Normally, instead of copy, it would use straight value assignment. This
will allow detection of changes to grains where the grains are modified
in-place instead of completely replaced. In-place grains changes are not
currently done in the main Salt code but may be done due to a custom
plug-in. Defaults to ``False``.
Example Config
.. code-block:: yaml
beacons:
bonjour_announce:
- run_once: True
- servicetype: _demo._tcp
- port: 1234
- txt:
ProdName: grains.productname
SerialNo: grains.serialnumber
Comments: 'this is a test'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/beacons/bonjour_announce.py#L93-L247
| null |
# -*- coding: utf-8 -*-
'''
Beacon to announce via Bonjour (zeroconf)
'''
# Import Python libs
from __future__ import absolute_import
import atexit
import logging
import select
import time
import salt.utils.stringutils
from salt.ext import six
from salt.ext.six.moves import map
# Import 3rd Party libs
try:
import pybonjour
HAS_PYBONJOUR = True
except ImportError:
HAS_PYBONJOUR = False
log = logging.getLogger(__name__)
__virtualname__ = 'bonjour_announce'
LAST_GRAINS = {}
SD_REF = None
def __virtual__():
if HAS_PYBONJOUR:
return __virtualname__
return False
def _close_sd_ref():
'''
Close the SD_REF object if it isn't NULL
For use with atexit.register
'''
global SD_REF
if SD_REF:
SD_REF.close()
SD_REF = None
def _register_callback(sdRef, flags, errorCode, name, regtype, domain): # pylint: disable=unused-argument
if errorCode != pybonjour.kDNSServiceErr_NoError:
log.error('Bonjour registration failed with error code %s', errorCode)
def validate(config):
'''
Validate the beacon configuration
'''
_config = {}
list(map(_config.update, config))
if not isinstance(config, list):
return False, ('Configuration for bonjour_announce '
'beacon must be a list.')
elif not all(x in _config for x in ('servicetype',
'port',
'txt')):
return False, ('Configuration for bonjour_announce beacon '
'must contain servicetype, port and txt items.')
return True, 'Valid beacon configuration.'
def _enforce_txt_record_maxlen(key, value):
'''
Enforces the TXT record maximum length of 255 characters.
TXT record length includes key, value, and '='.
:param str key: Key of the TXT record
:param str value: Value of the TXT record
:rtype: str
:return: The value of the TXT record. It may be truncated if it exceeds
the maximum permitted length. In case of truncation, '...' is
appended to indicate that the entire value is not present.
'''
# Add 1 for '=' seperator between key and value
if len(key) + len(value) + 1 > 255:
# 255 - 3 ('...') - 1 ('=') = 251
return value[:251 - len(key)] + '...'
return value
|
saltstack/salt
|
salt/modules/sysmod.py
|
doc
|
python
|
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
|
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L38-L91
|
[
"def strip_rst(docs):\n '''\n Strip/replace reStructuredText directives in docstrings\n '''\n for func, docstring in six.iteritems(docs):\n log.debug('Stripping docstring for %s', func)\n if not docstring:\n continue\n docstring_new = docstring if six.PY3 else salt.utils.data.encode(docstring)\n for regex, repl in (\n (r' *.. code-block:: \\S+\\n{1,2}', ''),\n ('.. note::', 'Note:'),\n ('.. warning::', 'Warning:'),\n ('.. versionadded::', 'New in version'),\n ('.. versionchanged::', 'Changed in version')):\n if six.PY2:\n regex = salt.utils.data.encode(regex)\n repl = salt.utils.data.encode(repl)\n try:\n docstring_new = re.sub(regex, repl, docstring_new)\n except Exception:\n log.debug(\n 'Exception encountered while matching regex %r to '\n 'docstring for function %s', regex, func,\n exc_info=True\n )\n if six.PY2:\n docstring_new = salt.utils.data.decode(docstring_new)\n if docstring != docstring_new:\n docs[func] = docstring_new\n return docs\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
state_doc
|
python
|
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
|
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L94-L161
|
[
"def strip_rst(docs):\n '''\n Strip/replace reStructuredText directives in docstrings\n '''\n for func, docstring in six.iteritems(docs):\n log.debug('Stripping docstring for %s', func)\n if not docstring:\n continue\n docstring_new = docstring if six.PY3 else salt.utils.data.encode(docstring)\n for regex, repl in (\n (r' *.. code-block:: \\S+\\n{1,2}', ''),\n ('.. note::', 'Note:'),\n ('.. warning::', 'Warning:'),\n ('.. versionadded::', 'New in version'),\n ('.. versionchanged::', 'Changed in version')):\n if six.PY2:\n regex = salt.utils.data.encode(regex)\n repl = salt.utils.data.encode(repl)\n try:\n docstring_new = re.sub(regex, repl, docstring_new)\n except Exception:\n log.debug(\n 'Exception encountered while matching regex %r to '\n 'docstring for function %s', regex, func,\n exc_info=True\n )\n if six.PY2:\n docstring_new = salt.utils.data.decode(docstring_new)\n if docstring != docstring_new:\n docs[func] = docstring_new\n return docs\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
runner_doc
|
python
|
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
|
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L164-L219
|
[
"def strip_rst(docs):\n '''\n Strip/replace reStructuredText directives in docstrings\n '''\n for func, docstring in six.iteritems(docs):\n log.debug('Stripping docstring for %s', func)\n if not docstring:\n continue\n docstring_new = docstring if six.PY3 else salt.utils.data.encode(docstring)\n for regex, repl in (\n (r' *.. code-block:: \\S+\\n{1,2}', ''),\n ('.. note::', 'Note:'),\n ('.. warning::', 'Warning:'),\n ('.. versionadded::', 'New in version'),\n ('.. versionchanged::', 'Changed in version')):\n if six.PY2:\n regex = salt.utils.data.encode(regex)\n repl = salt.utils.data.encode(repl)\n try:\n docstring_new = re.sub(regex, repl, docstring_new)\n except Exception:\n log.debug(\n 'Exception encountered while matching regex %r to '\n 'docstring for function %s', regex, func,\n exc_info=True\n )\n if six.PY2:\n docstring_new = salt.utils.data.decode(docstring_new)\n if docstring != docstring_new:\n docs[func] = docstring_new\n return docs\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
returner_doc
|
python
|
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
|
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L222-L279
|
[
"def iterkeys(d, **kw):\n return d.iterkeys(**kw)\n",
"def strip_rst(docs):\n '''\n Strip/replace reStructuredText directives in docstrings\n '''\n for func, docstring in six.iteritems(docs):\n log.debug('Stripping docstring for %s', func)\n if not docstring:\n continue\n docstring_new = docstring if six.PY3 else salt.utils.data.encode(docstring)\n for regex, repl in (\n (r' *.. code-block:: \\S+\\n{1,2}', ''),\n ('.. note::', 'Note:'),\n ('.. warning::', 'Warning:'),\n ('.. versionadded::', 'New in version'),\n ('.. versionchanged::', 'Changed in version')):\n if six.PY2:\n regex = salt.utils.data.encode(regex)\n repl = salt.utils.data.encode(repl)\n try:\n docstring_new = re.sub(regex, repl, docstring_new)\n except Exception:\n log.debug(\n 'Exception encountered while matching regex %r to '\n 'docstring for function %s', regex, func,\n exc_info=True\n )\n if six.PY2:\n docstring_new = salt.utils.data.decode(docstring_new)\n if docstring != docstring_new:\n docs[func] = docstring_new\n return docs\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
renderer_doc
|
python
|
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
|
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L282-L325
|
[
"def iterkeys(d, **kw):\n return d.iterkeys(**kw)\n",
"def strip_rst(docs):\n '''\n Strip/replace reStructuredText directives in docstrings\n '''\n for func, docstring in six.iteritems(docs):\n log.debug('Stripping docstring for %s', func)\n if not docstring:\n continue\n docstring_new = docstring if six.PY3 else salt.utils.data.encode(docstring)\n for regex, repl in (\n (r' *.. code-block:: \\S+\\n{1,2}', ''),\n ('.. note::', 'Note:'),\n ('.. warning::', 'Warning:'),\n ('.. versionadded::', 'New in version'),\n ('.. versionchanged::', 'Changed in version')):\n if six.PY2:\n regex = salt.utils.data.encode(regex)\n repl = salt.utils.data.encode(repl)\n try:\n docstring_new = re.sub(regex, repl, docstring_new)\n except Exception:\n log.debug(\n 'Exception encountered while matching regex %r to '\n 'docstring for function %s', regex, func,\n exc_info=True\n )\n if six.PY2:\n docstring_new = salt.utils.data.decode(docstring_new)\n if docstring != docstring_new:\n docs[func] = docstring_new\n return docs\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
utils_doc
|
python
|
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
|
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L328-L374
|
[
"def strip_rst(docs):\n '''\n Strip/replace reStructuredText directives in docstrings\n '''\n for func, docstring in six.iteritems(docs):\n log.debug('Stripping docstring for %s', func)\n if not docstring:\n continue\n docstring_new = docstring if six.PY3 else salt.utils.data.encode(docstring)\n for regex, repl in (\n (r' *.. code-block:: \\S+\\n{1,2}', ''),\n ('.. note::', 'Note:'),\n ('.. warning::', 'Warning:'),\n ('.. versionadded::', 'New in version'),\n ('.. versionchanged::', 'Changed in version')):\n if six.PY2:\n regex = salt.utils.data.encode(regex)\n repl = salt.utils.data.encode(repl)\n try:\n docstring_new = re.sub(regex, repl, docstring_new)\n except Exception:\n log.debug(\n 'Exception encountered while matching regex %r to '\n 'docstring for function %s', regex, func,\n exc_info=True\n )\n if six.PY2:\n docstring_new = salt.utils.data.decode(docstring_new)\n if docstring != docstring_new:\n docs[func] = docstring_new\n return docs\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_functions
|
python
|
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
|
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L377-L423
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_modules
|
python
|
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
|
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L426-L460
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
state_argspec
|
python
|
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
|
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L505-L528
|
[
"def argspec_report(functions, module=''):\n '''\n Pass in a functions dict as it is returned from the loader and return the\n argspec function signatures\n '''\n ret = {}\n if '*' in module or '.' in module:\n for fun in fnmatch.filter(functions, module):\n try:\n aspec = get_function_argspec(functions[fun])\n except TypeError:\n # this happens if not callable\n continue\n\n args, varargs, kwargs, defaults = aspec\n\n ret[fun] = {}\n ret[fun]['args'] = args if args else None\n ret[fun]['defaults'] = defaults if defaults else None\n ret[fun]['varargs'] = True if varargs else None\n ret[fun]['kwargs'] = True if kwargs else None\n\n else:\n # \"sys\" should just match sys without also matching sysctl\n module_dot = module + '.'\n\n for fun in functions:\n if fun.startswith(module_dot):\n try:\n aspec = get_function_argspec(functions[fun])\n except TypeError:\n # this happens if not callable\n continue\n\n args, varargs, kwargs, defaults = aspec\n\n ret[fun] = {}\n ret[fun]['args'] = args if args else None\n ret[fun]['defaults'] = defaults if defaults else None\n ret[fun]['varargs'] = True if varargs else None\n ret[fun]['kwargs'] = True if kwargs else None\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
returner_argspec
|
python
|
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
|
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L531-L554
|
[
"def argspec_report(functions, module=''):\n '''\n Pass in a functions dict as it is returned from the loader and return the\n argspec function signatures\n '''\n ret = {}\n if '*' in module or '.' in module:\n for fun in fnmatch.filter(functions, module):\n try:\n aspec = get_function_argspec(functions[fun])\n except TypeError:\n # this happens if not callable\n continue\n\n args, varargs, kwargs, defaults = aspec\n\n ret[fun] = {}\n ret[fun]['args'] = args if args else None\n ret[fun]['defaults'] = defaults if defaults else None\n ret[fun]['varargs'] = True if varargs else None\n ret[fun]['kwargs'] = True if kwargs else None\n\n else:\n # \"sys\" should just match sys without also matching sysctl\n module_dot = module + '.'\n\n for fun in functions:\n if fun.startswith(module_dot):\n try:\n aspec = get_function_argspec(functions[fun])\n except TypeError:\n # this happens if not callable\n continue\n\n args, varargs, kwargs, defaults = aspec\n\n ret[fun] = {}\n ret[fun]['args'] = args if args else None\n ret[fun]['defaults'] = defaults if defaults else None\n ret[fun]['varargs'] = True if varargs else None\n ret[fun]['kwargs'] = True if kwargs else None\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
runner_argspec
|
python
|
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
|
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L557-L579
|
[
"def argspec_report(functions, module=''):\n '''\n Pass in a functions dict as it is returned from the loader and return the\n argspec function signatures\n '''\n ret = {}\n if '*' in module or '.' in module:\n for fun in fnmatch.filter(functions, module):\n try:\n aspec = get_function_argspec(functions[fun])\n except TypeError:\n # this happens if not callable\n continue\n\n args, varargs, kwargs, defaults = aspec\n\n ret[fun] = {}\n ret[fun]['args'] = args if args else None\n ret[fun]['defaults'] = defaults if defaults else None\n ret[fun]['varargs'] = True if varargs else None\n ret[fun]['kwargs'] = True if kwargs else None\n\n else:\n # \"sys\" should just match sys without also matching sysctl\n module_dot = module + '.'\n\n for fun in functions:\n if fun.startswith(module_dot):\n try:\n aspec = get_function_argspec(functions[fun])\n except TypeError:\n # this happens if not callable\n continue\n\n args, varargs, kwargs, defaults = aspec\n\n ret[fun] = {}\n ret[fun]['args'] = args if args else None\n ret[fun]['defaults'] = defaults if defaults else None\n ret[fun]['varargs'] = True if varargs else None\n ret[fun]['kwargs'] = True if kwargs else None\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_state_functions
|
python
|
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
|
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L582-L632
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_state_modules
|
python
|
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
|
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L635-L674
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_runners
|
python
|
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
|
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L677-L714
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_runner_functions
|
python
|
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
|
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L717-L760
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_returners
|
python
|
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
|
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L763-L801
|
[
"def iterkeys(d, **kw):\n return d.iterkeys(**kw)\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_returner_functions
|
python
|
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
|
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L804-L847
| null |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
list_renderers
|
python
|
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
|
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L850-L880
|
[
"def iterkeys(d, **kw):\n return d.iterkeys(**kw)\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
saltstack/salt
|
salt/modules/sysmod.py
|
state_schema
|
python
|
def state_schema(module=''):
'''
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
'''
specs = state_argspec(module)
schemas = []
for state_mod, state_spec in specs.items():
schemas.append(_argspec_to_schema(state_mod, state_spec))
return schemas
|
Return a JSON Schema for the given state function(s)
.. versionadded:: 2016.3.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_schema
salt '*' sys.state_schema pkg.installed
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/sysmod.py#L920-L939
|
[
"def state_argspec(module=''):\n '''\n Return the argument specification of functions in Salt state\n modules.\n\n .. versionadded:: 2015.5.0\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' sys.state_argspec pkg.installed\n salt '*' sys.state_argspec file\n salt '*' sys.state_argspec\n\n State names can be specified as globs.\n\n .. code-block:: bash\n\n salt '*' sys.state_argspec 'pkg.*'\n\n '''\n st_ = salt.state.State(__opts__)\n return salt.utils.args.argspec_report(st_.states, module)\n",
"def _argspec_to_schema(mod, spec):\n args = spec['args']\n defaults = spec['defaults'] or []\n\n args_req = args[:len(args) - len(defaults)]\n args_defaults = list(zip(args[-len(defaults):], defaults))\n\n types = {\n 'title': mod,\n 'description': mod,\n }\n\n for i in args_req:\n types[i] = salt.utils.schema.OneOfItem(items=(\n salt.utils.schema.BooleanItem(title=i, description=i, required=True),\n salt.utils.schema.IntegerItem(title=i, description=i, required=True),\n salt.utils.schema.NumberItem(title=i, description=i, required=True),\n salt.utils.schema.StringItem(title=i, description=i, required=True),\n\n # S.ArrayItem(title=i, description=i, required=True),\n # S.DictItem(title=i, description=i, required=True),\n ))\n\n for i, j in args_defaults:\n types[i] = salt.utils.schema.OneOfItem(items=(\n salt.utils.schema.BooleanItem(title=i, description=i, default=j),\n salt.utils.schema.IntegerItem(title=i, description=i, default=j),\n salt.utils.schema.NumberItem(title=i, description=i, default=j),\n salt.utils.schema.StringItem(title=i, description=i, default=j),\n\n # S.ArrayItem(title=i, description=i, default=j),\n # S.DictItem(title=i, description=i, default=j),\n ))\n\n return type(mod, (salt.utils.schema.Schema,), types).serialize()\n"
] |
# -*- coding: utf-8 -*-
'''
The sys module provides information about the available functions on the minion
'''
from __future__ import absolute_import, unicode_literals, print_function
# Import python libs
import fnmatch
import logging
# Import salt libs
import salt.loader
import salt.runner
import salt.state
import salt.utils.args
import salt.utils.schema
from salt.utils.doc import strip_rst as _strip_rst
from salt.ext.six.moves import zip
# Import 3rd-party libs
from salt.ext import six
log = logging.getLogger(__name__)
# Define the module's virtual name
__virtualname__ = 'sys'
__proxyenabled__ = ['*']
def __virtual__():
'''
Return as sys
'''
return __virtualname__
def doc(*args):
'''
Return the docstrings for all modules. Optionally, specify a module or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.doc
salt '*' sys.doc sys
salt '*' sys.doc sys.doc
salt '*' sys.doc network.traceroute user.info
Modules can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.doc 'sys.*'
salt '*' sys.doc 'sys.list_*'
'''
docs = {}
if not args:
for fun in __salt__:
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__salt__, target_mod):
docs[fun] = __salt__[fun].__doc__
else:
for fun in __salt__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __salt__[fun].__doc__
return _strip_rst(docs)
def state_doc(*args):
'''
Return the docstrings for all states. Optionally, specify a state or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple states/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_doc
salt '*' sys.state_doc service
salt '*' sys.state_doc service.running
salt '*' sys.state_doc service.running ipables.append
State names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.state_doc 'service.*' 'iptables.*'
'''
st_ = salt.state.State(__opts__)
docs = {}
if not args:
for fun in st_.states:
state = fun.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(st_.states, target_mod):
state = fun.split('.')[0]
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
else:
for fun in st_.states:
if fun == module or fun.startswith(target_mod):
state = module.split('.')[0]
if state not in docs:
if hasattr(st_.states[fun], '__globals__'):
docs[state] = st_.states[fun].__globals__['__doc__']
docs[fun] = st_.states[fun].__doc__
return _strip_rst(docs)
def runner_doc(*args):
'''
Return the docstrings for all runners. Optionally, specify a runner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple runners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_doc
salt '*' sys.runner_doc cache
salt '*' sys.runner_doc cache.grains
salt '*' sys.runner_doc cache.grains mine.get
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.runner_doc 'cache.clear_*'
'''
run_ = salt.runner.Runner(__opts__)
docs = {}
if not args:
for fun in run_.functions:
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(run_.functions, target_mod):
docs[fun] = run_.functions[fun].__doc__
else:
for fun in run_.functions:
if fun == module or fun.startswith(target_mod):
docs[fun] = run_.functions[fun].__doc__
return _strip_rst(docs)
def returner_doc(*args):
'''
Return the docstrings for all returners. Optionally, specify a returner or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple returners/functions can be specified.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_doc
salt '*' sys.returner_doc sqlite3
salt '*' sys.returner_doc sqlite3.get_fun
salt '*' sys.returner_doc sqlite3.get_fun etcd.get_fun
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.returner_doc 'sqlite3.get_*'
'''
returners_ = salt.loader.returners(__opts__, [])
docs = {}
if not args:
for fun in returners_:
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in returners_:
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
else:
for fun in six.iterkeys(returners_):
if fun == module or fun.startswith(target_mod):
docs[fun] = returners_[fun].__doc__
return _strip_rst(docs)
def renderer_doc(*args):
'''
Return the docstrings for all renderers. Optionally, specify a renderer or a
function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple renderers can be specified.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.renderer_doc
salt '*' sys.renderer_doc cheetah
salt '*' sys.renderer_doc jinja json
Renderer names can be specified as globs.
.. code-block:: bash
salt '*' sys.renderer_doc 'c*' 'j*'
'''
renderers_ = salt.loader.render(__opts__, [])
docs = {}
if not args:
for func in six.iterkeys(renderers_):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(renderers_, module):
docs[func] = renderers_[func].__doc__
else:
moduledot = module + '.'
for func in six.iterkeys(renderers_):
if func.startswith(moduledot):
docs[func] = renderers_[func].__doc__
return _strip_rst(docs)
def utils_doc(*args):
'''
.. versionadded:: Neon
Return the docstrings for all utils modules. Optionally, specify a module
or a function to narrow the selection.
The strings are aggregated into a single document on the master for easy
reading.
Multiple modules/functions can be specified.
CLI Example:
.. code-block:: bash
salt '*' sys.utils_doc
salt '*' sys.utils_doc data stringutils
salt '*' sys.utils_doc stringutils.to_unicode
salt '*' sys.utils_doc data.encode data.decode
'''
docs = {}
if not args:
for fun in __utils__:
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
for module in args:
_use_fnmatch = False
if '*' in module:
target_mod = module
_use_fnmatch = True
elif module:
# allow both "sys" and "sys." to match sys, without also matching
# sysctl
target_mod = module + '.' if not module.endswith('.') else module
else:
target_mod = ''
if _use_fnmatch:
for fun in fnmatch.filter(__utils__, target_mod):
docs[fun] = __utils__[fun].__doc__
else:
for fun in __utils__:
if fun == module or fun.startswith(target_mod):
docs[fun] = __utils__[fun].__doc__
return _strip_rst(docs)
def list_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all modules. Optionally, specify a module or modules
from which to list.
CLI Example:
.. code-block:: bash
salt '*' sys.list_functions
salt '*' sys.list_functions sys
salt '*' sys.list_functions sys user
Function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_functions 'sys.list_*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_functions 'module.specific_function'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
if not args:
# We're being asked for all functions
return sorted(__salt__)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(__salt__, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in __salt__:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_modules
Module names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_modules 's*'
'''
modules = set()
if not args:
for func in __salt__:
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(__salt__, module):
modules.add(func.split('.')[0])
else:
for func in __salt__:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def reload_modules():
'''
Tell the minion to reload the execution modules
CLI Example:
.. code-block:: bash
salt '*' sys.reload_modules
'''
# This function is actually handled inside the minion.py file, the function
# is caught before it ever gets here. Therefore, the docstring above is
# only for the online docs, and ANY CHANGES made to it must also be made in
# each of the gen_modules() funcs in minion.py.
return True
def argspec(module=''):
'''
Return the argument specification of functions in Salt execution
modules.
CLI Example:
.. code-block:: bash
salt '*' sys.argspec pkg.install
salt '*' sys.argspec sys
salt '*' sys.argspec
Module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.argspec 'pkg.*'
'''
return salt.utils.args.argspec_report(__salt__, module)
def state_argspec(module=''):
'''
Return the argument specification of functions in Salt state
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.state_argspec pkg.installed
salt '*' sys.state_argspec file
salt '*' sys.state_argspec
State names can be specified as globs.
.. code-block:: bash
salt '*' sys.state_argspec 'pkg.*'
'''
st_ = salt.state.State(__opts__)
return salt.utils.args.argspec_report(st_.states, module)
def returner_argspec(module=''):
'''
Return the argument specification of functions in Salt returner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.returner_argspec xmpp
salt '*' sys.returner_argspec xmpp smtp
salt '*' sys.returner_argspec
Returner names can be specified as globs.
.. code-block:: bash
salt '*' sys.returner_argspec 'sqlite3.*'
'''
returners_ = salt.loader.returners(__opts__, [])
return salt.utils.args.argspec_report(returners_, module)
def runner_argspec(module=''):
'''
Return the argument specification of functions in Salt runner
modules.
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.runner_argspec state
salt '*' sys.runner_argspec http
salt '*' sys.runner_argspec
Runner names can be specified as globs.
.. code-block:: bash
salt '*' sys.runner_argspec 'winrepo.*'
'''
run_ = salt.runner.Runner(__opts__)
return salt.utils.args.argspec_report(run_.functions, module)
def list_state_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all state modules. Optionally, specify a state
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_functions
salt '*' sys.list_state_functions file
salt '*' sys.list_state_functions pkg user
State function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_functions 'file.*'
salt '*' sys.list_state_functions 'file.s*'
.. versionadded:: ?
.. code-block:: bash
salt '*' sys.list_state_functions 'module.specific_function'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
st_ = salt.state.State(__opts__)
if not args:
# We're being asked for all functions
return sorted(st_.states)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(st_.states, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in st_.states:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_state_modules(*args):
'''
List the modules loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_state_modules
State module names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_state_modules 'mysql_*'
'''
st_ = salt.state.State(__opts__)
modules = set()
if not args:
for func in st_.states:
log.debug('func %s', func)
modules.add(func.split('.')[0])
return sorted(modules)
for module in args:
if '*' in module:
for func in fnmatch.filter(st_.states, module):
modules.add(func.split('.')[0])
else:
for func in st_.states:
mod_test = func.split('.')[0]
if mod_test == module:
modules.add(mod_test)
return sorted(modules)
def list_runners(*args):
'''
List the runners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runners
Runner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runners 'm*'
'''
run_ = salt.runner.Runner(__opts__)
runners = set()
if not args:
for func in run_.functions:
runners.add(func.split('.')[0])
return sorted(runners)
for module in args:
if '*' in module:
for func in fnmatch.filter(run_.functions, module):
runners.add(func.split('.')[0])
else:
for func in run_.functions:
mod_test = func.split('.')[0]
if mod_test == module:
runners.add(mod_test)
return sorted(runners)
def list_runner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all runner modules. Optionally, specify a runner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_runner_functions
salt '*' sys.list_runner_functions state
salt '*' sys.list_runner_functions state virt
Runner function names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_runner_functions 'state.*' 'virt.*'
'''
# ## NOTE: **kwargs is used here to prevent a traceback when garbage
# ## arguments are tacked on to the end.
run_ = salt.runner.Runner(__opts__)
if not args:
# We're being asked for all functions
return sorted(run_.functions)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(run_.functions, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in run_.functions:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_returners(*args):
'''
List the returners loaded on the minion
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returners
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returners 's*'
'''
returners_ = salt.loader.returners(__opts__, [])
returners = set()
if not args:
for func in six.iterkeys(returners_):
returners.add(func.split('.')[0])
return sorted(returners)
for module in args:
if '*' in module:
for func in fnmatch.filter(returners_, module):
returners.add(func.split('.')[0])
else:
for func in returners_:
mod_test = func.split('.')[0]
if mod_test == module:
returners.add(mod_test)
return sorted(returners)
def list_returner_functions(*args, **kwargs): # pylint: disable=unused-argument
'''
List the functions for all returner modules. Optionally, specify a returner
module or modules from which to list.
.. versionadded:: 2014.7.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_returner_functions
salt '*' sys.list_returner_functions mysql
salt '*' sys.list_returner_functions mysql etcd
Returner names can be specified as globs.
.. versionadded:: 2015.5.0
.. code-block:: bash
salt '*' sys.list_returner_functions 'sqlite3.get_*'
'''
# NOTE: **kwargs is used here to prevent a traceback when garbage
# arguments are tacked on to the end.
returners_ = salt.loader.returners(__opts__, [])
if not args:
# We're being asked for all functions
return sorted(returners_)
names = set()
for module in args:
if '*' in module or '.' in module:
for func in fnmatch.filter(returners_, module):
names.add(func)
else:
# "sys" should just match sys without also matching sysctl
moduledot = module + '.'
for func in returners_:
if func.startswith(moduledot):
names.add(func)
return sorted(names)
def list_renderers(*args):
'''
List the renderers loaded on the minion
.. versionadded:: 2015.5.0
CLI Example:
.. code-block:: bash
salt '*' sys.list_renderers
Render names can be specified as globs.
.. code-block:: bash
salt '*' sys.list_renderers 'yaml*'
'''
renderers_ = salt.loader.render(__opts__, [])
renderers = set()
if not args:
for rend in six.iterkeys(renderers_):
renderers.add(rend)
return sorted(renderers)
for module in args:
for rend in fnmatch.filter(renderers_, module):
renderers.add(rend)
return sorted(renderers)
def _argspec_to_schema(mod, spec):
args = spec['args']
defaults = spec['defaults'] or []
args_req = args[:len(args) - len(defaults)]
args_defaults = list(zip(args[-len(defaults):], defaults))
types = {
'title': mod,
'description': mod,
}
for i in args_req:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, required=True),
salt.utils.schema.IntegerItem(title=i, description=i, required=True),
salt.utils.schema.NumberItem(title=i, description=i, required=True),
salt.utils.schema.StringItem(title=i, description=i, required=True),
# S.ArrayItem(title=i, description=i, required=True),
# S.DictItem(title=i, description=i, required=True),
))
for i, j in args_defaults:
types[i] = salt.utils.schema.OneOfItem(items=(
salt.utils.schema.BooleanItem(title=i, description=i, default=j),
salt.utils.schema.IntegerItem(title=i, description=i, default=j),
salt.utils.schema.NumberItem(title=i, description=i, default=j),
salt.utils.schema.StringItem(title=i, description=i, default=j),
# S.ArrayItem(title=i, description=i, default=j),
# S.DictItem(title=i, description=i, default=j),
))
return type(mod, (salt.utils.schema.Schema,), types).serialize()
|
saltstack/salt
|
salt/modules/postgres.py
|
_find_pg_binary
|
python
|
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
|
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L159-L171
| null |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_run_psql
|
python
|
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
|
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L174-L221
|
[
"def mkstemp(*args, **kwargs):\n '''\n Helper function which does exactly what ``tempfile.mkstemp()`` does but\n accepts another argument, ``close_fd``, which, by default, is true and closes\n the fd before returning the file path. Something commonly done throughout\n Salt's code.\n '''\n if 'prefix' not in kwargs:\n kwargs['prefix'] = '__salt.tmp.'\n close_fd = kwargs.pop('close_fd', True)\n fd_, f_path = tempfile.mkstemp(*args, **kwargs)\n if close_fd is False:\n return fd_, f_path\n os.close(fd_)\n del fd_\n return f_path\n",
"def fopen(*args, **kwargs):\n '''\n Wrapper around open() built-in to set CLOEXEC on the fd.\n\n This flag specifies that the file descriptor should be closed when an exec\n function is invoked;\n\n When a file descriptor is allocated (as with open or dup), this bit is\n initially cleared on the new file descriptor, meaning that descriptor will\n survive into the new program after exec.\n\n NB! We still have small race condition between open and fcntl.\n '''\n if six.PY3:\n try:\n # Don't permit stdin/stdout/stderr to be opened. The boolean False\n # and True are treated by Python 3's open() as file descriptors 0\n # and 1, respectively.\n if args[0] in (0, 1, 2):\n raise TypeError(\n '{0} is not a permitted file descriptor'.format(args[0])\n )\n except IndexError:\n pass\n binary = None\n # ensure 'binary' mode is always used on Windows in Python 2\n if ((six.PY2 and salt.utils.platform.is_windows() and 'binary' not in kwargs) or\n kwargs.pop('binary', False)):\n if len(args) > 1:\n args = list(args)\n if 'b' not in args[1]:\n args[1] = args[1].replace('t', 'b')\n if 'b' not in args[1]:\n args[1] += 'b'\n elif kwargs.get('mode'):\n if 'b' not in kwargs['mode']:\n kwargs['mode'] = kwargs['mode'].replace('t', 'b')\n if 'b' not in kwargs['mode']:\n kwargs['mode'] += 'b'\n else:\n # the default is to read\n kwargs['mode'] = 'rb'\n elif six.PY3 and 'encoding' not in kwargs:\n # In Python 3, if text mode is used and the encoding\n # is not specified, set the encoding to 'utf-8'.\n binary = False\n if len(args) > 1:\n args = list(args)\n if 'b' in args[1]:\n binary = True\n if kwargs.get('mode', None):\n if 'b' in kwargs['mode']:\n binary = True\n if not binary:\n kwargs['encoding'] = __salt_system_encoding__\n\n if six.PY3 and not binary and not kwargs.get('newline', None):\n kwargs['newline'] = ''\n\n f_handle = open(*args, **kwargs) # pylint: disable=resource-leakage\n\n if is_fcntl_available():\n # modify the file descriptor on systems with fcntl\n # unix and unix-like systems only\n try:\n FD_CLOEXEC = fcntl.FD_CLOEXEC # pylint: disable=C0103\n except AttributeError:\n FD_CLOEXEC = 1 # pylint: disable=C0103\n old_flags = fcntl.fcntl(f_handle.fileno(), fcntl.F_GETFD)\n fcntl.fcntl(f_handle.fileno(), fcntl.F_SETFD, old_flags | FD_CLOEXEC)\n\n return f_handle\n",
"def to_str(s, encoding=None, errors='strict', normalize=False):\n '''\n Given str, bytes, bytearray, or unicode (py2), return str\n '''\n def _normalize(s):\n try:\n return unicodedata.normalize('NFC', s) if normalize else s\n except TypeError:\n return s\n\n if encoding is None:\n # Try utf-8 first, and fall back to detected encoding\n encoding = ('utf-8', __salt_system_encoding__)\n if not isinstance(encoding, (tuple, list)):\n encoding = (encoding,)\n\n if not encoding:\n raise ValueError('encoding cannot be empty')\n\n # This shouldn't be six.string_types because if we're on PY2 and we already\n # have a string, we should just return it.\n if isinstance(s, str):\n return _normalize(s)\n\n exc = None\n if six.PY3:\n if isinstance(s, (bytes, bytearray)):\n for enc in encoding:\n try:\n return _normalize(s.decode(enc, errors))\n except UnicodeDecodeError as err:\n exc = err\n continue\n # The only way we get this far is if a UnicodeDecodeError was\n # raised, otherwise we would have already returned (or raised some\n # other exception).\n raise exc # pylint: disable=raising-bad-type\n raise TypeError('expected str, bytes, or bytearray not {}'.format(type(s)))\n else:\n if isinstance(s, bytearray):\n return str(s) # future lint: disable=blacklisted-function\n if isinstance(s, unicode): # pylint: disable=incompatible-py3-code,undefined-variable\n for enc in encoding:\n try:\n return _normalize(s).encode(enc, errors)\n except UnicodeEncodeError as err:\n exc = err\n continue\n # The only way we get this far is if a UnicodeDecodeError was\n # raised, otherwise we would have already returned (or raised some\n # other exception).\n raise exc # pylint: disable=raising-bad-type\n raise TypeError('expected str, bytearray, or unicode')\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_run_initdb
|
python
|
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
|
Helper function to call initdb
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L224-L288
| null |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
version
|
python
|
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
|
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L291-L316
|
[
"def split(orig, sep=None):\n '''\n Generator function for iterating through large strings, particularly useful\n as a replacement for str.splitlines().\n\n See http://stackoverflow.com/a/3865367\n '''\n exp = re.compile(r'\\s+' if sep is None else re.escape(sep))\n pos = 0\n length = len(orig)\n while True:\n match = exp.search(orig, pos)\n if not match:\n if pos < length or sep is not None:\n val = orig[pos:]\n if val:\n # Only yield a value if the slice was not an empty string,\n # because if it is then we've reached the end. This keeps\n # us from yielding an extra blank value at the end.\n yield val\n break\n if pos < match.start() or sep is not None:\n yield orig[pos:match.start()]\n pos = match.end()\n",
"def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):\n '''\n Helper function to call psql, because the password requirement\n makes this too much code to be repeated in each function below\n '''\n kwargs = {\n 'reset_system_locale': False,\n 'clean_env': True,\n }\n if runas is None:\n if not host:\n host = __salt__['config.option']('postgres.host')\n if not host or host.startswith('/'):\n if 'FreeBSD' in __grains__['os_family']:\n runas = 'pgsql'\n elif 'OpenBSD' in __grains__['os_family']:\n runas = '_postgresql'\n else:\n runas = 'postgres'\n\n if user is None:\n user = runas\n\n if runas:\n kwargs['runas'] = runas\n\n if password is None:\n password = __salt__['config.option']('postgres.pass')\n if password is not None:\n pgpassfile = salt.utils.files.mkstemp(text=True)\n with salt.utils.files.fopen(pgpassfile, 'w') as fp_:\n fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(\n 'localhost' if not host or host.startswith('/') else host,\n port if port else '*',\n user if user else '*',\n password,\n )))\n __salt__['file.chown'](pgpassfile, runas, '')\n kwargs['env'] = {'PGPASSFILE': pgpassfile}\n\n ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)\n\n if ret.get('retcode', 0) != 0:\n log.error('Error connecting to Postgresql server')\n if password is not None and not __salt__['file.remove'](pgpassfile):\n log.warning('Remove PGPASSFILE failed')\n\n return ret\n",
"def _psql_cmd(*args, **kwargs):\n '''\n Return string with fully composed psql command.\n\n Accepts optional keyword arguments: user, host, port and maintenance_db,\n as well as any number of positional arguments to be added to the end of\n the command.\n '''\n (user, host, port, maintenance_db) = _connection_defaults(\n kwargs.get('user'),\n kwargs.get('host'),\n kwargs.get('port'),\n kwargs.get('maintenance_db'))\n _PSQL_BIN = _find_pg_binary('psql')\n cmd = [_PSQL_BIN,\n '--no-align',\n '--no-readline',\n '--no-psqlrc',\n '--no-password'] # Never prompt, handled in _run_psql.\n if user:\n cmd += ['--username', user]\n if host:\n cmd += ['--host', host]\n if port:\n cmd += ['--port', six.text_type(port)]\n if not maintenance_db:\n maintenance_db = 'postgres'\n cmd.extend(['--dbname', maintenance_db])\n cmd.extend(args)\n return cmd\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_parsed_version
|
python
|
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
|
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L319-L341
|
[
"def version(user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None):\n '''\n Return the version of a Postgres server.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.version\n '''\n query = 'SELECT setting FROM pg_catalog.pg_settings ' \\\n 'WHERE name = \\'server_version\\''\n cmd = _psql_cmd('-c', query,\n '-t',\n host=host,\n user=user,\n port=port,\n maintenance_db=maintenance_db,\n password=password)\n ret = _run_psql(\n cmd, runas=runas, password=password, host=host, port=port, user=user)\n\n for line in salt.utils.itertools.split(ret['stdout'], '\\n'):\n # Just return the first line\n return line\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_connection_defaults
|
python
|
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
|
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L344-L358
| null |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_psql_cmd
|
python
|
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
|
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L361-L390
|
[
"def _find_pg_binary(util):\n '''\n ... versionadded:: 2016.3.2\n\n Helper function to locate various psql related binaries\n '''\n pg_bin_dir = __salt__['config.option']('postgres.bins_dir')\n util_bin = salt.utils.path.which(util)\n if not util_bin:\n if pg_bin_dir:\n return salt.utils.path.which(os.path.join(pg_bin_dir, util))\n else:\n return util_bin\n",
"def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):\n '''\n Returns a tuple of (user, host, port, db) with config, pillar, or default\n values assigned to missing values.\n '''\n if not user:\n user = __salt__['config.option']('postgres.user')\n if not host:\n host = __salt__['config.option']('postgres.host')\n if not port:\n port = __salt__['config.option']('postgres.port')\n if not maintenance_db:\n maintenance_db = __salt__['config.option']('postgres.maintenance_db')\n\n return (user, host, port, maintenance_db)\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
psql_query
|
python
|
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
|
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L409-L486
|
[
"def to_str(s, encoding=None, errors='strict', normalize=False):\n '''\n Given str, bytes, bytearray, or unicode (py2), return str\n '''\n def _normalize(s):\n try:\n return unicodedata.normalize('NFC', s) if normalize else s\n except TypeError:\n return s\n\n if encoding is None:\n # Try utf-8 first, and fall back to detected encoding\n encoding = ('utf-8', __salt_system_encoding__)\n if not isinstance(encoding, (tuple, list)):\n encoding = (encoding,)\n\n if not encoding:\n raise ValueError('encoding cannot be empty')\n\n # This shouldn't be six.string_types because if we're on PY2 and we already\n # have a string, we should just return it.\n if isinstance(s, str):\n return _normalize(s)\n\n exc = None\n if six.PY3:\n if isinstance(s, (bytes, bytearray)):\n for enc in encoding:\n try:\n return _normalize(s.decode(enc, errors))\n except UnicodeDecodeError as err:\n exc = err\n continue\n # The only way we get this far is if a UnicodeDecodeError was\n # raised, otherwise we would have already returned (or raised some\n # other exception).\n raise exc # pylint: disable=raising-bad-type\n raise TypeError('expected str, bytes, or bytearray not {}'.format(type(s)))\n else:\n if isinstance(s, bytearray):\n return str(s) # future lint: disable=blacklisted-function\n if isinstance(s, unicode): # pylint: disable=incompatible-py3-code,undefined-variable\n for enc in encoding:\n try:\n return _normalize(s).encode(enc, errors)\n except UnicodeEncodeError as err:\n exc = err\n continue\n # The only way we get this far is if a UnicodeDecodeError was\n # raised, otherwise we would have already returned (or raised some\n # other exception).\n raise exc # pylint: disable=raising-bad-type\n raise TypeError('expected str, bytearray, or unicode')\n",
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
db_list
|
python
|
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
|
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L491-L522
|
[
"def psql_query(query, user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None, write=False):\n '''\n Run an SQL-Query and return the results as a list. This command\n only supports SELECT statements. This limitation can be worked around\n with a query like this:\n\n WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE\n rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;\n\n query\n The query string.\n\n user\n Database username, if different from config or default.\n\n host\n Database host, if different from config or default.\n\n port\n Database port, if different from the config or default.\n\n maintenance_db\n The database to run the query against.\n\n password\n User password, if different from the config or default.\n\n runas\n User to run the command as.\n\n write\n Mark query as READ WRITE transaction.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.psql_query 'select * from pg_stat_activity'\n '''\n ret = []\n\n csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(\n query.strip().rstrip(';'))\n\n # Mark transaction as R/W to achieve write will be allowed\n # Commit is necessary due to transaction\n if write:\n csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)\n\n # always use the same datestyle settings to allow parsing dates\n # regardless what server settings are configured\n cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',\n '-c', csv_query],\n runas=runas,\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n password=password)\n if cmdret['retcode'] > 0:\n return ret\n\n csv_file = StringIO(cmdret['stdout'])\n header = {}\n for row in csv.reader(csv_file,\n delimiter=salt.utils.stringutils.to_str(','),\n quotechar=salt.utils.stringutils.to_str('\"')):\n if not row:\n continue\n if not header:\n header = row\n continue\n ret.append(dict(zip(header, row)))\n\n # Remove 'COMMIT' message if query is inside R/W transction\n if write:\n ret = ret[0:-1]\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
db_exists
|
python
|
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
|
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L525-L540
|
[
"def db_list(user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None):\n '''\n Return dictionary with information about databases of a Postgres server.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.db_list\n '''\n\n ret = {}\n\n query = (\n 'SELECT datname as \"Name\", pga.rolname as \"Owner\", '\n 'pg_encoding_to_char(encoding) as \"Encoding\", '\n 'datcollate as \"Collate\", datctype as \"Ctype\", '\n 'datacl as \"Access privileges\", spcname as \"Tablespace\" '\n 'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '\n 'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'\n )\n\n rows = psql_query(query, runas=runas, host=host, user=user,\n port=port, maintenance_db=maintenance_db,\n password=password)\n\n for row in rows:\n ret[row['Name']] = row\n ret[row['Name']].pop('Name')\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
db_create
|
python
|
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
|
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L553-L607
|
[
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n",
"def _quote_ddl_value(value, quote=\"'\"):\n if value is None:\n return None\n if quote in value: # detect trivial sqli\n raise SaltInvocationError(\n 'Unsupported character {0} in value: {1}'.format(quote, value))\n return \"{quote}{value}{quote}\".format(quote=quote, value=value)\n",
"def items(self):\n 'od.items() -> list of (key, value) pairs in od'\n return [(key, self[key]) for key in self]\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
db_alter
|
python
|
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
|
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L610-L651
| null |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
tablespace_list
|
python
|
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
|
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L680-L711
| null |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
tablespace_exists
|
python
|
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
|
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L714-L731
|
[
"def tablespace_list(user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None):\n '''\n Return dictionary with information about tablespaces of a Postgres server.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.tablespace_list\n\n .. versionadded:: 2015.8.0\n '''\n\n ret = {}\n\n query = (\n 'SELECT spcname as \"Name\", pga.rolname as \"Owner\", spcacl as \"ACL\", '\n 'spcoptions as \"Opts\", pg_tablespace_location(pgts.oid) as \"Location\" '\n 'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'\n )\n\n rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,\n user=user, port=port,\n maintenance_db=maintenance_db,\n password=password)\n\n for row in rows:\n ret[row['Name']] = row\n ret[row['Name']].pop('Name')\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
tablespace_create
|
python
|
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
|
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L734-L767
|
[
"def iteritems(d, **kw):\n return d.iteritems(**kw)\n",
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
tablespace_alter
|
python
|
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
|
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L770-L813
|
[
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
tablespace_remove
|
python
|
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
|
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L816-L837
|
[
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
user_list
|
python
|
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
|
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L842-L941
|
[
"def _parsed_version(user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None):\n '''\n Returns the server version properly parsed and int casted for internal use.\n\n If the Postgres server does not respond, None will be returned.\n '''\n\n psql_version = version(\n user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas,\n )\n\n if psql_version:\n return _LooseVersion(psql_version)\n else:\n log.warning('Attempt to parse version of Postgres server failed. '\n 'Is the server responding?')\n return None\n",
"def psql_query(query, user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None, write=False):\n '''\n Run an SQL-Query and return the results as a list. This command\n only supports SELECT statements. This limitation can be worked around\n with a query like this:\n\n WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE\n rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;\n\n query\n The query string.\n\n user\n Database username, if different from config or default.\n\n host\n Database host, if different from config or default.\n\n port\n Database port, if different from the config or default.\n\n maintenance_db\n The database to run the query against.\n\n password\n User password, if different from the config or default.\n\n runas\n User to run the command as.\n\n write\n Mark query as READ WRITE transaction.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.psql_query 'select * from pg_stat_activity'\n '''\n ret = []\n\n csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(\n query.strip().rstrip(';'))\n\n # Mark transaction as R/W to achieve write will be allowed\n # Commit is necessary due to transaction\n if write:\n csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)\n\n # always use the same datestyle settings to allow parsing dates\n # regardless what server settings are configured\n cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',\n '-c', csv_query],\n runas=runas,\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n password=password)\n if cmdret['retcode'] > 0:\n return ret\n\n csv_file = StringIO(cmdret['stdout'])\n header = {}\n for row in csv.reader(csv_file,\n delimiter=salt.utils.stringutils.to_str(','),\n quotechar=salt.utils.stringutils.to_str('\"')):\n if not row:\n continue\n if not header:\n header = row\n continue\n ret.append(dict(zip(header, row)))\n\n # Remove 'COMMIT' message if query is inside R/W transction\n if write:\n ret = ret[0:-1]\n\n return ret\n",
"_x = lambda s: s if return_password else ''\n",
"def get_bool(rowdict, key):\n '''\n Returns the boolean value of the key, instead of 't' and 'f' strings.\n '''\n if rowdict[key] == 't':\n return True\n elif rowdict[key] == 'f':\n return False\n else:\n return None\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
role_get
|
python
|
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
|
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L944-L968
|
[
"def user_list(user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None, return_password=False):\n '''\n Return a dict with information about users of a Postgres server.\n\n Set return_password to True to get password hash in the result.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.user_list\n '''\n\n ret = {}\n\n ver = _parsed_version(user=user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas)\n if ver:\n if ver >= _LooseVersion('9.1'):\n replication_column = 'pg_roles.rolreplication'\n else:\n replication_column = 'NULL'\n if ver >= _LooseVersion('9.5'):\n rolcatupdate_column = 'NULL'\n else:\n rolcatupdate_column = 'pg_roles.rolcatupdate'\n else:\n log.error('Could not retrieve Postgres version. Is Postgresql server running?')\n return False\n\n # will return empty string if return_password = False\n _x = lambda s: s if return_password else ''\n\n query = (''.join([\n 'SELECT '\n 'pg_roles.rolname as \"name\",'\n 'pg_roles.rolsuper as \"superuser\", '\n 'pg_roles.rolinherit as \"inherits privileges\", '\n 'pg_roles.rolcreaterole as \"can create roles\", '\n 'pg_roles.rolcreatedb as \"can create databases\", '\n '{0} as \"can update system catalogs\", '\n 'pg_roles.rolcanlogin as \"can login\", '\n '{1} as \"replication\", '\n 'pg_roles.rolconnlimit as \"connections\", '\n '(SELECT array_agg(pg_roles2.rolname)'\n ' FROM pg_catalog.pg_auth_members'\n ' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'\n ' WHERE pg_auth_members.member = pg_roles.oid) as \"groups\",'\n 'pg_roles.rolvaliduntil::timestamp(0) as \"expiry time\", '\n 'pg_roles.rolconfig as \"defaults variables\" '\n , _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as \"password\" '),\n 'FROM pg_roles '\n , _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')\n , _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')\n ]).format(rolcatupdate_column, replication_column))\n\n rows = psql_query(query,\n runas=runas,\n host=host,\n user=user,\n port=port,\n maintenance_db=maintenance_db,\n password=password)\n\n def get_bool(rowdict, key):\n '''\n Returns the boolean value of the key, instead of 't' and 'f' strings.\n '''\n if rowdict[key] == 't':\n return True\n elif rowdict[key] == 'f':\n return False\n else:\n return None\n\n for row in rows:\n retrow = {}\n for key in ('superuser', 'inherits privileges', 'can create roles',\n 'can create databases', 'can update system catalogs',\n 'can login', 'replication', 'connections'):\n retrow[key] = get_bool(row, key)\n for date_key in ('expiry time',):\n try:\n retrow[date_key] = datetime.datetime.strptime(\n row[date_key], '%Y-%m-%d %H:%M:%S')\n except ValueError:\n retrow[date_key] = None\n retrow['defaults variables'] = row['defaults variables']\n if return_password:\n retrow['password'] = row['password']\n # use csv reader to handle quoted roles correctly\n retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]\n ret[row['name']] = retrow\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
user_exists
|
python
|
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
|
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L971-L992
|
[
"def role_get(name, user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None, return_password=False):\n '''\n Return a dict with information about users of a Postgres server.\n\n Set return_password to True to get password hash in the result.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.role_get postgres\n '''\n all_users = user_list(user=user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas,\n return_password=return_password)\n try:\n return all_users.get(name, None)\n except AttributeError:\n log.error('Could not retrieve Postgres role. Is Postgres running?')\n return None\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_maybe_encrypt_password
|
python
|
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
|
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1015-L1026
| null |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_role_create
|
python
|
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
|
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1119-L1170
|
[
"def user_exists(name,\n user=None, host=None, port=None, maintenance_db=None,\n password=None,\n runas=None):\n '''\n Checks if a user exists on the Postgres server.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.user_exists 'username'\n '''\n return bool(\n role_get(name,\n user=user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas,\n return_password=False))\n",
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n",
"def _role_cmd_args(name,\n sub_cmd='',\n typ_='role',\n encrypted=None,\n login=None,\n connlimit=None,\n inherit=None,\n createdb=None,\n createroles=None,\n superuser=None,\n groups=None,\n replication=None,\n rolepassword=None,\n valid_until=None,\n db_role=None):\n if inherit is None:\n if typ_ in ['user', 'group']:\n inherit = True\n if login is None:\n if typ_ == 'user':\n login = True\n if typ_ == 'group':\n login = False\n # defaults to encrypted passwords (md5{password}{rolename})\n if encrypted is None:\n encrypted = _DEFAULT_PASSWORDS_ENCRYPTION\n skip_passwd = False\n escaped_password = ''\n escaped_valid_until = ''\n if not (\n rolepassword is not None\n # first is passwd set\n # second is for handling NOPASSWD\n and (\n isinstance(rolepassword, six.string_types) and bool(rolepassword)\n )\n or (\n isinstance(rolepassword, bool)\n )\n ):\n skip_passwd = True\n if isinstance(rolepassword, six.string_types) and bool(rolepassword):\n escaped_password = '\\'{0}\\''.format(\n _maybe_encrypt_password(name,\n rolepassword.replace('\\'', '\\'\\''),\n encrypted=encrypted))\n if isinstance(valid_until, six.string_types) and bool(valid_until):\n escaped_valid_until = '\\'{0}\\''.format(\n valid_until.replace('\\'', '\\'\\''),\n )\n skip_superuser = False\n if bool(db_role) and bool(superuser) == bool(db_role['superuser']):\n skip_superuser = True\n flags = (\n {'flag': 'INHERIT', 'test': inherit},\n {'flag': 'CREATEDB', 'test': createdb},\n {'flag': 'CREATEROLE', 'test': createroles},\n {'flag': 'SUPERUSER', 'test': superuser,\n 'skip': skip_superuser},\n {'flag': 'REPLICATION', 'test': replication},\n {'flag': 'LOGIN', 'test': login},\n {'flag': 'CONNECTION LIMIT',\n 'test': bool(connlimit),\n 'addtxt': six.text_type(connlimit),\n 'skip': connlimit is None},\n {'flag': 'ENCRYPTED',\n 'test': (encrypted is not None and bool(rolepassword)),\n 'skip': skip_passwd or isinstance(rolepassword, bool),\n 'cond': encrypted,\n 'prefix': 'UN'},\n {'flag': 'PASSWORD', 'test': bool(rolepassword),\n 'skip': skip_passwd,\n 'addtxt': escaped_password},\n {'flag': 'VALID UNTIL',\n 'test': bool(valid_until),\n 'skip': valid_until is None,\n 'addtxt': escaped_valid_until},\n )\n for data in flags:\n sub_cmd = _add_role_flag(sub_cmd, **data)\n if sub_cmd.endswith('WITH'):\n sub_cmd = sub_cmd.replace(' WITH', '')\n if groups:\n if isinstance(groups, list):\n groups = ','.join(groups)\n for group in groups.split(','):\n sub_cmd = '{0}; GRANT \"{1}\" TO \"{2}\"'.format(sub_cmd, group, name)\n return sub_cmd\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
user_create
|
python
|
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
|
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1173-L1220
|
[
"def _role_create(name,\n user=None,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n createdb=None,\n createroles=None,\n encrypted=None,\n superuser=None,\n login=None,\n connlimit=None,\n inherit=None,\n replication=None,\n rolepassword=None,\n valid_until=None,\n typ_='role',\n groups=None,\n runas=None):\n '''\n Creates a Postgres role. Users and Groups are both roles in postgres.\n However, users can login, groups cannot.\n '''\n\n # check if role exists\n if user_exists(name, user, host, port, maintenance_db,\n password=password, runas=runas):\n log.info('%s \\'%s\\' already exists', typ_.capitalize(), name)\n return False\n\n sub_cmd = 'CREATE ROLE \"{0}\" WITH'.format(name)\n sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(\n name,\n typ_=typ_,\n encrypted=encrypted,\n login=login,\n connlimit=connlimit,\n inherit=inherit,\n createdb=createdb,\n createroles=createroles,\n superuser=superuser,\n groups=groups,\n replication=replication,\n rolepassword=rolepassword,\n valid_until=valid_until\n ))\n ret = _psql_prepare_and_run(['-c', sub_cmd],\n runas=runas, host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n password=password)\n\n return ret['retcode'] == 0\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_role_update
|
python
|
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
|
Updates a postgres role.
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1223-L1282
|
[
"def role_get(name, user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None, return_password=False):\n '''\n Return a dict with information about users of a Postgres server.\n\n Set return_password to True to get password hash in the result.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.role_get postgres\n '''\n all_users = user_list(user=user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas,\n return_password=return_password)\n try:\n return all_users.get(name, None)\n except AttributeError:\n log.error('Could not retrieve Postgres role. Is Postgres running?')\n return None\n",
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n",
"def _role_cmd_args(name,\n sub_cmd='',\n typ_='role',\n encrypted=None,\n login=None,\n connlimit=None,\n inherit=None,\n createdb=None,\n createroles=None,\n superuser=None,\n groups=None,\n replication=None,\n rolepassword=None,\n valid_until=None,\n db_role=None):\n if inherit is None:\n if typ_ in ['user', 'group']:\n inherit = True\n if login is None:\n if typ_ == 'user':\n login = True\n if typ_ == 'group':\n login = False\n # defaults to encrypted passwords (md5{password}{rolename})\n if encrypted is None:\n encrypted = _DEFAULT_PASSWORDS_ENCRYPTION\n skip_passwd = False\n escaped_password = ''\n escaped_valid_until = ''\n if not (\n rolepassword is not None\n # first is passwd set\n # second is for handling NOPASSWD\n and (\n isinstance(rolepassword, six.string_types) and bool(rolepassword)\n )\n or (\n isinstance(rolepassword, bool)\n )\n ):\n skip_passwd = True\n if isinstance(rolepassword, six.string_types) and bool(rolepassword):\n escaped_password = '\\'{0}\\''.format(\n _maybe_encrypt_password(name,\n rolepassword.replace('\\'', '\\'\\''),\n encrypted=encrypted))\n if isinstance(valid_until, six.string_types) and bool(valid_until):\n escaped_valid_until = '\\'{0}\\''.format(\n valid_until.replace('\\'', '\\'\\''),\n )\n skip_superuser = False\n if bool(db_role) and bool(superuser) == bool(db_role['superuser']):\n skip_superuser = True\n flags = (\n {'flag': 'INHERIT', 'test': inherit},\n {'flag': 'CREATEDB', 'test': createdb},\n {'flag': 'CREATEROLE', 'test': createroles},\n {'flag': 'SUPERUSER', 'test': superuser,\n 'skip': skip_superuser},\n {'flag': 'REPLICATION', 'test': replication},\n {'flag': 'LOGIN', 'test': login},\n {'flag': 'CONNECTION LIMIT',\n 'test': bool(connlimit),\n 'addtxt': six.text_type(connlimit),\n 'skip': connlimit is None},\n {'flag': 'ENCRYPTED',\n 'test': (encrypted is not None and bool(rolepassword)),\n 'skip': skip_passwd or isinstance(rolepassword, bool),\n 'cond': encrypted,\n 'prefix': 'UN'},\n {'flag': 'PASSWORD', 'test': bool(rolepassword),\n 'skip': skip_passwd,\n 'addtxt': escaped_password},\n {'flag': 'VALID UNTIL',\n 'test': bool(valid_until),\n 'skip': valid_until is None,\n 'addtxt': escaped_valid_until},\n )\n for data in flags:\n sub_cmd = _add_role_flag(sub_cmd, **data)\n if sub_cmd.endswith('WITH'):\n sub_cmd = sub_cmd.replace(' WITH', '')\n if groups:\n if isinstance(groups, list):\n groups = ','.join(groups)\n for group in groups.split(','):\n sub_cmd = '{0}; GRANT \"{1}\" TO \"{2}\"'.format(sub_cmd, group, name)\n return sub_cmd\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
_role_remove
|
python
|
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
|
Removes a role from the Postgres Server
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1335-L1359
|
[
"def user_exists(name,\n user=None, host=None, port=None, maintenance_db=None,\n password=None,\n runas=None):\n '''\n Checks if a user exists on the Postgres server.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.user_exists 'username'\n '''\n return bool(\n role_get(name,\n user=user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas,\n return_password=False))\n",
"def _psql_prepare_and_run(cmd,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None,\n user=None):\n rcmd = _psql_cmd(\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n *cmd)\n cmdret = _run_psql(\n rcmd, runas=runas, password=password, host=host, port=port, user=user)\n return cmdret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
installed_extensions
|
python
|
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
|
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1393-L1421
|
[
"def psql_query(query, user=None, host=None, port=None, maintenance_db=None,\n password=None, runas=None, write=False):\n '''\n Run an SQL-Query and return the results as a list. This command\n only supports SELECT statements. This limitation can be worked around\n with a query like this:\n\n WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE\n rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;\n\n query\n The query string.\n\n user\n Database username, if different from config or default.\n\n host\n Database host, if different from config or default.\n\n port\n Database port, if different from the config or default.\n\n maintenance_db\n The database to run the query against.\n\n password\n User password, if different from the config or default.\n\n runas\n User to run the command as.\n\n write\n Mark query as READ WRITE transaction.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.psql_query 'select * from pg_stat_activity'\n '''\n ret = []\n\n csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(\n query.strip().rstrip(';'))\n\n # Mark transaction as R/W to achieve write will be allowed\n # Commit is necessary due to transaction\n if write:\n csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)\n\n # always use the same datestyle settings to allow parsing dates\n # regardless what server settings are configured\n cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',\n '-c', csv_query],\n runas=runas,\n host=host, user=user, port=port,\n maintenance_db=maintenance_db,\n password=password)\n if cmdret['retcode'] > 0:\n return ret\n\n csv_file = StringIO(cmdret['stdout'])\n header = {}\n for row in csv.reader(csv_file,\n delimiter=salt.utils.stringutils.to_str(','),\n quotechar=salt.utils.stringutils.to_str('\"')):\n if not row:\n continue\n if not header:\n header = row\n continue\n ret.append(dict(zip(header, row)))\n\n # Remove 'COMMIT' message if query is inside R/W transction\n if write:\n ret = ret[0:-1]\n\n return ret\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
get_available_extension
|
python
|
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
|
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1424-L1446
|
[
"def available_extensions(user=None,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None):\n '''\n List available postgresql extensions\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.available_extensions\n\n '''\n exts = []\n query = (\n 'select * '\n 'from pg_available_extensions();'\n )\n ret = psql_query(query, user=user, host=host, port=port,\n maintenance_db=maintenance_db,\n password=password, runas=runas)\n exts = {}\n for row in ret:\n if 'default_version' in row and 'name' in row:\n exts[row['name']] = row\n return exts\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
get_installed_extension
|
python
|
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
|
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1449-L1471
|
[
"def installed_extensions(user=None,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None):\n '''\n List installed postgresql extensions\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.installed_extensions\n\n '''\n exts = []\n query = (\n 'select a.*, b.nspname as schema_name '\n 'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'\n )\n ret = psql_query(query, user=user, host=host, port=port,\n maintenance_db=maintenance_db,\n password=password, runas=runas)\n exts = {}\n for row in ret:\n if 'extversion' in row and 'extname' in row:\n exts[row['extname']] = row\n return exts\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
saltstack/salt
|
salt/modules/postgres.py
|
is_available_extension
|
python
|
def is_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
'''
exts = available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if name.lower() in [
a.lower()
for a in exts
]:
return True
return False
|
Test if a specific extension is available
CLI Example:
.. code-block:: bash
salt '*' postgres.is_available_extension
|
train
|
https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/postgres.py#L1474-L1502
|
[
"def available_extensions(user=None,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None):\n '''\n List available postgresql extensions\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.available_extensions\n\n '''\n exts = []\n query = (\n 'select * '\n 'from pg_available_extensions();'\n )\n ret = psql_query(query, user=user, host=host, port=port,\n maintenance_db=maintenance_db,\n password=password, runas=runas)\n exts = {}\n for row in ret:\n if 'default_version' in row and 'name' in row:\n exts[row['name']] = row\n return exts\n"
] |
# -*- coding: utf-8 -*-
'''
Module to provide Postgres compatibility to salt.
:configuration: In order to connect to Postgres, certain configuration is
required in /etc/salt/minion on the relevant minions. Some sample configs
might look like::
postgres.host: 'localhost'
postgres.port: '5432'
postgres.user: 'postgres' -> db user
postgres.pass: ''
postgres.maintenance_db: 'postgres'
The default for the maintenance_db is 'postgres' and in most cases it can
be left at the default setting.
This data can also be passed into pillar. Options passed into opts will
overwrite options passed into pillar
:note: This module uses MD5 hashing which may not be compliant with certain
security audits.
:note: When installing postgres from the official postgres repos, on certain
linux distributions, either the psql or the initdb binary is *not*
automatically placed on the path. Add a configuration to the location
of the postgres bin's path to the relevant minion for this module::
postgres.bins_dir: '/usr/pgsql-9.5/bin/'
'''
# This pylint error is popping up where there are no colons?
# pylint: disable=E8203
# Import python libs
from __future__ import absolute_import, unicode_literals, print_function
import datetime
import logging
import hashlib
import os
import re
import pipes
import tempfile
try:
import csv
HAS_CSV = True
except ImportError:
HAS_CSV = False
# Import salt libs
import salt.utils.files
import salt.utils.itertools
import salt.utils.odict
import salt.utils.path
import salt.utils.stringutils
from salt.exceptions import CommandExecutionError, SaltInvocationError
from salt.utils.versions import LooseVersion as _LooseVersion
# Import 3rd-party libs
from salt.ext import six
from salt.ext.six.moves import zip # pylint: disable=import-error,redefined-builtin
from salt.ext.six.moves import StringIO
log = logging.getLogger(__name__)
_DEFAULT_PASSWORDS_ENCRYPTION = True
_EXTENSION_NOT_INSTALLED = 'EXTENSION NOT INSTALLED'
_EXTENSION_INSTALLED = 'EXTENSION INSTALLED'
_EXTENSION_TO_UPGRADE = 'EXTENSION TO UPGRADE'
_EXTENSION_TO_MOVE = 'EXTENSION TO MOVE'
_EXTENSION_FLAGS = (
_EXTENSION_NOT_INSTALLED,
_EXTENSION_INSTALLED,
_EXTENSION_TO_UPGRADE,
_EXTENSION_TO_MOVE,
)
_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
'c': 'CONNECT',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'T': 'TEMPORARY',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_MAP = {
'a': 'INSERT',
'C': 'CREATE',
'D': 'TRUNCATE',
't': 'TRIGGER',
'r': 'SELECT',
'U': 'USAGE',
'w': 'UPDATE',
'X': 'EXECUTE',
'x': 'REFERENCES',
'd': 'DELETE',
'*': 'GRANT',
}
_DEFAULT_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'sequence',
'table',
'group',
'function',
)
)
_PRIVILEGES_OBJECTS = frozenset(
(
'schema',
'tablespace',
'language',
'sequence',
'table',
'group',
'database',
'function',
)
)
_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'tablespace': 'C',
'language': 'U',
'sequence': 'rwU',
'schema': 'UC',
'database': 'CTc',
'function': 'X',
}
_DEFAULT_PRIVILEGE_TYPE_MAP = {
'table': 'arwdDxt',
'sequence': 'rwU',
'schema': 'UC',
'function': 'X',
}
def __virtual__():
'''
Only load this module if the psql bin exist.
initdb bin might also be used, but its presence will be detected on runtime.
'''
utils = ['psql']
if not HAS_CSV:
return False
for util in utils:
if not salt.utils.path.which(util):
if not _find_pg_binary(util):
return (False, '{0} was not found'.format(util))
return True
def _find_pg_binary(util):
'''
... versionadded:: 2016.3.2
Helper function to locate various psql related binaries
'''
pg_bin_dir = __salt__['config.option']('postgres.bins_dir')
util_bin = salt.utils.path.which(util)
if not util_bin:
if pg_bin_dir:
return salt.utils.path.which(os.path.join(pg_bin_dir, util))
else:
return util_bin
def _run_psql(cmd, runas=None, password=None, host=None, port=None, user=None):
'''
Helper function to call psql, because the password requirement
makes this too much code to be repeated in each function below
'''
kwargs = {
'reset_system_locale': False,
'clean_env': True,
}
if runas is None:
if not host:
host = __salt__['config.option']('postgres.host')
if not host or host.startswith('/'):
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
if runas:
kwargs['runas'] = runas
if password is None:
password = __salt__['config.option']('postgres.pass')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}:{1}:*:{2}:{3}'.format(
'localhost' if not host or host.startswith('/') else host,
port if port else '*',
user if user else '*',
password,
)))
__salt__['file.chown'](pgpassfile, runas, '')
kwargs['env'] = {'PGPASSFILE': pgpassfile}
ret = __salt__['cmd.run_all'](cmd, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error connecting to Postgresql server')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Remove PGPASSFILE failed')
return ret
def _run_initdb(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
runas=None,
waldir=None,
checksums=False):
'''
Helper function to call initdb
'''
if runas is None:
if 'FreeBSD' in __grains__['os_family']:
runas = 'pgsql'
elif 'OpenBSD' in __grains__['os_family']:
runas = '_postgresql'
else:
runas = 'postgres'
if user is None:
user = runas
_INITDB_BIN = _find_pg_binary('initdb')
if not _INITDB_BIN:
raise CommandExecutionError('initdb executable not found.')
cmd = [
_INITDB_BIN,
'--pgdata={0}'.format(name),
'--username={0}'.format(user),
'--auth={0}'.format(auth),
'--encoding={0}'.format(encoding),
]
if locale is not None:
cmd.append('--locale={0}'.format(locale))
# intentionally use short option, as the long option name has been
# renamed from "xlogdir" to "waldir" in PostgreSQL 10
if waldir is not None:
cmd.append('-X')
cmd.append(waldir)
if checksums:
cmd.append('--data-checksums')
if password is not None:
pgpassfile = salt.utils.files.mkstemp(text=True)
with salt.utils.files.fopen(pgpassfile, 'w') as fp_:
fp_.write(salt.utils.stringutils.to_str('{0}'.format(password)))
__salt__['file.chown'](pgpassfile, runas, '')
cmd.extend([
'--pwfile={0}'.format(pgpassfile),
])
kwargs = dict(runas=runas, clean_env=True)
cmdstr = ' '.join([pipes.quote(c) for c in cmd])
ret = __salt__['cmd.run_all'](cmdstr, python_shell=False, **kwargs)
if ret.get('retcode', 0) != 0:
log.error('Error initilizing the postgres data directory')
if password is not None and not __salt__['file.remove'](pgpassfile):
log.warning('Removal of PGPASSFILE failed')
return ret
def version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return the version of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.version
'''
query = 'SELECT setting FROM pg_catalog.pg_settings ' \
'WHERE name = \'server_version\''
cmd = _psql_cmd('-c', query,
'-t',
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = _run_psql(
cmd, runas=runas, password=password, host=host, port=port, user=user)
for line in salt.utils.itertools.split(ret['stdout'], '\n'):
# Just return the first line
return line
def _parsed_version(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Returns the server version properly parsed and int casted for internal use.
If the Postgres server does not respond, None will be returned.
'''
psql_version = version(
user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
)
if psql_version:
return _LooseVersion(psql_version)
else:
log.warning('Attempt to parse version of Postgres server failed. '
'Is the server responding?')
return None
def _connection_defaults(user=None, host=None, port=None, maintenance_db=None):
'''
Returns a tuple of (user, host, port, db) with config, pillar, or default
values assigned to missing values.
'''
if not user:
user = __salt__['config.option']('postgres.user')
if not host:
host = __salt__['config.option']('postgres.host')
if not port:
port = __salt__['config.option']('postgres.port')
if not maintenance_db:
maintenance_db = __salt__['config.option']('postgres.maintenance_db')
return (user, host, port, maintenance_db)
def _psql_cmd(*args, **kwargs):
'''
Return string with fully composed psql command.
Accepts optional keyword arguments: user, host, port and maintenance_db,
as well as any number of positional arguments to be added to the end of
the command.
'''
(user, host, port, maintenance_db) = _connection_defaults(
kwargs.get('user'),
kwargs.get('host'),
kwargs.get('port'),
kwargs.get('maintenance_db'))
_PSQL_BIN = _find_pg_binary('psql')
cmd = [_PSQL_BIN,
'--no-align',
'--no-readline',
'--no-psqlrc',
'--no-password'] # Never prompt, handled in _run_psql.
if user:
cmd += ['--username', user]
if host:
cmd += ['--host', host]
if port:
cmd += ['--port', six.text_type(port)]
if not maintenance_db:
maintenance_db = 'postgres'
cmd.extend(['--dbname', maintenance_db])
cmd.extend(args)
return cmd
def _psql_prepare_and_run(cmd,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None,
user=None):
rcmd = _psql_cmd(
host=host, user=user, port=port,
maintenance_db=maintenance_db,
*cmd)
cmdret = _run_psql(
rcmd, runas=runas, password=password, host=host, port=port, user=user)
return cmdret
def psql_query(query, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, write=False):
'''
Run an SQL-Query and return the results as a list. This command
only supports SELECT statements. This limitation can be worked around
with a query like this:
WITH updated AS (UPDATE pg_authid SET rolconnlimit = 2000 WHERE
rolname = 'rolename' RETURNING rolconnlimit) SELECT * FROM updated;
query
The query string.
user
Database username, if different from config or default.
host
Database host, if different from config or default.
port
Database port, if different from the config or default.
maintenance_db
The database to run the query against.
password
User password, if different from the config or default.
runas
User to run the command as.
write
Mark query as READ WRITE transaction.
CLI Example:
.. code-block:: bash
salt '*' postgres.psql_query 'select * from pg_stat_activity'
'''
ret = []
csv_query = 'COPY ({0}) TO STDOUT WITH CSV HEADER'.format(
query.strip().rstrip(';'))
# Mark transaction as R/W to achieve write will be allowed
# Commit is necessary due to transaction
if write:
csv_query = 'START TRANSACTION READ WRITE; {0}; COMMIT TRANSACTION;'.format(csv_query)
# always use the same datestyle settings to allow parsing dates
# regardless what server settings are configured
cmdret = _psql_prepare_and_run(['-v', 'datestyle=ISO,MDY',
'-c', csv_query],
runas=runas,
host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
if cmdret['retcode'] > 0:
return ret
csv_file = StringIO(cmdret['stdout'])
header = {}
for row in csv.reader(csv_file,
delimiter=salt.utils.stringutils.to_str(','),
quotechar=salt.utils.stringutils.to_str('"')):
if not row:
continue
if not header:
header = row
continue
ret.append(dict(zip(header, row)))
# Remove 'COMMIT' message if query is inside R/W transction
if write:
ret = ret[0:-1]
return ret
# Database related actions
def db_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about databases of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_list
'''
ret = {}
query = (
'SELECT datname as "Name", pga.rolname as "Owner", '
'pg_encoding_to_char(encoding) as "Encoding", '
'datcollate as "Collate", datctype as "Ctype", '
'datacl as "Access privileges", spcname as "Tablespace" '
'FROM pg_database pgd, pg_roles pga, pg_tablespace pgts '
'WHERE pga.oid = pgd.datdba AND pgts.oid = pgd.dattablespace'
)
rows = psql_query(query, runas=runas, host=host, user=user,
port=port, maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def db_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a database exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_exists 'dbname'
'''
databases = db_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in databases
# TODO properly implemented escaping
def _quote_ddl_value(value, quote="'"):
if value is None:
return None
if quote in value: # detect trivial sqli
raise SaltInvocationError(
'Unsupported character {0} in value: {1}'.format(quote, value))
return "{quote}{value}{quote}".format(quote=quote, value=value)
def db_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
tablespace=None,
encoding=None,
lc_collate=None,
lc_ctype=None,
owner=None,
template=None,
runas=None):
'''
Adds a databases to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_create 'dbname'
salt '*' postgres.db_create 'dbname' template=template_postgis
'''
# Base query to create a database
query = 'CREATE DATABASE "{0}"'.format(name)
# "With"-options to create a database
with_args = salt.utils.odict.OrderedDict([
('TABLESPACE', _quote_ddl_value(tablespace, '"')),
# owner needs to be enclosed in double quotes so postgres
# doesn't get thrown by dashes in the name
('OWNER', _quote_ddl_value(owner, '"')),
('TEMPLATE', template),
('ENCODING', _quote_ddl_value(encoding)),
('LC_COLLATE', _quote_ddl_value(lc_collate)),
('LC_CTYPE', _quote_ddl_value(lc_ctype)),
])
with_chunks = []
for key, value in with_args.items():
if value is not None:
with_chunks += [key, '=', value]
# Build a final query
if with_chunks:
with_chunks.insert(0, ' WITH')
query += ' '.join(with_chunks)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def db_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, tablespace=None, owner=None, owner_recurse=False,
runas=None):
'''
Change tablespace or/and owner of database.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_alter dbname owner=otheruser
'''
if not any((tablespace, owner)):
return True # Nothing todo?
if owner and owner_recurse:
ret = owner_to(name, owner,
user=user,
host=host,
port=port,
password=password,
runas=runas)
else:
queries = []
if owner:
queries.append('ALTER DATABASE "{0}" OWNER TO "{1}"'.format(
name, owner
))
if tablespace:
queries.append('ALTER DATABASE "{0}" SET TABLESPACE "{1}"'.format(
name, tablespace
))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def db_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a databases from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.db_remove 'dbname'
'''
# db doesn't exist, proceed
query = 'DROP DATABASE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# Tablespace related actions
def tablespace_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Return dictionary with information about tablespaces of a Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_list
.. versionadded:: 2015.8.0
'''
ret = {}
query = (
'SELECT spcname as "Name", pga.rolname as "Owner", spcacl as "ACL", '
'spcoptions as "Opts", pg_tablespace_location(pgts.oid) as "Location" '
'FROM pg_tablespace pgts, pg_roles pga WHERE pga.oid = pgts.spcowner'
)
rows = __salt__['postgres.psql_query'](query, runas=runas, host=host,
user=user, port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row
ret[row['Name']].pop('Name')
return ret
def tablespace_exists(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Checks if a tablespace exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_exists 'dbname'
.. versionadded:: 2015.8.0
'''
tablespaces = tablespace_list(user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return name in tablespaces
def tablespace_create(name, location, options=None, owner=None, user=None,
host=None, port=None, maintenance_db=None, password=None,
runas=None):
'''
Adds a tablespace to the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_create tablespacename '/path/datadir'
.. versionadded:: 2015.8.0
'''
owner_query = ''
options_query = ''
if owner:
owner_query = 'OWNER "{0}"'.format(owner)
# should come out looking like: 'OWNER postgres'
if options:
optionstext = ['{0} = {1}'.format(k, v) for k, v in six.iteritems(options)]
options_query = 'WITH ( {0} )'.format(', '.join(optionstext))
# should come out looking like: 'WITH ( opt1 = 1.0, opt2 = 4.0 )'
query = 'CREATE TABLESPACE "{0}" {1} LOCATION \'{2}\' {3}'.format(name,
owner_query,
location,
options_query)
# Execute the command
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
return ret['retcode'] == 0
def tablespace_alter(name, user=None, host=None, port=None, maintenance_db=None,
password=None, new_name=None, new_owner=None,
set_option=None, reset_option=None, runas=None):
'''
Change tablespace name, owner, or options.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_alter tsname new_owner=otheruser
salt '*' postgres.tablespace_alter index_space new_name=fast_raid
salt '*' postgres.tablespace_alter test set_option="{'seq_page_cost': '1.1'}"
salt '*' postgres.tablespace_alter tsname reset_option=seq_page_cost
.. versionadded:: 2015.8.0
'''
if not any([new_name, new_owner, set_option, reset_option]):
return True # Nothing todo?
queries = []
if new_name:
queries.append('ALTER TABLESPACE "{0}" RENAME TO "{1}"'.format(
name, new_name))
if new_owner:
queries.append('ALTER TABLESPACE "{0}" OWNER TO "{1}"'.format(
name, new_owner))
if set_option:
queries.append('ALTER TABLESPACE "{0}" SET ({1} = {2})'.format(
name, set_option.keys()[0], set_option.values()[0]))
if reset_option:
queries.append('ALTER TABLESPACE "{0}" RESET ({1})'.format(
name, reset_option))
for query in queries:
ret = _psql_prepare_and_run(['-c', query],
user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
if ret['retcode'] != 0:
return False
return True
def tablespace_remove(name, user=None, host=None, port=None,
maintenance_db=None, password=None, runas=None):
'''
Removes a tablespace from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.tablespace_remove tsname
.. versionadded:: 2015.8.0
'''
query = 'DROP TABLESPACE "{0}"'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
# User related actions
def user_list(user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_list
'''
ret = {}
ver = _parsed_version(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if ver:
if ver >= _LooseVersion('9.1'):
replication_column = 'pg_roles.rolreplication'
else:
replication_column = 'NULL'
if ver >= _LooseVersion('9.5'):
rolcatupdate_column = 'NULL'
else:
rolcatupdate_column = 'pg_roles.rolcatupdate'
else:
log.error('Could not retrieve Postgres version. Is Postgresql server running?')
return False
# will return empty string if return_password = False
_x = lambda s: s if return_password else ''
query = (''.join([
'SELECT '
'pg_roles.rolname as "name",'
'pg_roles.rolsuper as "superuser", '
'pg_roles.rolinherit as "inherits privileges", '
'pg_roles.rolcreaterole as "can create roles", '
'pg_roles.rolcreatedb as "can create databases", '
'{0} as "can update system catalogs", '
'pg_roles.rolcanlogin as "can login", '
'{1} as "replication", '
'pg_roles.rolconnlimit as "connections", '
'(SELECT array_agg(pg_roles2.rolname)'
' FROM pg_catalog.pg_auth_members'
' JOIN pg_catalog.pg_roles pg_roles2 ON (pg_auth_members.roleid = pg_roles2.oid)'
' WHERE pg_auth_members.member = pg_roles.oid) as "groups",'
'pg_roles.rolvaliduntil::timestamp(0) as "expiry time", '
'pg_roles.rolconfig as "defaults variables" '
, _x(', COALESCE(pg_shadow.passwd, pg_authid.rolpassword) as "password" '),
'FROM pg_roles '
, _x('LEFT JOIN pg_authid ON pg_roles.oid = pg_authid.oid ')
, _x('LEFT JOIN pg_shadow ON pg_roles.oid = pg_shadow.usesysid')
]).format(rolcatupdate_column, replication_column))
rows = psql_query(query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
def get_bool(rowdict, key):
'''
Returns the boolean value of the key, instead of 't' and 'f' strings.
'''
if rowdict[key] == 't':
return True
elif rowdict[key] == 'f':
return False
else:
return None
for row in rows:
retrow = {}
for key in ('superuser', 'inherits privileges', 'can create roles',
'can create databases', 'can update system catalogs',
'can login', 'replication', 'connections'):
retrow[key] = get_bool(row, key)
for date_key in ('expiry time',):
try:
retrow[date_key] = datetime.datetime.strptime(
row[date_key], '%Y-%m-%d %H:%M:%S')
except ValueError:
retrow[date_key] = None
retrow['defaults variables'] = row['defaults variables']
if return_password:
retrow['password'] = row['password']
# use csv reader to handle quoted roles correctly
retrow['groups'] = list(csv.reader([row['groups'].strip('{}')]))[0]
ret[row['name']] = retrow
return ret
def role_get(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None, return_password=False):
'''
Return a dict with information about users of a Postgres server.
Set return_password to True to get password hash in the result.
CLI Example:
.. code-block:: bash
salt '*' postgres.role_get postgres
'''
all_users = user_list(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=return_password)
try:
return all_users.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres role. Is Postgres running?')
return None
def user_exists(name,
user=None, host=None, port=None, maintenance_db=None,
password=None,
runas=None):
'''
Checks if a user exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_exists 'username'
'''
return bool(
role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False))
def _add_role_flag(string,
test,
flag,
cond=None,
prefix='NO',
addtxt='',
skip=False):
if not skip:
if cond is None:
cond = test
if test is not None:
if cond:
string = '{0} {1}'.format(string, flag)
else:
string = '{0} {2}{1}'.format(string, flag, prefix)
if addtxt:
string = '{0} {1}'.format(string, addtxt)
return string
def _maybe_encrypt_password(role,
password,
encrypted=_DEFAULT_PASSWORDS_ENCRYPTION):
'''
pgsql passwords are md5 hashes of the string: 'md5{password}{rolename}'
'''
if password is not None:
password = six.text_type(password)
if encrypted and password and not password.startswith('md5'):
password = "md5{0}".format(
hashlib.md5(salt.utils.stringutils.to_bytes('{0}{1}'.format(password, role))).hexdigest())
return password
def _role_cmd_args(name,
sub_cmd='',
typ_='role',
encrypted=None,
login=None,
connlimit=None,
inherit=None,
createdb=None,
createroles=None,
superuser=None,
groups=None,
replication=None,
rolepassword=None,
valid_until=None,
db_role=None):
if inherit is None:
if typ_ in ['user', 'group']:
inherit = True
if login is None:
if typ_ == 'user':
login = True
if typ_ == 'group':
login = False
# defaults to encrypted passwords (md5{password}{rolename})
if encrypted is None:
encrypted = _DEFAULT_PASSWORDS_ENCRYPTION
skip_passwd = False
escaped_password = ''
escaped_valid_until = ''
if not (
rolepassword is not None
# first is passwd set
# second is for handling NOPASSWD
and (
isinstance(rolepassword, six.string_types) and bool(rolepassword)
)
or (
isinstance(rolepassword, bool)
)
):
skip_passwd = True
if isinstance(rolepassword, six.string_types) and bool(rolepassword):
escaped_password = '\'{0}\''.format(
_maybe_encrypt_password(name,
rolepassword.replace('\'', '\'\''),
encrypted=encrypted))
if isinstance(valid_until, six.string_types) and bool(valid_until):
escaped_valid_until = '\'{0}\''.format(
valid_until.replace('\'', '\'\''),
)
skip_superuser = False
if bool(db_role) and bool(superuser) == bool(db_role['superuser']):
skip_superuser = True
flags = (
{'flag': 'INHERIT', 'test': inherit},
{'flag': 'CREATEDB', 'test': createdb},
{'flag': 'CREATEROLE', 'test': createroles},
{'flag': 'SUPERUSER', 'test': superuser,
'skip': skip_superuser},
{'flag': 'REPLICATION', 'test': replication},
{'flag': 'LOGIN', 'test': login},
{'flag': 'CONNECTION LIMIT',
'test': bool(connlimit),
'addtxt': six.text_type(connlimit),
'skip': connlimit is None},
{'flag': 'ENCRYPTED',
'test': (encrypted is not None and bool(rolepassword)),
'skip': skip_passwd or isinstance(rolepassword, bool),
'cond': encrypted,
'prefix': 'UN'},
{'flag': 'PASSWORD', 'test': bool(rolepassword),
'skip': skip_passwd,
'addtxt': escaped_password},
{'flag': 'VALID UNTIL',
'test': bool(valid_until),
'skip': valid_until is None,
'addtxt': escaped_valid_until},
)
for data in flags:
sub_cmd = _add_role_flag(sub_cmd, **data)
if sub_cmd.endswith('WITH'):
sub_cmd = sub_cmd.replace(' WITH', '')
if groups:
if isinstance(groups, list):
groups = ','.join(groups)
for group in groups.split(','):
sub_cmd = '{0}; GRANT "{1}" TO "{2}"'.format(sub_cmd, group, name)
return sub_cmd
def _role_create(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
login=None,
connlimit=None,
inherit=None,
replication=None,
rolepassword=None,
valid_until=None,
typ_='role',
groups=None,
runas=None):
'''
Creates a Postgres role. Users and Groups are both roles in postgres.
However, users can login, groups cannot.
'''
# check if role exists
if user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('%s \'%s\' already exists', typ_.capitalize(), name)
return False
sub_cmd = 'CREATE ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
typ_=typ_,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_create(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Creates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_create 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_create(username,
typ_='user',
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
inherit=inherit,
login=login,
connlimit=connlimit,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_update(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
typ_='role',
createroles=None,
inherit=None,
login=None,
connlimit=None,
encrypted=None,
superuser=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a postgres role.
'''
role = role_get(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas,
return_password=False)
# check if user exists
if not bool(role):
log.info(
'%s \'%s\' could not be found', typ_.capitalize(), name
)
return False
sub_cmd = 'ALTER ROLE "{0}" WITH'.format(name)
sub_cmd = '{0} {1}'.format(sub_cmd, _role_cmd_args(
name,
encrypted=encrypted,
login=login,
connlimit=connlimit,
inherit=inherit,
createdb=createdb,
createroles=createroles,
superuser=superuser,
groups=groups,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
db_role=role
))
ret = _psql_prepare_and_run(['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def user_update(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
superuser=None,
inherit=None,
login=None,
connlimit=None,
replication=None,
rolepassword=None,
valid_until=None,
groups=None,
runas=None):
'''
Updates a Postgres user.
CLI Examples:
.. code-block:: bash
salt '*' postgres.user_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword' valid_until='valid_until'
'''
return _role_update(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
typ_='user',
inherit=inherit,
login=login,
connlimit=connlimit,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
valid_until=valid_until,
groups=groups,
runas=runas)
def _role_remove(name, user=None, host=None, port=None, maintenance_db=None,
password=None, runas=None):
'''
Removes a role from the Postgres Server
'''
# check if user exists
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
log.info('User \'%s\' does not exist', name)
return False
# user exists, proceed
sub_cmd = 'DROP ROLE "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
if not user_exists(name, user, host, port, maintenance_db,
password=password, runas=runas):
return True
else:
log.info('Failed to delete user \'%s\'.', name)
return False
def available_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List available postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.available_extensions
'''
exts = []
query = (
'select * '
'from pg_available_extensions();'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'default_version' in row and 'name' in row:
exts[row['name']] = row
return exts
def installed_extensions(user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
List installed postgresql extensions
CLI Example:
.. code-block:: bash
salt '*' postgres.installed_extensions
'''
exts = []
query = (
'select a.*, b.nspname as schema_name '
'from pg_extension a, pg_namespace b where a.extnamespace = b.oid;'
)
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=maintenance_db,
password=password, runas=runas)
exts = {}
for row in ret:
if 'extversion' in row and 'extname' in row:
exts[row['extname']] = row
return exts
def get_available_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an available postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_available_extension plpgsql
'''
return available_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def get_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get info about an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.get_installed_extension plpgsql
'''
return installed_extensions(user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas).get(name, None)
def _pg_is_older_ext_ver(a, b):
'''
Compare versions of extensions using salt.utils.versions.LooseVersion.
Returns ``True`` if version a is lesser than b.
'''
return _LooseVersion(a) < _LooseVersion(b)
def is_installed_extension(name,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Test if a specific extension is installed
CLI Example:
.. code-block:: bash
salt '*' postgres.is_installed_extension
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return bool(installed_ext)
def create_metadata(name,
ext_version=None,
schema=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Get lifecycle information about an extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_metadata adminpack
'''
installed_ext = get_installed_extension(
name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = [_EXTENSION_NOT_INSTALLED]
if installed_ext:
ret = [_EXTENSION_INSTALLED]
if (
ext_version is not None
and _pg_is_older_ext_ver(
installed_ext.get('extversion', ext_version),
ext_version
)
):
ret.append(_EXTENSION_TO_UPGRADE)
if (
schema is not None
and installed_ext.get('extrelocatable', 'f') == 't'
and installed_ext.get('schema_name', schema) != schema
):
ret.append(_EXTENSION_TO_MOVE)
return ret
def drop_extension(name,
if_exists=None,
restrict=None,
cascade=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Drop an installed postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.drop_extension 'adminpack'
'''
if cascade is None:
cascade = True
if if_exists is None:
if_exists = False
if restrict is None:
restrict = False
args = ['DROP EXTENSION']
if if_exists:
args.append('IF EXISTS')
args.append(name)
if cascade:
args.append('CASCADE')
if restrict:
args.append('RESTRICT')
args.append(';')
cmd = ' '.join(args)
if is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas):
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
ret = not is_installed_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if not ret:
log.info('Failed to drop ext: %s', name)
return ret
def create_extension(name,
if_not_exists=None,
schema=None,
ext_version=None,
from_version=None,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Install a postgresql extension
CLI Example:
.. code-block:: bash
salt '*' postgres.create_extension 'adminpack'
'''
if if_not_exists is None:
if_not_exists = True
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
installed = _EXTENSION_NOT_INSTALLED not in mtdata
installable = is_available_extension(name,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
if installable:
if not installed:
args = ['CREATE EXTENSION']
if if_not_exists:
args.append('IF NOT EXISTS')
args.append('"{0}"'.format(name))
sargs = []
if schema:
sargs.append('SCHEMA "{0}"'.format(schema))
if ext_version:
sargs.append('VERSION {0}'.format(ext_version))
if from_version:
sargs.append('FROM {0}'.format(from_version))
if sargs:
args.append('WITH')
args.extend(sargs)
args.append(';')
cmd = ' '.join(args).strip()
else:
args = []
if schema and _EXTENSION_TO_MOVE in mtdata:
args.append('ALTER EXTENSION "{0}" SET SCHEMA "{1}";'.format(
name, schema))
if ext_version and _EXTENSION_TO_UPGRADE in mtdata:
args.append('ALTER EXTENSION "{0}" UPDATE TO {1};'.format(
name, ext_version))
cmd = ' '.join(args).strip()
if cmd:
_psql_prepare_and_run(
['-c', cmd],
runas=runas, host=host, user=user, port=port,
maintenance_db=maintenance_db, password=password)
mtdata = create_metadata(name,
ext_version=ext_version,
schema=schema,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
ret = True
for i in _EXTENSION_FLAGS:
if (i in mtdata) and (i != _EXTENSION_INSTALLED):
ret = False
if not ret:
log.info('Failed to create ext: %s', name)
return ret
def user_remove(username,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a user from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.user_remove 'username'
'''
return _role_remove(username,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
# Group related actions
def group_create(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
login=None,
inherit=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Creates a Postgres group. A group is postgres is similar to a user, but
cannot login.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_create 'groupname' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_create(groupname,
user=user,
typ_='group',
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_update(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
createdb=None,
createroles=None,
encrypted=None,
inherit=None,
login=None,
superuser=None,
replication=None,
rolepassword=None,
groups=None,
runas=None):
'''
Updates a postgres group
CLI Examples:
.. code-block:: bash
salt '*' postgres.group_update 'username' user='user' \\
host='hostname' port='port' password='password' \\
rolepassword='rolepassword'
'''
return _role_update(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
createdb=createdb,
typ_='group',
createroles=createroles,
encrypted=encrypted,
login=login,
inherit=inherit,
superuser=superuser,
replication=replication,
rolepassword=rolepassword,
groups=groups,
runas=runas)
def group_remove(groupname,
user=None,
host=None,
port=None,
maintenance_db=None,
password=None,
runas=None):
'''
Removes a group from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.group_remove 'groupname'
'''
return _role_remove(groupname,
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
def owner_to(dbname,
ownername,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Set the owner of all schemas, functions, tables, views and sequences to
the given username.
CLI Example:
.. code-block:: bash
salt '*' postgres.owner_to 'dbname' 'username'
'''
sqlfile = tempfile.NamedTemporaryFile()
sqlfile.write('begin;\n')
sqlfile.write(
'alter database "{0}" owner to "{1}";\n'.format(
dbname, ownername
)
)
queries = (
# schemas
('alter schema {n} owner to {owner};',
'select quote_ident(schema_name) as n from '
'information_schema.schemata;'),
# tables and views
('alter table {n} owner to {owner};',
'select quote_ident(table_schema)||\'.\'||quote_ident(table_name) as '
'n from information_schema.tables where table_schema not in '
'(\'pg_catalog\', \'information_schema\');'),
# functions
('alter function {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
' and not p.proisagg;'),
# aggregate functions
('alter aggregate {n} owner to {owner};',
'select p.oid::regprocedure::text as n from pg_catalog.pg_proc p '
'join pg_catalog.pg_namespace ns on p.pronamespace=ns.oid where '
'ns.nspname not in (\'pg_catalog\', \'information_schema\') '
'and p.proisagg;'),
# sequences
('alter sequence {n} owner to {owner};',
'select quote_ident(sequence_schema)||\'.\'||'
'quote_ident(sequence_name) as n from information_schema.sequences;')
)
for fmt, query in queries:
ret = psql_query(query, user=user, host=host, port=port,
maintenance_db=dbname, password=password, runas=runas)
for row in ret:
sqlfile.write(fmt.format(owner=ownername, n=row['n']) + '\n')
sqlfile.write('commit;\n')
sqlfile.flush()
os.chmod(sqlfile.name, 0o644) # ensure psql can read the file
# run the generated sqlfile in the db
cmdret = _psql_prepare_and_run(['-f', sqlfile.name],
user=user,
runas=runas,
host=host,
port=port,
password=password,
maintenance_db=dbname)
return cmdret
# Schema related actions
def schema_create(dbname, name, owner=None,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Creates a Postgres schema.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_create dbname name owner='owner' \\
user='user' \\
db_user='user' db_password='password'
db_host='hostname' db_port='port'
'''
# check if schema exists
if schema_exists(dbname, name, user=user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('\'%s\' already exists in \'%s\'', name, dbname)
return False
sub_cmd = 'CREATE SCHEMA "{0}"'.format(name)
if owner is not None:
sub_cmd = '{0} AUTHORIZATION "{1}"'.format(sub_cmd, owner)
ret = _psql_prepare_and_run(['-c', sub_cmd],
user=db_user, password=db_password,
port=db_port, host=db_host,
maintenance_db=dbname, runas=user)
return ret['retcode'] == 0
def schema_remove(dbname, name,
user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Removes a schema from the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_remove dbname schemaname
dbname
Database name we work on
schemaname
The schema's name we'll remove
user
System user all operations should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
# check if schema exists
if not schema_exists(dbname, name, user=None,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
log.info('Schema \'%s\' does not exist in \'%s\'', name, dbname)
return False
# schema exists, proceed
sub_cmd = 'DROP SCHEMA "{0}"'.format(name)
_psql_prepare_and_run(
['-c', sub_cmd],
runas=user,
maintenance_db=dbname,
host=db_host, user=db_user, port=db_port, password=db_password)
if not schema_exists(dbname, name, user,
db_user=db_user, db_password=db_password,
db_host=db_host, db_port=db_port):
return True
else:
log.info('Failed to delete schema \'%s\'.', name)
return False
def schema_exists(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Checks if a schema exists on the Postgres server.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_exists dbname schemaname
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
return bool(
schema_get(dbname, name, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password))
def schema_get(dbname, name, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_get dbname name
dbname
Database name we query on
name
Schema name we look for
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
all_schemas = schema_list(dbname, user=user,
db_user=db_user,
db_host=db_host,
db_port=db_port,
db_password=db_password)
try:
return all_schemas.get(name, None)
except AttributeError:
log.error('Could not retrieve Postgres schema. Is Postgres running?')
return False
def schema_list(dbname, user=None,
db_user=None, db_password=None,
db_host=None, db_port=None):
'''
Return a dict with information about schemas in a Postgres database.
CLI Example:
.. code-block:: bash
salt '*' postgres.schema_list dbname
dbname
Database name we query on
user
The system user the operation should be performed on behalf of
db_user
database username if different from config or default
db_password
user password if any password for a specified user
db_host
Database host if different from config or default
db_port
Database port if different from config or default
'''
ret = {}
query = (''.join([
'SELECT '
'pg_namespace.nspname as "name",'
'pg_namespace.nspacl as "acl", '
'pg_roles.rolname as "owner" '
'FROM pg_namespace '
'LEFT JOIN pg_roles ON pg_roles.oid = pg_namespace.nspowner '
]))
rows = psql_query(query, runas=user,
host=db_host,
user=db_user,
port=db_port,
maintenance_db=dbname,
password=db_password)
for row in rows:
retrow = {}
for key in ('owner', 'acl'):
retrow[key] = row[key]
ret[row['name']] = retrow
return ret
def language_list(
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of languages in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_list dbname
maintenance_db
The database to check
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
ret = {}
query = 'SELECT lanname AS "Name" FROM pg_language'
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
for row in rows:
ret[row['Name']] = row['Name']
return ret
def language_exists(
name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Checks if language exists in a database.
CLI Example:
.. code-block:: bash
salt '*' postgres.language_exists plpgsql dbname
name
Language to check for
maintenance_db
The database to check in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
languages = language_list(
maintenance_db, user=user, host=host,
port=port, password=password,
runas=runas)
return name in languages
def language_create(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Installs a language into a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_create plpgsql dbname
name
Language to install
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if language_exists(name, maintenance_db):
log.info('Language %s already exists in %s', name, maintenance_db)
return False
query = 'CREATE LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def language_remove(name,
maintenance_db,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Removes a language from a database
CLI Example:
.. code-block:: bash
salt '*' postgres.language_remove plpgsql dbname
name
Language to remove
maintenance_db
The database to install the language in
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
if not language_exists(name, maintenance_db):
log.info('Language %s does not exist in %s', name, maintenance_db)
return False
query = 'DROP LANGUAGE {0}'.format(name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
runas=runas,
maintenance_db=maintenance_db,
password=password)
return ret['retcode'] == 0
def _make_default_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='r'",
'ORDER BY nspname',
])).format(prepend)
elif object_type == 'sequence':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='S'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT defacl.defaclacl AS name',
'FROM pg_default_acl defacl',
'JOIN pg_authid aid',
'ON defacl.defaclrole = aid.oid ',
'JOIN pg_namespace nsp ',
'ON nsp.oid = defacl.defaclnamespace',
"WHERE nsp.nspname = '{0}'",
"AND defaclobjtype ='f'",
'ORDER BY nspname',
])).format(prepend, name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _make_privileges_list_query(name, object_type, prepend):
'''
Generate the SQL required for specific object type
'''
if object_type == 'table':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'r'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT relacl AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE nspname = '{0}'",
"AND relname = '{1}'",
"AND relkind = 'S'",
'ORDER BY relname',
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT nspacl AS name',
'FROM pg_catalog.pg_namespace',
"WHERE nspname = '{0}'",
'ORDER BY nspname',
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proacl AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT spcacl AS name',
'FROM pg_catalog.pg_tablespace',
"WHERE spcname = '{0}'",
'ORDER BY spcname',
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT lanacl AS name',
'FROM pg_catalog.pg_language',
"WHERE lanname = '{0}'",
'ORDER BY lanname',
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT datacl AS name',
'FROM pg_catalog.pg_database',
"WHERE datname = '{0}'",
'ORDER BY datname',
])).format(name)
elif object_type == 'group':
query = (' '.join([
'SELECT rolname, admin_option',
'FROM pg_catalog.pg_auth_members m',
'JOIN pg_catalog.pg_roles r',
'ON m.member=r.oid',
'WHERE m.roleid IN',
'(SELECT oid',
'FROM pg_catalog.pg_roles',
"WHERE rolname='{0}')",
'ORDER BY rolname',
])).format(name)
return query
def _get_object_owner(name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
Return the owner of a postgres object
'''
if object_type == 'table':
query = (' '.join([
'SELECT tableowner AS name',
'FROM pg_tables',
"WHERE schemaname = '{0}'",
"AND tablename = '{1}'"
])).format(prepend, name)
elif object_type == 'sequence':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_catalog.pg_class c',
'JOIN pg_roles r',
'ON c.relowner = r.oid',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = c.relnamespace',
"WHERE relkind='S'",
"AND nspname='{0}'",
"AND relname = '{1}'",
])).format(prepend, name)
elif object_type == 'schema':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_namespace n',
'JOIN pg_roles r',
'ON n.nspowner = r.oid',
"WHERE nspname = '{0}'",
])).format(name)
elif object_type == 'function':
query = (' '.join([
'SELECT proname AS name',
'FROM pg_catalog.pg_proc p',
'JOIN pg_catalog.pg_namespace n',
'ON n.oid = p.pronamespace',
"WHERE nspname = '{0}'",
"AND p.oid::regprocedure::text = '{1}'",
'ORDER BY proname, proargtypes',
])).format(prepend, name)
elif object_type == 'tablespace':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_tablespace t',
'JOIN pg_roles r',
'ON t.spcowner = r.oid',
"WHERE spcname = '{0}'",
])).format(name)
elif object_type == 'language':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_language l',
'JOIN pg_roles r',
'ON l.lanowner = r.oid',
"WHERE lanname = '{0}'",
])).format(name)
elif object_type == 'database':
query = (' '.join([
'SELECT rolname AS name',
'FROM pg_database d',
'JOIN pg_roles r',
'ON d.datdba = r.oid',
"WHERE datname = '{0}'",
])).format(name)
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
try:
ret = rows[0]['name']
except IndexError:
ret = None
return ret
def _validate_default_privileges(object_type, defprivs, defprivileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_defperms = [_DEFAULT_PRIVILEGES_MAP[defperm]
for defperm in _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]]
_defperms.append('ALL')
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(defprivs).issubset(set(_defperms)):
raise SaltInvocationError(
'Invalid default privilege(s): {0} provided for object {1}'.format(
defprivileges, object_type))
else:
if defprivileges:
raise SaltInvocationError(
'The default privileges option should not '
'be set for object_type group')
def _mod_defpriv_opts(object_type, defprivileges):
'''
Format options
'''
object_type = object_type.lower()
defprivileges = '' if defprivileges is None else defprivileges
_defprivs = re.split(r'\s?,\s?', defprivileges.upper())
return object_type, defprivileges, _defprivs
def _process_defpriv_part(defperms):
'''
Process part
'''
_tmp = {}
previous = None
for defperm in defperms:
if previous is None:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
else:
if defperm == '*':
_tmp[previous] = True
else:
_tmp[_DEFAULT_PRIVILEGES_MAP[defperm]] = False
previous = _DEFAULT_PRIVILEGES_MAP[defperm]
return _tmp
def _validate_privileges(object_type, privs, privileges):
'''
Validate the supplied privileges
'''
if object_type != 'group':
_perms = [_PRIVILEGES_MAP[perm]
for perm in _PRIVILEGE_TYPE_MAP[object_type]]
_perms.append('ALL')
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
if not set(privs).issubset(set(_perms)):
raise SaltInvocationError(
'Invalid privilege(s): {0} provided for object {1}'.format(
privileges, object_type))
else:
if privileges:
raise SaltInvocationError(
'The privileges option should not '
'be set for object_type group')
def _mod_priv_opts(object_type, privileges):
'''
Format options
'''
object_type = object_type.lower()
privileges = '' if privileges is None else privileges
_privs = re.split(r'\s?,\s?', privileges.upper())
return object_type, privileges, _privs
def _process_priv_part(perms):
'''
Process part
'''
_tmp = {}
previous = None
for perm in perms:
if previous is None:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
else:
if perm == '*':
_tmp[previous] = True
else:
_tmp[_PRIVILEGES_MAP[perm]] = False
previous = _PRIVILEGES_MAP[perm]
return _tmp
def default_privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Return a list of default privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_default_privileges_list_query(name, object_type, prepend)
if object_type not in _DEFAULT_PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, defperms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_defpriv_part(defperms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def privileges_list(
name,
object_type,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Return a list of privileges for the specified object.
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_list table_name table maintenance_db=db_name
name
Name of the object for which the permissions should be returned
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type = object_type.lower()
query = _make_privileges_list_query(name, object_type, prepend)
if object_type not in _PRIVILEGES_OBJECTS:
raise SaltInvocationError(
'Invalid object_type: {0} provided'.format(object_type))
rows = psql_query(
query,
runas=runas,
host=host,
user=user,
port=port,
maintenance_db=maintenance_db,
password=password)
ret = {}
for row in rows:
if object_type != 'group':
result = row['name']
result = result.strip('{}')
parts = result.split(',')
for part in parts:
perms_part, _ = part.split('/')
rolename, perms = perms_part.split('=')
if rolename == '':
rolename = 'public'
_tmp = _process_priv_part(perms)
ret[rolename] = _tmp
else:
if row['admin_option'] == 't':
admin_option = True
else:
admin_option = False
ret[row['rolname']] = admin_option
return ret
def has_default_privileges(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_default_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_defprivileges = default_privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _defprivileges:
if object_type == 'group':
if grant_option:
retval = _defprivileges[name]
else:
retval = True
return retval
else:
_defperms = _DEFAULT_PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
defperms = dict((_DEFAULT_PRIVILEGES_MAP[defperm], True) for defperm in _defperms)
retval = defperms == _defprivileges[name]
else:
defperms = [_DEFAULT_PRIVILEGES_MAP[defperm] for defperm in _defperms]
if 'ALL' in _defprivs:
retval = sorted(defperms) == sorted(_defprivileges[name].keys())
else:
retval = set(_defprivs).issubset(
set(_defprivileges[name].keys()))
return retval
return False
def has_privileges(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Check if a role has the specified privileges on an object
CLI Example:
.. code-block:: bash
salt '*' postgres.has_privileges user_name table_name table \\
SELECT,INSERT maintenance_db=db_name
name
Name of the role whose privileges should be checked on object_type
object_name
Name of the object on which the check is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to check, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the grant option check is performed
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if object_type != 'group':
owner = _get_object_owner(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if owner is not None and name == owner:
return True
_privileges = privileges_list(object_name, object_type, prepend=prepend,
maintenance_db=maintenance_db, user=user, host=host, port=port,
password=password, runas=runas)
if name in _privileges:
if object_type == 'group':
if grant_option:
retval = _privileges[name]
else:
retval = True
return retval
else:
_perms = _PRIVILEGE_TYPE_MAP[object_type]
if grant_option:
perms = dict((_PRIVILEGES_MAP[perm], True) for perm in _perms)
retval = perms == _privileges[name]
else:
perms = [_PRIVILEGES_MAP[perm] for perm in _perms]
if 'ALL' in _privs:
retval = sorted(perms) == sorted(_privileges[name].keys())
else:
retval = set(_privs).issubset(
set(_privileges[name].keys()))
return retval
return False
def default_privileges_grant(name,
object_name,
object_type,
defprivileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Grant default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which default privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the default privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, pdefrivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has default privileges: %s set',
object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = ' ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence', 'function') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = ' ALTER DEFAULT PRIVILEGES IN SCHEMA {2} GRANT {0} ON {1}S TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def default_privileges_revoke(name,
object_name,
object_type,
defprivileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2019.0.0
Revoke default privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.default_privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose default privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- TRIGGER
- SELECT
- USAGE
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, defprivileges, _defprivs = _mod_defpriv_opts(object_type, defprivileges)
_validate_default_privileges(object_type, _defprivs, defprivileges)
if not has_default_privileges(name, object_name, object_type, defprivileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have default privileges: %s set', object_name, object_type, defprivileges)
return False
_grants = ','.join(_defprivs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'ALTER DEFAULT PRIVILEGES REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'ALTER DEFAULT PRIVILEGES IN SCHEMA {2} REVOKE {0} ON {1}S FROM {3}'.format(
_grants, object_type.upper(), prepend, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_grant(name,
object_name,
object_type,
privileges=None,
grant_option=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Grant privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_grant user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role to which privileges should be granted
object_name
Name of the object on which the grant is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to grant, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
grant_option
If grant_option is set to True, the recipient of the privilege can
in turn grant it to others
prepend
Table and Sequence object types live under a schema so this should be
provided if the object is not under the default `public` schema
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s already has privileges: %s set',
object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}."{1}"'.format(prepend, object_name)
elif object_type == 'function':
on_part = '{0}'.format(object_name)
else:
on_part = '"{0}"'.format(object_name)
if grant_option:
if object_type == 'group':
query = 'GRANT {0} TO "{1}" WITH ADMIN OPTION'.format(
object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO ' \
'"{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}" WITH GRANT OPTION'.format(
_grants, object_type.upper(), on_part, name)
else:
if object_type == 'group':
query = 'GRANT {0} TO "{1}"'.format(object_name, name)
elif (object_type in ('table', 'sequence') and
object_name.upper() == 'ALL'):
query = 'GRANT {0} ON ALL {1}S IN SCHEMA {2} TO "{3}"'.format(
_grants, object_type.upper(), prepend, name)
else:
query = 'GRANT {0} ON {1} {2} TO "{3}"'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def privileges_revoke(name,
object_name,
object_type,
privileges=None,
prepend='public',
maintenance_db=None,
user=None,
host=None,
port=None,
password=None,
runas=None):
'''
.. versionadded:: 2016.3.0
Revoke privileges on a postgres object
CLI Example:
.. code-block:: bash
salt '*' postgres.privileges_revoke user_name table_name table \\
SELECT,UPDATE maintenance_db=db_name
name
Name of the role whose privileges should be revoked
object_name
Name of the object on which the revoke is to be performed
object_type
The object type, which can be one of the following:
- table
- sequence
- schema
- tablespace
- language
- database
- group
- function
privileges
Comma separated list of privileges to revoke, from the list below:
- INSERT
- CREATE
- TRUNCATE
- CONNECT
- TRIGGER
- SELECT
- USAGE
- TEMPORARY
- UPDATE
- EXECUTE
- REFERENCES
- DELETE
- ALL
maintenance_db
The database to connect to
user
database username if different from config or default
password
user password if any password for a specified user
host
Database host if different from config or default
port
Database port if different from config or default
runas
System user all operations should be performed on behalf of
'''
object_type, privileges, _privs = _mod_priv_opts(object_type, privileges)
_validate_privileges(object_type, _privs, privileges)
if not has_privileges(name, object_name, object_type, privileges,
prepend=prepend, maintenance_db=maintenance_db, user=user,
host=host, port=port, password=password, runas=runas):
log.info('The object: %s of type: %s does not'
' have privileges: %s set', object_name, object_type, privileges)
return False
_grants = ','.join(_privs)
if object_type in ['table', 'sequence']:
on_part = '{0}.{1}'.format(prepend, object_name)
else:
on_part = object_name
if object_type == 'group':
query = 'REVOKE {0} FROM {1}'.format(object_name, name)
else:
query = 'REVOKE {0} ON {1} {2} FROM {3}'.format(
_grants, object_type.upper(), on_part, name)
ret = _psql_prepare_and_run(['-c', query],
user=user,
host=host,
port=port,
maintenance_db=maintenance_db,
password=password,
runas=runas)
return ret['retcode'] == 0
def datadir_init(name,
auth='password',
user=None,
password=None,
encoding='UTF8',
locale=None,
waldir=None,
checksums=False,
runas=None):
'''
.. versionadded:: 2016.3.0
Initializes a postgres data directory
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_init '/var/lib/pgsql/data'
name
The name of the directory to initialize
auth
The default authentication method for local connections
password
The password to set for the postgres user
user
The database superuser name
encoding
The default encoding for new databases
locale
The default locale for new databases
waldir
The transaction log (WAL) directory (default is to keep WAL
inside the data directory)
.. versionadded:: 2019.2.0
checksums
If True, the cluster will be created with data page checksums.
.. note:: Data page checksums are supported since PostgreSQL 9.3.
.. versionadded:: 2019.2.0
runas
The system user the operation should be performed on behalf of
'''
if datadir_exists(name):
log.info('%s already exists', name)
return False
ret = _run_initdb(
name,
auth=auth,
user=user,
password=password,
encoding=encoding,
locale=locale,
runas=runas)
return ret['retcode'] == 0
def datadir_exists(name):
'''
.. versionadded:: 2016.3.0
Checks if postgres data directory has been initialized
CLI Example:
.. code-block:: bash
salt '*' postgres.datadir_exists '/var/lib/pgsql/data'
name
Name of the directory to check
'''
_version_file = os.path.join(name, 'PG_VERSION')
_config_file = os.path.join(name, 'postgresql.conf')
return os.path.isfile(_version_file) and os.path.isfile(_config_file)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.