INSTRUCTION stringlengths 1 46.3k | RESPONSE stringlengths 75 80.2k |
|---|---|
Encode a string as base64 using the "legacy" Python interface.
Among other possible differences, the "legacy" encoder includes
a newline ('\\n') character after every 76 characters and always
at the end of the encoded string. | def base64_encodestring(instr):
'''
Encode a string as base64 using the "legacy" Python interface.
Among other possible differences, the "legacy" encoder includes
a newline ('\\n') character after every 76 characters and always
at the end of the encoded string.
'''
return salt.utils.stringu... |
Decode a base64-encoded string using the "legacy" Python interface. | def base64_decodestring(instr):
'''
Decode a base64-encoded string using the "legacy" Python interface.
'''
b = salt.utils.stringutils.to_bytes(instr)
try:
# PY3
decoded = base64.decodebytes(b)
except AttributeError:
# PY2
decoded = base64.decodestring(b)
try:... |
Generate an md5 hash of a given string. | def md5_digest(instr):
'''
Generate an md5 hash of a given string.
'''
return salt.utils.stringutils.to_unicode(
hashlib.md5(salt.utils.stringutils.to_bytes(instr)).hexdigest()
) |
Generate an sha1 hash of a given string. | def sha1_digest(instr):
'''
Generate an sha1 hash of a given string.
'''
if six.PY3:
b = salt.utils.stringutils.to_bytes(instr)
return hashlib.sha1(b).hexdigest()
return hashlib.sha1(instr).hexdigest() |
Generate a sha256 hash of a given string. | def sha256_digest(instr):
'''
Generate a sha256 hash of a given string.
'''
return salt.utils.stringutils.to_unicode(
hashlib.sha256(salt.utils.stringutils.to_bytes(instr)).hexdigest()
) |
Generate a sha512 hash of a given string | def sha512_digest(instr):
'''
Generate a sha512 hash of a given string
'''
return salt.utils.stringutils.to_unicode(
hashlib.sha512(salt.utils.stringutils.to_bytes(instr)).hexdigest()
) |
Verify a challenging hmac signature against a string / shared-secret
Returns a boolean if the verification succeeded or failed. | def hmac_signature(string, shared_secret, challenge_hmac):
'''
Verify a challenging hmac signature against a string / shared-secret
Returns a boolean if the verification succeeded or failed.
'''
msg = salt.utils.stringutils.to_bytes(string)
key = salt.utils.stringutils.to_bytes(shared_secret)
... |
Return a hash of a randomized data from random.SystemRandom() | def random_hash(size=9999999999, hash_type=None):
'''
Return a hash of a randomized data from random.SystemRandom()
'''
if not hash_type:
hash_type = 'md5'
hasher = getattr(hashlib, hash_type)
return hasher(salt.utils.stringutils.to_bytes(six.text_type(random.SystemRandom().randint(0, si... |
Get the hash sum of a file
This is better than ``get_sum`` for the following reasons:
- It does not read the entire file into memory.
- It does not return a string on error. The returned value of
``get_sum`` cannot really be trusted since it is vulnerable to
collisions: ``ge... | def get_hash(path, form='sha256', chunk_size=65536):
'''
Get the hash sum of a file
This is better than ``get_sum`` for the following reasons:
- It does not read the entire file into memory.
- It does not return a string on error. The returned value of
``get_sum`` cannot really ... |
Update digest with the file content by path.
:param path:
:return: | def add(self, path):
'''
Update digest with the file content by path.
:param path:
:return:
'''
with salt.utils.files.fopen(path, 'rb') as ifile:
for chunk in iter(lambda: ifile.read(self.__buff), b''):
self.__digest.update(chunk) |
Get digest.
:return: | def digest(self):
'''
Get digest.
:return:
'''
return salt.utils.stringutils.to_str(self.__digest.hexdigest() + os.linesep) |
Load properties for the cassandra module from config or pillar.
:param property_name: The property to load.
:type property_name: str or list of str
:param config_option: The name of the config option.
:type config_option: str
:param set_default: Should a default be set if not found in config.
... | def _load_properties(property_name, config_option, set_default=False, default=None):
'''
Load properties for the cassandra module from config or pillar.
:param property_name: The property to load.
:type property_name: str or list of str
:param config_option: The name of the config option.
:typ... |
Parse out ssl_options for Cassandra cluster connection.
Make sure that the ssl_version (if any specified) is valid. | def _get_ssl_opts():
'''
Parse out ssl_options for Cassandra cluster connection.
Make sure that the ssl_version (if any specified) is valid.
'''
sslopts = __salt__['config.option']('cassandra').get('ssl_options', None)
ssl_opts = {}
if sslopts:
ssl_opts['ca_certs'] = sslopts['ca_cer... |
Connect to a Cassandra cluster.
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str or list of str
:param cql_user: The Cassandra user if authentication is turned on.
:type cql_user: str
:param cql_pass: The ... | def _connect(contact_points=None, port=None, cql_user=None, cql_pass=None,
protocol_version=None):
'''
Connect to a Cassandra cluster.
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str or list of str
:param cql_u... |
Run a query on a Cassandra cluster and return a dictionary.
:param query: The query to execute.
:type query: str
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str | list[str]
:param cql_user: The Cass... | def cql_query(query, contact_points=None, port=None, cql_user=None, cql_pass=None):
'''
Run a query on a Cassandra cluster and return a dictionary.
:param query: The query to execute.
:type query: str
:param contact_points: The Cassandra cluster addresses, can either be a string ... |
Run a query on a Cassandra cluster and return a dictionary.
This function should not be used asynchronously for SELECTs -- it will not
return anything and we don't currently have a mechanism for handling a future
that will return results.
:param query: The query to execute.
:type query: ... | def cql_query_with_prepare(query, statement_name, statement_arguments, callback_errors=None, contact_points=None,
port=None, cql_user=None, cql_pass=None, **kwargs):
'''
Run a query on a Cassandra cluster and return a dictionary.
This function should not be used asynchronously fo... |
List column families in a Cassandra cluster for all keyspaces or just the provided one.
:param keyspace: The keyspace to provide the column families for, optional.
:type keyspace: str
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type co... | def list_column_families(keyspace=None, contact_points=None, port=None, cql_user=None, cql_pass=None):
'''
List column families in a Cassandra cluster for all keyspaces or just the provided one.
:param keyspace: The keyspace to provide the column families for, optional.
:type keyspace: str... |
Check if a keyspace exists in a Cassandra cluster.
:param keyspace The keyspace name to check for.
:type keyspace: str
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str | list[str]
:param cql_user: The Cas... | def keyspace_exists(keyspace, contact_points=None, port=None, cql_user=None, cql_pass=None):
'''
Check if a keyspace exists in a Cassandra cluster.
:param keyspace The keyspace name to check for.
:type keyspace: str
:param contact_points: The Cassandra cluster addresses, can either be... |
Create a new keyspace in Cassandra.
:param keyspace: The keyspace name
:type keyspace: str
:param replication_strategy: either `SimpleStrategy` or `NetworkTopologyStrategy`
:type replication_strategy: str
:param replication_factor: number of replicas of da... | def create_keyspace(keyspace, replication_strategy='SimpleStrategy', replication_factor=1, replication_datacenters=None,
contact_points=None, port=None, cql_user=None, cql_pass=None):
'''
Create a new keyspace in Cassandra.
:param keyspace: The keyspace name
:type ke... |
Drop a keyspace if it exists in a Cassandra cluster.
:param keyspace: The keyspace to drop.
:type keyspace: str
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str | list[str]
:param cql_user: The Cassandra u... | def drop_keyspace(keyspace, contact_points=None, port=None, cql_user=None, cql_pass=None):
'''
Drop a keyspace if it exists in a Cassandra cluster.
:param keyspace: The keyspace to drop.
:type keyspace: str
:param contact_points: The Cassandra cluster addresses, can either be a string ... |
List existing users in this Cassandra cluster.
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str | list[str]
:param port: The Cassandra cluster port, defaults to None.
:type port: int
:param cql_user: ... | def list_users(contact_points=None, port=None, cql_user=None, cql_pass=None):
'''
List existing users in this Cassandra cluster.
:param contact_points: The Cassandra cluster addresses, can either be a string or a list of IPs.
:type contact_points: str | list[str]
:param port: The Cassand... |
List permissions.
:param username: The name of the user to list permissions for.
:type username: str
:param resource: The resource (keyspace or table), if None, permissions for all resources are listed.
:type resource: str
:param resource_type: The resource_type (keyspace... | def list_permissions(username=None, resource=None, resource_type='keyspace', permission=None, contact_points=None,
port=None, cql_user=None, cql_pass=None):
'''
List permissions.
:param username: The name of the user to list permissions for.
:type username: str
:pa... |
Grant permissions to a user.
:param username: The name of the user to grant permissions to.
:type username: str
:param resource: The resource (keyspace or table), if None, permissions for all resources are granted.
:type resource: str
:param resource_type: The resource_ty... | def grant_permission(username, resource=None, resource_type='keyspace', permission=None, contact_points=None, port=None,
cql_user=None, cql_pass=None):
'''
Grant permissions to a user.
:param username: The name of the user to grant permissions to.
:type username: str
... |
Return the active running journal object | def _get_journal():
'''
Return the active running journal object
'''
if 'systemd.journald' in __context__:
return __context__['systemd.journald']
__context__['systemd.journald'] = systemd.journal.Reader()
# get to the end of the journal
__context__['systemd.journald'].seek_tail()
... |
The journald beacon allows for the systemd journal to be parsed and linked
objects to be turned into events.
This beacons config will return all sshd jornal entries
.. code-block:: yaml
beacons:
journald:
- services:
sshd:
SYSLOG_IDENTIFIER:... | def beacon(config):
'''
The journald beacon allows for the systemd journal to be parsed and linked
objects to be turned into events.
This beacons config will return all sshd jornal entries
.. code-block:: yaml
beacons:
journald:
- services:
sshd:
... |
Get the couchdb options from salt. | def _get_options(ret=None):
'''
Get the couchdb options from salt.
'''
attrs = {'url': 'url',
'db': 'db',
'user': 'user',
'passwd': 'passwd',
'redact_pws': 'redact_pws',
'minimum_return': 'minimum_return'}
_options = salt.returners.ge... |
Create a object that will be saved into the database based on
options. | def _generate_doc(ret):
'''
Create a object that will be saved into the database based on
options.
'''
# Create a copy of the object that we will return.
retc = ret.copy()
# Set the ID of the document to be the JID.
retc["_id"] = ret["jid"]
# Add a timestamp field to the document
... |
Makes a HTTP request. Returns the JSON parse, or an obj with an error. | def _request(method, url, content_type=None, _data=None, user=None, passwd=None):
'''
Makes a HTTP request. Returns the JSON parse, or an obj with an error.
'''
opener = _build_opener(_HTTPHandler)
request = _Request(url, data=_data)
if content_type:
request.add_header('Content-Type', co... |
Create a object that will be saved into the database based in
options. | def _generate_event_doc(event):
'''
Create a object that will be saved into the database based in
options.
'''
# Create a copy of the object that we will return.
eventc = event.copy()
# Set the ID of the document to be the JID.
eventc["_id"] = '{}-{}'.format(
... |
Take in the return and shove it into the couchdb database. | def returner(ret):
'''
Take in the return and shove it into the couchdb database.
'''
options = _get_options(ret)
# Check to see if the database exists.
_response = _request("GET",
options['url'] + "_all_dbs",
user=options['user'],
... |
Return event to CouchDB server
Requires that configuration be enabled via 'event_return'
option in master config.
Example:
event_return:
- couchdb | def event_return(events):
'''
Return event to CouchDB server
Requires that configuration be enabled via 'event_return'
option in master config.
Example:
event_return:
- couchdb
'''
log.debug('events data is: %s', events)
options = _get_options()
# Check to see if the d... |
List all the jobs that we have.. | def get_jids():
'''
List all the jobs that we have..
'''
options = _get_options(ret=None)
_response = _request("GET", options['url'] + options['db'] + "/_all_docs?include_docs=true")
# Make sure the 'total_rows' is returned.. if not error out.
if 'total_rows' not in _response:
log.e... |
Return a dict with key being minion and value
being the job details of the last run of function 'fun'. | def get_fun(fun):
'''
Return a dict with key being minion and value
being the job details of the last run of function 'fun'.
'''
# Get the options..
options = _get_options(ret=None)
# Define a simple return object.
_ret = {}
# get_minions takes care of calling ensure_views for us.... |
This function makes sure that all the views that should
exist in the design document do exist. | def ensure_views():
'''
This function makes sure that all the views that should
exist in the design document do exist.
'''
# Get the options so we have the URL and DB..
options = _get_options(ret=None)
# Make a request to check if the design document exists.
_response = _request("GET",... |
Helper function that sets the salt design
document. Uses get_valid_salt_views and some hardcoded values. | def set_salt_view():
'''
Helper function that sets the salt design
document. Uses get_valid_salt_views and some hardcoded values.
'''
options = _get_options(ret=None)
# Create the new object that we will shove in as the design doc.
new_doc = {}
new_doc['views'] = get_valid_salt_views()... |
Included for API consistency | def get_load(jid):
'''
Included for API consistency
'''
options = _get_options(ret=None)
_response = _request("GET", options['url'] + options['db'] + '/' + jid)
if 'error' in _response:
log.error('Unable to get JID "%s" : "%s"', jid, _response)
return {}
return {_response['id... |
Set up heat credentials, returns
`heatclient.client.Client`. Optional parameter
"api_version" defaults to 1.
Only intended to be used within heat-enabled modules | def _auth(profile=None, api_version=1, **connection_args):
'''
Set up heat credentials, returns
`heatclient.client.Client`. Optional parameter
"api_version" defaults to 1.
Only intended to be used within heat-enabled modules
'''
if profile:
prefix = profile + ':keystone.'
else:... |
Parsing template | def _parse_environment(env_str):
'''
Parsing template
'''
try:
env = salt.utils.yaml.safe_load(env_str)
except salt.utils.yaml.YAMLError as exc:
raise ValueError(six.text_type(exc))
else:
if env is None:
env = {}
elif not isinstance(env, dict):
... |
Get event for stack | def _get_stack_events(h_client, stack_id, event_args):
'''
Get event for stack
'''
event_args['stack_id'] = stack_id
event_args['resource_name'] = None
try:
events = h_client.events.list(**event_args)
except heatclient.exc.HTTPNotFound as exc:
raise heatclient.exc.CommandErro... |
Polling stack events | def _poll_for_events(h_client, stack_name, action=None, poll_period=5,
timeout=60, marker=None):
'''
Polling stack events
'''
if action:
stop_status = ('{0}_FAILED'.format(action), '{0}_COMPLETE'.format(action))
stop_check = lambda a: a in stop_status
else:
... |
Return a list of available stack (heat stack-list)
profile
Profile to use
CLI Example:
.. code-block:: bash
salt '*' heat.list_stack profile=openstack1 | def list_stack(profile=None):
'''
Return a list of available stack (heat stack-list)
profile
Profile to use
CLI Example:
.. code-block:: bash
salt '*' heat.list_stack profile=openstack1
'''
ret = {}
h_client = _auth(profile)
for stack in h_client.stacks.list():
... |
Return details about a specific stack (heat stack-show)
name
Name of the stack
profile
Profile to use
CLI Example:
.. code-block:: bash
salt '*' heat.show_stack name=mystack profile=openstack1 | def show_stack(name=None, profile=None):
'''
Return details about a specific stack (heat stack-show)
name
Name of the stack
profile
Profile to use
CLI Example:
.. code-block:: bash
salt '*' heat.show_stack name=mystack profile=openstack1
'''
h_client = _auth(... |
Delete a stack (heat stack-delete)
name
Name of the stack
poll
Poll and report events until stack complete
timeout
Stack creation timeout in minute
profile
Profile to use
CLI Examples:
.. code-block:: bash
salt '*' heat.delete_stack name=mystack po... | def delete_stack(name=None, poll=0, timeout=60, profile=None):
'''
Delete a stack (heat stack-delete)
name
Name of the stack
poll
Poll and report events until stack complete
timeout
Stack creation timeout in minute
profile
Profile to use
CLI Examples:
... |
Create a stack (heat stack-create)
name
Name of the new stack
template_file
File of template
environment
File of environment
parameters
Parameter dict used to create the stack
poll
Poll and report events until stack complete
rollback
Enable r... | def create_stack(name=None, template_file=None, environment=None,
parameters=None, poll=0, rollback=False, timeout=60,
profile=None, enviroment=None):
'''
Create a stack (heat stack-create)
name
Name of the new stack
template_file
File of template
... |
Return template a specific stack (heat stack-template)
name
Name of the stack
profile
Profile to use
CLI Example:
.. code-block:: bash
salt '*' heat.template_stack name=mystack profile=openstack1 | def template_stack(name=None, profile=None):
'''
Return template a specific stack (heat stack-template)
name
Name of the stack
profile
Profile to use
CLI Example:
.. code-block:: bash
salt '*' heat.template_stack name=mystack profile=openstack1
'''
h_client =... |
Makes sure an URL is monitored by uptime. Checks if URL is already
monitored, and if not, adds it. | def monitored(name, **params):
'''
Makes sure an URL is monitored by uptime. Checks if URL is already
monitored, and if not, adds it.
'''
ret = {'name': name, 'changes': {}, 'result': None, 'comment': ''}
if __salt__['uptime.check_exists'](name=name):
ret['result'] = True
ret['... |
Return an un-ordered list of lock holders
path
The path in zookeeper where the lock is
zk_hosts
zookeeper connect string
identifier
Name to identify this minion, if unspecified defaults to hostname
max_concurrency
Maximum number of lock holders
timeout
ti... | def lock_holders(path,
zk_hosts=None,
identifier=None,
max_concurrency=1,
timeout=None,
ephemeral_lease=False,
profile=None,
scheme=None,
username=None,
password=None,... |
Get lock (with optional timeout)
path
The path in zookeeper where the lock is
zk_hosts
zookeeper connect string
identifier
Name to identify this minion, if unspecified defaults to the hostname
max_concurrency
Maximum number of lock holders
timeout
timeout... | def lock(path,
zk_hosts=None,
identifier=None,
max_concurrency=1,
timeout=None,
ephemeral_lease=False,
force=False, # foricble get the lock regardless of open slots
profile=None,
scheme=None,
username=None,
password=None,
... |
Remove lease from semaphore
path
The path in zookeeper where the lock is
zk_hosts
zookeeper connect string
identifier
Name to identify this minion, if unspecified defaults to hostname
max_concurrency
Maximum number of lock holders
timeout
timeout to wait ... | def unlock(path,
zk_hosts=None, # in case you need to unlock without having run lock (failed execution for example)
identifier=None,
max_concurrency=1,
ephemeral_lease=False,
scheme=None,
profile=None,
username=None,
password=None,... |
Get the List of identifiers in a particular party, optionally waiting for the
specified minimum number of nodes (min_nodes) to appear
path
The path in zookeeper where the lock is
zk_hosts
zookeeper connect string
min_nodes
The minimum number of nodes expected to be present in ... | def party_members(path,
zk_hosts=None,
min_nodes=1,
blocking=False,
profile=None,
scheme=None,
username=None,
password=None,
default_acl=None,
):
'''
... |
Retrieve the logfile name | def _default_logfile(exe_name):
'''
Retrieve the logfile name
'''
if salt.utils.platform.is_windows():
tmp_dir = os.path.join(__opts__['cachedir'], 'tmp')
if not os.path.isdir(tmp_dir):
os.mkdir(tmp_dir)
logfile_tmp = tempfile.NamedTemporaryFile(dir=tmp_dir,
... |
Execute a chef client run and return a dict with the stderr, stdout,
return code, and pid.
CLI Example:
.. code-block:: bash
salt '*' chef.client server=https://localhost
server
The chef server URL
client_key
Set the client key file location
config
The confi... | def client(whyrun=False,
localmode=False,
logfile=None,
**kwargs):
'''
Execute a chef client run and return a dict with the stderr, stdout,
return code, and pid.
CLI Example:
.. code-block:: bash
salt '*' chef.client server=https://localhost
server
... |
Execute a chef solo run and return a dict with the stderr, stdout,
return code, and pid.
CLI Example:
.. code-block:: bash
salt '*' chef.solo override-runlist=test
config
The configuration file to use
environment
Set the Chef Environment on the node
group
Gr... | def solo(whyrun=False,
logfile=None,
**kwargs):
'''
Execute a chef solo run and return a dict with the stderr, stdout,
return code, and pid.
CLI Example:
.. code-block:: bash
salt '*' chef.solo override-runlist=test
config
The configuration file to use
... |
Frame the given message with our wire protocol | def frame_msg(body, header=None, raw_body=False): # pylint: disable=unused-argument
'''
Frame the given message with our wire protocol
'''
framed_msg = {}
if header is None:
header = {}
framed_msg['head'] = header
framed_msg['body'] = body
return salt.utils.msgpack.dumps(framed... |
Frame the given message with our wire protocol for IPC
For IPC, we don't need to be backwards compatible, so
use the more efficient "use_bin_type=True" on Python 3. | def frame_msg_ipc(body, header=None, raw_body=False): # pylint: disable=unused-argument
'''
Frame the given message with our wire protocol for IPC
For IPC, we don't need to be backwards compatible, so
use the more efficient "use_bin_type=True" on Python 3.
'''
framed_msg = {}
if header is ... |
Convert enbedded bytes to strings if possible.
List helper. | def _decode_embedded_list(src):
'''
Convert enbedded bytes to strings if possible.
List helper.
'''
output = []
for elem in src:
if isinstance(elem, dict):
elem = _decode_embedded_dict(elem)
elif isinstance(elem, list):
elem = _decode_embedded_list(elem) ... |
Convert enbedded bytes to strings if possible.
Dict helper. | def _decode_embedded_dict(src):
'''
Convert enbedded bytes to strings if possible.
Dict helper.
'''
output = {}
for key, val in six.iteritems(src):
if isinstance(val, dict):
val = _decode_embedded_dict(val)
elif isinstance(val, list):
val = _decode_embedde... |
Convert enbedded bytes to strings if possible.
This is necessary because Python 3 makes a distinction
between these types.
This wouldn't be needed if we used "use_bin_type=True" when encoding
and "encoding='utf-8'" when decoding. Unfortunately, this would break
backwards compatibility due to a chan... | def decode_embedded_strs(src):
'''
Convert enbedded bytes to strings if possible.
This is necessary because Python 3 makes a distinction
between these types.
This wouldn't be needed if we used "use_bin_type=True" when encoding
and "encoding='utf-8'" when decoding. Unfortunately, this would brea... |
Validate the named integer within the supplied limits inclusive and
strip supplied unit characters | def _validate_int(name, value, limits=(), strip='%'):
'''
Validate the named integer within the supplied limits inclusive and
strip supplied unit characters
'''
comment = ''
# Must be integral
try:
if isinstance(value, string_types):
value = value.strip(' ' + strip)
... |
Return the current disk usage stats for the named mount point
name
Disk mount or directory for which to check used space
maximum
The maximum disk utilization
minimum
The minimum disk utilization
absolute
By default, the utilization is measured in percentage. Set
... | def status(name, maximum=None, minimum=None, absolute=False, free=False):
'''
Return the current disk usage stats for the named mount point
name
Disk mount or directory for which to check used space
maximum
The maximum disk utilization
minimum
The minimum disk utilization
... |
Verifies that the specified host is known by the specified user
On many systems, specifically those running with openssh 4 or older, the
``enc`` option must be set, only openssh 5 and above can detect the key
type.
name
The name of the remote host (e.g. "github.com")
Note that only a s... | def present(
name,
user=None,
fingerprint=None,
key=None,
port=None,
enc=None,
config=None,
hash_known_hosts=True,
timeout=5,
fingerprint_hash_type=None):
'''
Verifies that the specified host is known by the specified user
On m... |
Verifies that the specified host is not known by the given user
name
The host name
Note that only single host names are supported. If foo.example.com
and bar.example.com are the same machine and you need to exclude both,
you will need one Salt state for each.
user
The ... | def absent(name, user=None, config=None):
'''
Verifies that the specified host is not known by the given user
name
The host name
Note that only single host names are supported. If foo.example.com
and bar.example.com are the same machine and you need to exclude both,
you wil... |
Fire up the configured engines! | def start_engines(opts, proc_mgr, proxy=None):
'''
Fire up the configured engines!
'''
utils = salt.loader.utils(opts, proxy=proxy)
if opts['__role'] == 'master':
runners = salt.loader.runner(opts, utils=utils)
else:
runners = []
funcs = salt.loader.minion_mods(opts, utils=ut... |
Run the master service! | def run(self):
'''
Run the master service!
'''
self.utils = salt.loader.utils(self.opts, proxy=self.proxy)
if salt.utils.platform.is_windows():
# Calculate function references since they can't be pickled.
if self.opts['__role'] == 'master':
... |
Return the targets from a range query | def targets(tgt, tgt_type='range', **kwargs):
'''
Return the targets from a range query
'''
r = seco.range.Range(__opts__['range_server'])
log.debug('Range connection to \'%s\' established', __opts__['range_server'])
hosts = []
try:
log.debug('Querying range for \'%s\'', tgt)
... |
returns a authentication handler. | def _auth(url, user, passwd, realm):
'''
returns a authentication handler.
'''
basic = _HTTPBasicAuthHandler()
basic.add_password(realm=realm, uri=url, user=user, passwd=passwd)
digest = _HTTPDigestAuthHandler()
digest.add_password(realm=realm, uri=url, user=user, passwd=passwd)
return ... |
Make the http request and return the data | def _do_http(opts, profile='default'):
'''
Make the http request and return the data
'''
ret = {}
url = __salt__['config.get']('modjk:{0}:url'.format(profile), '')
user = __salt__['config.get']('modjk:{0}:user'.format(profile), '')
passwd = __salt__['config.get']('modjk:{0}:pass'.format(pr... |
enable/disable/stop a worker | def _worker_ctl(worker, lbn, vwa, profile='default'):
'''
enable/disable/stop a worker
'''
cmd = {
'cmd': 'update',
'mime': 'prop',
'w': lbn,
'sw': worker,
'vwa': vwa,
}
return _do_http(cmd, profile)['worker.result.type'] == 'OK' |
Return a list of member workers from the configuration files
CLI Examples:
.. code-block:: bash
salt '*' modjk.list_configured_members loadbalancer1
salt '*' modjk.list_configured_members loadbalancer1 other-profile | def list_configured_members(lbn, profile='default'):
'''
Return a list of member workers from the configuration files
CLI Examples:
.. code-block:: bash
salt '*' modjk.list_configured_members loadbalancer1
salt '*' modjk.list_configured_members loadbalancer1 other-profile
'''
... |
Return a list of member workers and their status
CLI Examples:
.. code-block:: bash
salt '*' modjk.workers
salt '*' modjk.workers other-profile | def workers(profile='default'):
'''
Return a list of member workers and their status
CLI Examples:
.. code-block:: bash
salt '*' modjk.workers
salt '*' modjk.workers other-profile
'''
config = get_running(profile)
lbn = config['worker.list'].split(',')
worker_list = [... |
Set the all the workers in lbn to recover and activate them if they are not
CLI Examples:
.. code-block:: bash
salt '*' modjk.recover_all loadbalancer1
salt '*' modjk.recover_all loadbalancer1 other-profile | def recover_all(lbn, profile='default'):
'''
Set the all the workers in lbn to recover and activate them if they are not
CLI Examples:
.. code-block:: bash
salt '*' modjk.recover_all loadbalancer1
salt '*' modjk.recover_all loadbalancer1 other-profile
'''
ret = {}
config ... |
Edit the loadbalancer settings
Note: http://tomcat.apache.org/connectors-doc/reference/status.html
Data Parameters for the standard Update Action
CLI Examples:
.. code-block:: bash
salt '*' modjk.lb_edit loadbalancer1 "{'vlr': 1, 'vlt': 60}"
salt '*' modjk.lb_edit loadbalancer1 "{'vl... | def lb_edit(lbn, settings, profile='default'):
'''
Edit the loadbalancer settings
Note: http://tomcat.apache.org/connectors-doc/reference/status.html
Data Parameters for the standard Update Action
CLI Examples:
.. code-block:: bash
salt '*' modjk.lb_edit loadbalancer1 "{'vlr': 1, 'vl... |
Stop all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_stop node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_stop node1,node2,node3 loadbalancer1 other-profile
salt '*' modjk.bulk_stop ["node1","node2","node3"] loadbalancer1... | def bulk_stop(workers, lbn, profile='default'):
'''
Stop all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_stop node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_stop node1,node2,node3 loadbalancer1 other-profile
salt... |
Activate all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_activate node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_activate node1,node2,node3 loadbalancer1 other-profile
salt '*' modjk.bulk_activate ["node1","node2","node3... | def bulk_activate(workers, lbn, profile='default'):
'''
Activate all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_activate node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_activate node1,node2,node3 loadbalancer1 other-profi... |
Disable all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_disable node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_disable node1,node2,node3 loadbalancer1 other-profile
salt '*' modjk.bulk_disable ["node1","node2","node3"] l... | def bulk_disable(workers, lbn, profile='default'):
'''
Disable all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_disable node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_disable node1,node2,node3 loadbalancer1 other-profile
... |
Recover all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_recover node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_recover node1,node2,node3 loadbalancer1 other-profile
salt '*' modjk.bulk_recover ["node1","node2","node3"] l... | def bulk_recover(workers, lbn, profile='default'):
'''
Recover all the given workers in the specific load balancer
CLI Examples:
.. code-block:: bash
salt '*' modjk.bulk_recover node1,node2,node3 loadbalancer1
salt '*' modjk.bulk_recover node1,node2,node3 loadbalancer1 other-profile
... |
Return the state of the worker
CLI Examples:
.. code-block:: bash
salt '*' modjk.worker_status node1
salt '*' modjk.worker_status node1 other-profile | def worker_status(worker, profile='default'):
'''
Return the state of the worker
CLI Examples:
.. code-block:: bash
salt '*' modjk.worker_status node1
salt '*' modjk.worker_status node1 other-profile
'''
config = get_running(profile)
try:
return {
'act... |
Set the worker to recover
this module will fail if it is in OK state
CLI Examples:
.. code-block:: bash
salt '*' modjk.worker_recover node1 loadbalancer1
salt '*' modjk.worker_recover node1 loadbalancer1 other-profile | def worker_recover(worker, lbn, profile='default'):
'''
Set the worker to recover
this module will fail if it is in OK state
CLI Examples:
.. code-block:: bash
salt '*' modjk.worker_recover node1 loadbalancer1
salt '*' modjk.worker_recover node1 loadbalancer1 other-profile
'''... |
Return server and build arguments
CLI Example:
.. code-block:: bash
salt '*' nginx.build_info | def build_info():
'''
Return server and build arguments
CLI Example:
.. code-block:: bash
salt '*' nginx.build_info
'''
ret = {'info': []}
out = __salt__['cmd.run']('{0} -V'.format(__detect_os()))
for i in out.splitlines():
if i.startswith('configure argument'):
... |
Edit the worker settings
Note: http://tomcat.apache.org/connectors-doc/reference/status.html
Data Parameters for the standard Update Action
CLI Examples:
.. code-block:: bash
salt '*' modjk.worker_edit node1 loadbalancer1 "{'vwf': 500, 'vwd': 60}"
salt '*' modjk.worker_edit node1 loa... | def worker_edit(worker, lbn, settings, profile='default'):
'''
Edit the worker settings
Note: http://tomcat.apache.org/connectors-doc/reference/status.html
Data Parameters for the standard Update Action
CLI Examples:
.. code-block:: bash
salt '*' modjk.worker_edit node1 loadbalancer1... |
Signals nginx to start, reload, reopen or stop.
CLI Example:
.. code-block:: bash
salt '*' nginx.signal reload | def signal(signal=None):
'''
Signals nginx to start, reload, reopen or stop.
CLI Example:
.. code-block:: bash
salt '*' nginx.signal reload
'''
valid_signals = ('start', 'reopen', 'stop', 'quit', 'reload')
if signal not in valid_signals:
return
# Make sure you use th... |
Return the data from an Nginx status page as a dictionary.
http://wiki.nginx.org/HttpStubStatusModule
url
The URL of the status page. Defaults to 'http://127.0.0.1/status'
CLI Example:
.. code-block:: bash
salt '*' nginx.status | def status(url="http://127.0.0.1/status"):
"""
Return the data from an Nginx status page as a dictionary.
http://wiki.nginx.org/HttpStubStatusModule
url
The URL of the status page. Defaults to 'http://127.0.0.1/status'
CLI Example:
.. code-block:: bash
salt '*' nginx.status
... |
This function gets called when the proxy starts up. For
ESXi devices, the host, login credentials, and, if configured,
the protocol and port are cached. | def init(opts):
'''
This function gets called when the proxy starts up. For
ESXi devices, the host, login credentials, and, if configured,
the protocol and port are cached.
'''
log.debug('Initting esxi proxy module in process %s', os.getpid())
log.debug('Validating esxi proxy input')
sch... |
Returns True if connection is to be done via a vCenter (no connection is attempted).
Check to see if the host is responding when connecting directly via an ESXi
host.
CLI Example:
.. code-block:: bash
salt esxi-host test.ping | def ping():
'''
Returns True if connection is to be done via a vCenter (no connection is attempted).
Check to see if the host is responding when connecting directly via an ESXi
host.
CLI Example:
.. code-block:: bash
salt esxi-host test.ping
'''
if DETAILS.get('esxi_host'):
... |
This function is called by the
:mod:`salt.modules.esxi.cmd <salt.modules.esxi.cmd>` shim.
It then calls whatever is passed in ``cmd`` inside the
:mod:`salt.modules.vsphere <salt.modules.vsphere>` module.
Passes the return through from the vsphere module.
cmd
The command to call inside salt.... | def ch_config(cmd, *args, **kwargs):
'''
This function is called by the
:mod:`salt.modules.esxi.cmd <salt.modules.esxi.cmd>` shim.
It then calls whatever is passed in ``cmd`` inside the
:mod:`salt.modules.vsphere <salt.modules.vsphere>` module.
Passes the return through from the vsphere module.
... |
Cycle through all the possible credentials and return the first one that
works. | def find_credentials(host):
'''
Cycle through all the possible credentials and return the first one that
works.
'''
user_names = [__pillar__['proxy'].get('username', 'root')]
passwords = __pillar__['proxy']['passwords']
for user in user_names:
for password in passwords:
t... |
Send a message to a Telegram chat.
:param message: The message to send to the Telegram chat.
:param chat_id: (optional) The Telegram chat id.
:param token: (optional) The Telegram API token.
:return: Boolean if message was sent successfully.
CLI Example:
.. code-block:: bash
... | def post_message(message, chat_id=None, token=None):
'''
Send a message to a Telegram chat.
:param message: The message to send to the Telegram chat.
:param chat_id: (optional) The Telegram chat id.
:param token: (optional) The Telegram API token.
:return: Boolean if message was sent s... |
Helper function to the grains from the proxied device. | def _grains(host, protocol=None, port=None):
'''
Helper function to the grains from the proxied device.
'''
username, password = find_credentials(DETAILS['host'])
ret = __salt__['vsphere.system_info'](host=host,
username=username,
... |
Send a message to a Telegram chat.
:param chat_id: The chat id.
:param message: The message to send to the telegram chat.
:param token: The Telegram API token.
:return: Boolean if message was sent successfully. | def _post_message(message, chat_id, token):
'''
Send a message to a Telegram chat.
:param chat_id: The chat id.
:param message: The message to send to the telegram chat.
:param token: The Telegram API token.
:return: Boolean if message was sent successfully.
'''
... |
Return the targets from the ansible inventory_file
Default: /etc/salt/roster | def targets(tgt, tgt_type='glob', **kwargs):
'''
Return the targets from the ansible inventory_file
Default: /etc/salt/roster
'''
inventory = __runner__['salt.cmd']('cmd.run', 'ansible-inventory -i {0} --list'.format(get_roster_file(__opts__)))
__context__['inventory'] = __utils__['json.loads'](... |
Set a key/value pair in the cache service | def set_(key, value, service=None, profile=None): # pylint: disable=W0613
'''
Set a key/value pair in the cache service
'''
key, profile = _parse_key(key, profile)
cache = salt.cache.Cache(__opts__)
cache.store(profile['bank'], key, value)
return get(key, service, profile) |
Get a value from the cache service | def get(key, service=None, profile=None): # pylint: disable=W0613
'''
Get a value from the cache service
'''
key, profile = _parse_key(key, profile)
cache = salt.cache.Cache(__opts__)
return cache.fetch(profile['bank'], key=key) |
Get a value from the cache service | def delete(key, service=None, profile=None): # pylint: disable=W0613
'''
Get a value from the cache service
'''
key, profile = _parse_key(key, profile)
cache = salt.cache.Cache(__opts__)
try:
cache.flush(profile['bank'], key=key)
return True
except Exception:
return ... |
Parse out a key and update the opts with any override data | def _parse_key(key, profile):
'''
Parse out a key and update the opts with any override data
'''
comps = key.split('?')
if len(comps) > 1:
for item in comps[1].split('&'):
newkey, newval = item.split('=')
profile[newkey] = newval
if 'cachedir' in profile:
... |
Connect to the redis host and return a StrictRedisCluster client object.
If connection fails then return None. | def _redis_client(opts):
'''
Connect to the redis host and return a StrictRedisCluster client object.
If connection fails then return None.
'''
redis_host = opts.get("eauth_redis_host", "localhost")
redis_port = opts.get("eauth_redis_port", 6379)
try:
return rediscluster.StrictRedisC... |
Mint a new token using the config option hash_type and store tdata with 'token' attribute set
to the token.
This module uses the hash of random 512 bytes as a token.
:param opts: Salt master config options
:param tdata: Token data to be stored with 'token' attirbute of this dict set to the token.
:... | def mk_token(opts, tdata):
'''
Mint a new token using the config option hash_type and store tdata with 'token' attribute set
to the token.
This module uses the hash of random 512 bytes as a token.
:param opts: Salt master config options
:param tdata: Token data to be stored with 'token' attirbu... |
Fetch the token data from the store.
:param opts: Salt master config options
:param tok: Token value to get
:returns: Token data if successful. Empty dict if failed. | def get_token(opts, tok):
'''
Fetch the token data from the store.
:param opts: Salt master config options
:param tok: Token value to get
:returns: Token data if successful. Empty dict if failed.
'''
redis_client = _redis_client(opts)
if not redis_client:
return {}
serial = ... |
Remove token from the store.
:param opts: Salt master config options
:param tok: Token to remove
:returns: Empty dict if successful. None if failed. | def rm_token(opts, tok):
'''
Remove token from the store.
:param opts: Salt master config options
:param tok: Token to remove
:returns: Empty dict if successful. None if failed.
'''
redis_client = _redis_client(opts)
if not redis_client:
return
try:
redis_client.dele... |
List all tokens in the store.
:param opts: Salt master config options
:returns: List of dicts (token_data) | def list_tokens(opts):
'''
List all tokens in the store.
:param opts: Salt master config options
:returns: List of dicts (token_data)
'''
ret = []
redis_client = _redis_client(opts)
if not redis_client:
return []
serial = salt.payload.Serial(opts)
try:
return [k.... |
Run the initial setup of wordpress
name
path to the wordpress installation
user
user that owns the files for the wordpress installation
admin_user
username for wordpress website administrator user
admin_password
password for wordpress website administrator user
a... | def installed(name, user, admin_user, admin_password, admin_email, title, url):
'''
Run the initial setup of wordpress
name
path to the wordpress installation
user
user that owns the files for the wordpress installation
admin_user
username for wordpress website administrat... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.