partition stringclasses 3
values | func_name stringlengths 1 134 | docstring stringlengths 1 46.9k | path stringlengths 4 223 | original_string stringlengths 75 104k | code stringlengths 75 104k | docstring_tokens listlengths 1 1.97k | repo stringlengths 7 55 | language stringclasses 1
value | url stringlengths 87 315 | code_tokens listlengths 19 28.4k | sha stringlengths 40 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|
train | ps | List all running containers and report some information about them
path
Path where the docker-compose file is stored on the server
CLI Example:
.. code-block:: bash
salt myminion dockercompose.ps /path/where/docker-compose/stored | salt/modules/dockercompose.py | def ps(path):
'''
List all running containers and report some information about them
path
Path where the docker-compose file is stored on the server
CLI Example:
.. code-block:: bash
salt myminion dockercompose.ps /path/where/docker-compose/stored
'''
project = __load_pr... | def ps(path):
'''
List all running containers and report some information about them
path
Path where the docker-compose file is stored on the server
CLI Example:
.. code-block:: bash
salt myminion dockercompose.ps /path/where/docker-compose/stored
'''
project = __load_pr... | [
"List",
"all",
"running",
"containers",
"and",
"report",
"some",
"information",
"about",
"them"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dockercompose.py#L814-L854 | [
"def",
"ps",
"(",
"path",
")",
":",
"project",
"=",
"__load_project",
"(",
"path",
")",
"result",
"=",
"{",
"}",
"if",
"isinstance",
"(",
"project",
",",
"dict",
")",
":",
"return",
"project",
"else",
":",
"if",
"USE_FILTERCLASS",
":",
"containers",
"=... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | up | Create and start containers defined in the docker-compose.yml file
located in path, service_names is a python list, if omitted create and
start all containers
path
Path where the docker-compose file is stored on the server
service_names
If specified will create and start only the specif... | salt/modules/dockercompose.py | def up(path, service_names=None):
'''
Create and start containers defined in the docker-compose.yml file
located in path, service_names is a python list, if omitted create and
start all containers
path
Path where the docker-compose file is stored on the server
service_names
If s... | def up(path, service_names=None):
'''
Create and start containers defined in the docker-compose.yml file
located in path, service_names is a python list, if omitted create and
start all containers
path
Path where the docker-compose file is stored on the server
service_names
If s... | [
"Create",
"and",
"start",
"containers",
"defined",
"in",
"the",
"docker",
"-",
"compose",
".",
"yml",
"file",
"located",
"in",
"path",
"service_names",
"is",
"a",
"python",
"list",
"if",
"omitted",
"create",
"and",
"start",
"all",
"containers"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dockercompose.py#L857-L891 | [
"def",
"up",
"(",
"path",
",",
"service_names",
"=",
"None",
")",
":",
"debug_ret",
"=",
"{",
"}",
"project",
"=",
"__load_project",
"(",
"path",
")",
"if",
"isinstance",
"(",
"project",
",",
"dict",
")",
":",
"return",
"project",
"else",
":",
"try",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | service_upsert | Create or update the definition of a docker-compose service
This does not pull or up the service
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
service_name
Name of the service to cr... | salt/modules/dockercompose.py | def service_upsert(path, service_name, definition):
'''
Create or update the definition of a docker-compose service
This does not pull or up the service
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored ... | def service_upsert(path, service_name, definition):
'''
Create or update the definition of a docker-compose service
This does not pull or up the service
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored ... | [
"Create",
"or",
"update",
"the",
"definition",
"of",
"a",
"docker",
"-",
"compose",
"service",
"This",
"does",
"not",
"pull",
"or",
"up",
"the",
"service",
"This",
"wil",
"re",
"-",
"write",
"your",
"yaml",
"file",
".",
"Comments",
"will",
"be",
"lost",
... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dockercompose.py#L927-L956 | [
"def",
"service_upsert",
"(",
"path",
",",
"service_name",
",",
"definition",
")",
":",
"compose_result",
",",
"loaded_definition",
",",
"err",
"=",
"__load_compose_definitions",
"(",
"path",
",",
"definition",
")",
"if",
"err",
":",
"return",
"err",
"services",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | service_remove | Remove the definition of a docker-compose service
This does not rm the container
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
service_name
Name of the service to remove
CLI Ex... | salt/modules/dockercompose.py | def service_remove(path, service_name):
'''
Remove the definition of a docker-compose service
This does not rm the container
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
service_na... | def service_remove(path, service_name):
'''
Remove the definition of a docker-compose service
This does not rm the container
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
service_na... | [
"Remove",
"the",
"definition",
"of",
"a",
"docker",
"-",
"compose",
"service",
"This",
"does",
"not",
"rm",
"the",
"container",
"This",
"wil",
"re",
"-",
"write",
"your",
"yaml",
"file",
".",
"Comments",
"will",
"be",
"lost",
".",
"Indentation",
"is",
"s... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dockercompose.py#L959-L987 | [
"def",
"service_remove",
"(",
"path",
",",
"service_name",
")",
":",
"compose_result",
",",
"err",
"=",
"__load_docker_compose",
"(",
"path",
")",
"if",
"err",
":",
"return",
"err",
"services",
"=",
"compose_result",
"[",
"'compose_content'",
"]",
"[",
"'servi... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | service_set_tag | Change the tag of a docker-compose service
This does not pull or up the service
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
service_name
Name of the service to remove
tag
... | salt/modules/dockercompose.py | def service_set_tag(path, service_name, tag):
'''
Change the tag of a docker-compose service
This does not pull or up the service
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
servi... | def service_set_tag(path, service_name, tag):
'''
Change the tag of a docker-compose service
This does not pull or up the service
This wil re-write your yaml file. Comments will be lost. Indentation is set to 2 spaces
path
Path where the docker-compose file is stored on the server
servi... | [
"Change",
"the",
"tag",
"of",
"a",
"docker",
"-",
"compose",
"service",
"This",
"does",
"not",
"pull",
"or",
"up",
"the",
"service",
"This",
"wil",
"re",
"-",
"write",
"your",
"yaml",
"file",
".",
"Comments",
"will",
"be",
"lost",
".",
"Indentation",
"... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dockercompose.py#L990-L1025 | [
"def",
"service_set_tag",
"(",
"path",
",",
"service_name",
",",
"tag",
")",
":",
"compose_result",
",",
"err",
"=",
"__load_docker_compose",
"(",
"path",
")",
"if",
"err",
":",
"return",
"err",
"services",
"=",
"compose_result",
"[",
"'compose_content'",
"]",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | split_low_tag | Take a low tag and split it back into the low dict that it came from | salt/state.py | def split_low_tag(tag):
'''
Take a low tag and split it back into the low dict that it came from
'''
state, id_, name, fun = tag.split('_|-')
return {'state': state,
'__id__': id_,
'name': name,
'fun': fun} | def split_low_tag(tag):
'''
Take a low tag and split it back into the low dict that it came from
'''
state, id_, name, fun = tag.split('_|-')
return {'state': state,
'__id__': id_,
'name': name,
'fun': fun} | [
"Take",
"a",
"low",
"tag",
"and",
"split",
"it",
"back",
"into",
"the",
"low",
"dict",
"that",
"it",
"came",
"from"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L144-L153 | [
"def",
"split_low_tag",
"(",
"tag",
")",
":",
"state",
",",
"id_",
",",
"name",
",",
"fun",
"=",
"tag",
".",
"split",
"(",
"'_|-'",
")",
"return",
"{",
"'state'",
":",
"state",
",",
"'__id__'",
":",
"id_",
",",
"'name'",
":",
"name",
",",
"'fun'",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | _calculate_fake_duration | Generate a NULL duration for when states do not run
but we want the results to be consistent. | salt/state.py | def _calculate_fake_duration():
'''
Generate a NULL duration for when states do not run
but we want the results to be consistent.
'''
utc_start_time = datetime.datetime.utcnow()
local_start_time = utc_start_time - \
(datetime.datetime.utcnow() - datetime.datetime.now())
utc_finish_ti... | def _calculate_fake_duration():
'''
Generate a NULL duration for when states do not run
but we want the results to be consistent.
'''
utc_start_time = datetime.datetime.utcnow()
local_start_time = utc_start_time - \
(datetime.datetime.utcnow() - datetime.datetime.now())
utc_finish_ti... | [
"Generate",
"a",
"NULL",
"duration",
"for",
"when",
"states",
"do",
"not",
"run",
"but",
"we",
"want",
"the",
"results",
"to",
"be",
"consistent",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L178-L192 | [
"def",
"_calculate_fake_duration",
"(",
")",
":",
"utc_start_time",
"=",
"datetime",
".",
"datetime",
".",
"utcnow",
"(",
")",
"local_start_time",
"=",
"utc_start_time",
"-",
"(",
"datetime",
".",
"datetime",
".",
"utcnow",
"(",
")",
"-",
"datetime",
".",
"d... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | get_accumulator_dir | Return the directory that accumulator data is stored in, creating it if it
doesn't exist. | salt/state.py | def get_accumulator_dir(cachedir):
'''
Return the directory that accumulator data is stored in, creating it if it
doesn't exist.
'''
fn_ = os.path.join(cachedir, 'accumulator')
if not os.path.isdir(fn_):
# accumulator_dir is not present, create it
os.makedirs(fn_)
return fn_ | def get_accumulator_dir(cachedir):
'''
Return the directory that accumulator data is stored in, creating it if it
doesn't exist.
'''
fn_ = os.path.join(cachedir, 'accumulator')
if not os.path.isdir(fn_):
# accumulator_dir is not present, create it
os.makedirs(fn_)
return fn_ | [
"Return",
"the",
"directory",
"that",
"accumulator",
"data",
"is",
"stored",
"in",
"creating",
"it",
"if",
"it",
"doesn",
"t",
"exist",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L195-L204 | [
"def",
"get_accumulator_dir",
"(",
"cachedir",
")",
":",
"fn_",
"=",
"os",
".",
"path",
".",
"join",
"(",
"cachedir",
",",
"'accumulator'",
")",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"fn_",
")",
":",
"# accumulator_dir is not present, create it"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | trim_req | Trim any function off of a requisite | salt/state.py | def trim_req(req):
'''
Trim any function off of a requisite
'''
reqfirst = next(iter(req))
if '.' in reqfirst:
return {reqfirst.split('.')[0]: req[reqfirst]}
return req | def trim_req(req):
'''
Trim any function off of a requisite
'''
reqfirst = next(iter(req))
if '.' in reqfirst:
return {reqfirst.split('.')[0]: req[reqfirst]}
return req | [
"Trim",
"any",
"function",
"off",
"of",
"a",
"requisite"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L207-L214 | [
"def",
"trim_req",
"(",
"req",
")",
":",
"reqfirst",
"=",
"next",
"(",
"iter",
"(",
"req",
")",
")",
"if",
"'.'",
"in",
"reqfirst",
":",
"return",
"{",
"reqfirst",
".",
"split",
"(",
"'.'",
")",
"[",
"0",
"]",
":",
"req",
"[",
"reqfirst",
"]",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | state_args | Return a set of the arguments passed to the named state | salt/state.py | def state_args(id_, state, high):
'''
Return a set of the arguments passed to the named state
'''
args = set()
if id_ not in high:
return args
if state not in high[id_]:
return args
for item in high[id_][state]:
if not isinstance(item, dict):
continue
... | def state_args(id_, state, high):
'''
Return a set of the arguments passed to the named state
'''
args = set()
if id_ not in high:
return args
if state not in high[id_]:
return args
for item in high[id_][state]:
if not isinstance(item, dict):
continue
... | [
"Return",
"a",
"set",
"of",
"the",
"arguments",
"passed",
"to",
"the",
"named",
"state"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L217-L232 | [
"def",
"state_args",
"(",
"id_",
",",
"state",
",",
"high",
")",
":",
"args",
"=",
"set",
"(",
")",
"if",
"id_",
"not",
"in",
"high",
":",
"return",
"args",
"if",
"state",
"not",
"in",
"high",
"[",
"id_",
"]",
":",
"return",
"args",
"for",
"item"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | find_name | Scan high data for the id referencing the given name and return a list of (IDs, state) tuples that match
Note: if `state` is sls, then we are looking for all IDs that match the given SLS | salt/state.py | def find_name(name, state, high):
'''
Scan high data for the id referencing the given name and return a list of (IDs, state) tuples that match
Note: if `state` is sls, then we are looking for all IDs that match the given SLS
'''
ext_id = []
if name in high:
ext_id.append((name, state))
... | def find_name(name, state, high):
'''
Scan high data for the id referencing the given name and return a list of (IDs, state) tuples that match
Note: if `state` is sls, then we are looking for all IDs that match the given SLS
'''
ext_id = []
if name in high:
ext_id.append((name, state))
... | [
"Scan",
"high",
"data",
"for",
"the",
"id",
"referencing",
"the",
"given",
"name",
"and",
"return",
"a",
"list",
"of",
"(",
"IDs",
"state",
")",
"tuples",
"that",
"match"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L235-L262 | [
"def",
"find_name",
"(",
"name",
",",
"state",
",",
"high",
")",
":",
"ext_id",
"=",
"[",
"]",
"if",
"name",
"in",
"high",
":",
"ext_id",
".",
"append",
"(",
"(",
"name",
",",
"state",
")",
")",
"# if we are requiring an entire SLS, then we need to add ourse... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | find_sls_ids | Scan for all ids in the given sls and return them in a dict; {name: state} | salt/state.py | def find_sls_ids(sls, high):
'''
Scan for all ids in the given sls and return them in a dict; {name: state}
'''
ret = []
for nid, item in six.iteritems(high):
try:
sls_tgt = item['__sls__']
except TypeError:
if nid != '__exclude__':
log.error(
... | def find_sls_ids(sls, high):
'''
Scan for all ids in the given sls and return them in a dict; {name: state}
'''
ret = []
for nid, item in six.iteritems(high):
try:
sls_tgt = item['__sls__']
except TypeError:
if nid != '__exclude__':
log.error(
... | [
"Scan",
"for",
"all",
"ids",
"in",
"the",
"given",
"sls",
"and",
"return",
"them",
"in",
"a",
"dict",
";",
"{",
"name",
":",
"state",
"}"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L265-L286 | [
"def",
"find_sls_ids",
"(",
"sls",
",",
"high",
")",
":",
"ret",
"=",
"[",
"]",
"for",
"nid",
",",
"item",
"in",
"six",
".",
"iteritems",
"(",
"high",
")",
":",
"try",
":",
"sls_tgt",
"=",
"item",
"[",
"'__sls__'",
"]",
"except",
"TypeError",
":",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | format_log | Format the state into a log message | salt/state.py | def format_log(ret):
'''
Format the state into a log message
'''
msg = ''
if isinstance(ret, dict):
# Looks like the ret may be a valid state return
if 'changes' in ret:
# Yep, looks like a valid state return
chg = ret['changes']
if not chg:
... | def format_log(ret):
'''
Format the state into a log message
'''
msg = ''
if isinstance(ret, dict):
# Looks like the ret may be a valid state return
if 'changes' in ret:
# Yep, looks like a valid state return
chg = ret['changes']
if not chg:
... | [
"Format",
"the",
"state",
"into",
"a",
"log",
"message"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L289-L330 | [
"def",
"format_log",
"(",
"ret",
")",
":",
"msg",
"=",
"''",
"if",
"isinstance",
"(",
"ret",
",",
"dict",
")",
":",
"# Looks like the ret may be a valid state return",
"if",
"'changes'",
"in",
"ret",
":",
"# Yep, looks like a valid state return",
"chg",
"=",
"ret"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | master_compile | Compile the master side low state data, and build the hidden state file | salt/state.py | def master_compile(master_opts, minion_opts, grains, id_, saltenv):
'''
Compile the master side low state data, and build the hidden state file
'''
st_ = MasterHighState(master_opts, minion_opts, grains, id_, saltenv)
return st_.compile_highstate() | def master_compile(master_opts, minion_opts, grains, id_, saltenv):
'''
Compile the master side low state data, and build the hidden state file
'''
st_ = MasterHighState(master_opts, minion_opts, grains, id_, saltenv)
return st_.compile_highstate() | [
"Compile",
"the",
"master",
"side",
"low",
"state",
"data",
"and",
"build",
"the",
"hidden",
"state",
"file"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L333-L338 | [
"def",
"master_compile",
"(",
"master_opts",
",",
"minion_opts",
",",
"grains",
",",
"id_",
",",
"saltenv",
")",
":",
"st_",
"=",
"MasterHighState",
"(",
"master_opts",
",",
"minion_opts",
",",
"grains",
",",
"id_",
",",
"saltenv",
")",
"return",
"st_",
".... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Compiler.render_template | Enforce the states in a template | salt/state.py | def render_template(self, template, **kwargs):
'''
Enforce the states in a template
'''
high = compile_template(template,
self.rend,
self.opts['renderer'],
self.opts['renderer_blacklist'],
... | def render_template(self, template, **kwargs):
'''
Enforce the states in a template
'''
high = compile_template(template,
self.rend,
self.opts['renderer'],
self.opts['renderer_blacklist'],
... | [
"Enforce",
"the",
"states",
"in",
"a",
"template"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L381-L393 | [
"def",
"render_template",
"(",
"self",
",",
"template",
",",
"*",
"*",
"kwargs",
")",
":",
"high",
"=",
"compile_template",
"(",
"template",
",",
"self",
".",
"rend",
",",
"self",
".",
"opts",
"[",
"'renderer'",
"]",
",",
"self",
".",
"opts",
"[",
"'... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Compiler.pad_funcs | Turns dot delimited function refs into function strings | salt/state.py | def pad_funcs(self, high):
'''
Turns dot delimited function refs into function strings
'''
for name in high:
if not isinstance(high[name], dict):
if isinstance(high[name], six.string_types):
# Is this is a short state? It needs to be padded... | def pad_funcs(self, high):
'''
Turns dot delimited function refs into function strings
'''
for name in high:
if not isinstance(high[name], dict):
if isinstance(high[name], six.string_types):
# Is this is a short state? It needs to be padded... | [
"Turns",
"dot",
"delimited",
"function",
"refs",
"into",
"function",
"strings"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L395-L442 | [
"def",
"pad_funcs",
"(",
"self",
",",
"high",
")",
":",
"for",
"name",
"in",
"high",
":",
"if",
"not",
"isinstance",
"(",
"high",
"[",
"name",
"]",
",",
"dict",
")",
":",
"if",
"isinstance",
"(",
"high",
"[",
"name",
"]",
",",
"six",
".",
"string... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Compiler.verify_high | Verify that the high data is viable and follows the data structure | salt/state.py | def verify_high(self, high):
'''
Verify that the high data is viable and follows the data structure
'''
errors = []
if not isinstance(high, dict):
errors.append('High data is not a dictionary and is invalid')
reqs = OrderedDict()
for name, body in six.... | def verify_high(self, high):
'''
Verify that the high data is viable and follows the data structure
'''
errors = []
if not isinstance(high, dict):
errors.append('High data is not a dictionary and is invalid')
reqs = OrderedDict()
for name, body in six.... | [
"Verify",
"that",
"the",
"high",
"data",
"is",
"viable",
"and",
"follows",
"the",
"data",
"structure"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L444-L584 | [
"def",
"verify_high",
"(",
"self",
",",
"high",
")",
":",
"errors",
"=",
"[",
"]",
"if",
"not",
"isinstance",
"(",
"high",
",",
"dict",
")",
":",
"errors",
".",
"append",
"(",
"'High data is not a dictionary and is invalid'",
")",
"reqs",
"=",
"OrderedDict",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Compiler.order_chunks | Sort the chunk list verifying that the chunks follow the order
specified in the order options. | salt/state.py | def order_chunks(self, chunks):
'''
Sort the chunk list verifying that the chunks follow the order
specified in the order options.
'''
cap = 1
for chunk in chunks:
if 'order' in chunk:
if not isinstance(chunk['order'], int):
... | def order_chunks(self, chunks):
'''
Sort the chunk list verifying that the chunks follow the order
specified in the order options.
'''
cap = 1
for chunk in chunks:
if 'order' in chunk:
if not isinstance(chunk['order'], int):
... | [
"Sort",
"the",
"chunk",
"list",
"verifying",
"that",
"the",
"chunks",
"follow",
"the",
"order",
"specified",
"in",
"the",
"order",
"options",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L586-L618 | [
"def",
"order_chunks",
"(",
"self",
",",
"chunks",
")",
":",
"cap",
"=",
"1",
"for",
"chunk",
"in",
"chunks",
":",
"if",
"'order'",
"in",
"chunk",
":",
"if",
"not",
"isinstance",
"(",
"chunk",
"[",
"'order'",
"]",
",",
"int",
")",
":",
"continue",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Compiler.apply_exclude | Read in the __exclude__ list and remove all excluded objects from the
high data | salt/state.py | def apply_exclude(self, high):
'''
Read in the __exclude__ list and remove all excluded objects from the
high data
'''
if '__exclude__' not in high:
return high
ex_sls = set()
ex_id = set()
exclude = high.pop('__exclude__')
for exc in e... | def apply_exclude(self, high):
'''
Read in the __exclude__ list and remove all excluded objects from the
high data
'''
if '__exclude__' not in high:
return high
ex_sls = set()
ex_id = set()
exclude = high.pop('__exclude__')
for exc in e... | [
"Read",
"in",
"the",
"__exclude__",
"list",
"and",
"remove",
"all",
"excluded",
"objects",
"from",
"the",
"high",
"data"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L677-L711 | [
"def",
"apply_exclude",
"(",
"self",
",",
"high",
")",
":",
"if",
"'__exclude__'",
"not",
"in",
"high",
":",
"return",
"high",
"ex_sls",
"=",
"set",
"(",
")",
"ex_id",
"=",
"set",
"(",
")",
"exclude",
"=",
"high",
".",
"pop",
"(",
"'__exclude__'",
")... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._gather_pillar | Whenever a state run starts, gather the pillar data fresh | salt/state.py | def _gather_pillar(self):
'''
Whenever a state run starts, gather the pillar data fresh
'''
if self._pillar_override:
if self._pillar_enc:
try:
self._pillar_override = salt.utils.crypt.decrypt(
self._pillar_override,... | def _gather_pillar(self):
'''
Whenever a state run starts, gather the pillar data fresh
'''
if self._pillar_override:
if self._pillar_enc:
try:
self._pillar_override = salt.utils.crypt.decrypt(
self._pillar_override,... | [
"Whenever",
"a",
"state",
"run",
"starts",
"gather",
"the",
"pillar",
"data",
"fresh"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L767-L808 | [
"def",
"_gather_pillar",
"(",
"self",
")",
":",
"if",
"self",
".",
"_pillar_override",
":",
"if",
"self",
".",
"_pillar_enc",
":",
"try",
":",
"self",
".",
"_pillar_override",
"=",
"salt",
".",
"utils",
".",
"crypt",
".",
"decrypt",
"(",
"self",
".",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._mod_init | Check the module initialization function, if this is the first run
of a state package that has a mod_init function, then execute the
mod_init function in the state module. | salt/state.py | def _mod_init(self, low):
'''
Check the module initialization function, if this is the first run
of a state package that has a mod_init function, then execute the
mod_init function in the state module.
'''
# ensure that the module is loaded
try:
self.s... | def _mod_init(self, low):
'''
Check the module initialization function, if this is the first run
of a state package that has a mod_init function, then execute the
mod_init function in the state module.
'''
# ensure that the module is loaded
try:
self.s... | [
"Check",
"the",
"module",
"initialization",
"function",
"if",
"this",
"is",
"the",
"first",
"run",
"of",
"a",
"state",
"package",
"that",
"has",
"a",
"mod_init",
"function",
"then",
"execute",
"the",
"mod_init",
"function",
"in",
"the",
"state",
"module",
".... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L810-L827 | [
"def",
"_mod_init",
"(",
"self",
",",
"low",
")",
":",
"# ensure that the module is loaded",
"try",
":",
"self",
".",
"states",
"[",
"'{0}.{1}'",
".",
"format",
"(",
"low",
"[",
"'state'",
"]",
",",
"low",
"[",
"'fun'",
"]",
")",
"]",
"# pylint: disable=W0... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._mod_aggregate | Execute the aggregation systems to runtime modify the low chunk | salt/state.py | def _mod_aggregate(self, low, running, chunks):
'''
Execute the aggregation systems to runtime modify the low chunk
'''
agg_opt = self.functions['config.option']('state_aggregate')
if 'aggregate' in low:
agg_opt = low['aggregate']
if agg_opt is True:
... | def _mod_aggregate(self, low, running, chunks):
'''
Execute the aggregation systems to runtime modify the low chunk
'''
agg_opt = self.functions['config.option']('state_aggregate')
if 'aggregate' in low:
agg_opt = low['aggregate']
if agg_opt is True:
... | [
"Execute",
"the",
"aggregation",
"systems",
"to",
"runtime",
"modify",
"the",
"low",
"chunk"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L829-L848 | [
"def",
"_mod_aggregate",
"(",
"self",
",",
"low",
",",
"running",
",",
"chunks",
")",
":",
"agg_opt",
"=",
"self",
".",
"functions",
"[",
"'config.option'",
"]",
"(",
"'state_aggregate'",
")",
"if",
"'aggregate'",
"in",
"low",
":",
"agg_opt",
"=",
"low",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._run_check | Check that unless doesn't return 0, and that onlyif returns a 0. | salt/state.py | def _run_check(self, low_data):
'''
Check that unless doesn't return 0, and that onlyif returns a 0.
'''
ret = {'result': False, 'comment': []}
cmd_opts = {}
if 'shell' in self.opts['grains']:
cmd_opts['shell'] = self.opts['grains'].get('shell')
if '... | def _run_check(self, low_data):
'''
Check that unless doesn't return 0, and that onlyif returns a 0.
'''
ret = {'result': False, 'comment': []}
cmd_opts = {}
if 'shell' in self.opts['grains']:
cmd_opts['shell'] = self.opts['grains'].get('shell')
if '... | [
"Check",
"that",
"unless",
"doesn",
"t",
"return",
"0",
"and",
"that",
"onlyif",
"returns",
"a",
"0",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L850-L876 | [
"def",
"_run_check",
"(",
"self",
",",
"low_data",
")",
":",
"ret",
"=",
"{",
"'result'",
":",
"False",
",",
"'comment'",
":",
"[",
"]",
"}",
"cmd_opts",
"=",
"{",
"}",
"if",
"'shell'",
"in",
"self",
".",
"opts",
"[",
"'grains'",
"]",
":",
"cmd_opt... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._run_check_onlyif | Check that unless doesn't return 0, and that onlyif returns a 0. | salt/state.py | def _run_check_onlyif(self, low_data, cmd_opts):
'''
Check that unless doesn't return 0, and that onlyif returns a 0.
'''
ret = {'result': False}
if not isinstance(low_data['onlyif'], list):
low_data_onlyif = [low_data['onlyif']]
else:
low_data_on... | def _run_check_onlyif(self, low_data, cmd_opts):
'''
Check that unless doesn't return 0, and that onlyif returns a 0.
'''
ret = {'result': False}
if not isinstance(low_data['onlyif'], list):
low_data_onlyif = [low_data['onlyif']]
else:
low_data_on... | [
"Check",
"that",
"unless",
"doesn",
"t",
"return",
"0",
"and",
"that",
"onlyif",
"returns",
"a",
"0",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L878-L921 | [
"def",
"_run_check_onlyif",
"(",
"self",
",",
"low_data",
",",
"cmd_opts",
")",
":",
"ret",
"=",
"{",
"'result'",
":",
"False",
"}",
"if",
"not",
"isinstance",
"(",
"low_data",
"[",
"'onlyif'",
"]",
",",
"list",
")",
":",
"low_data_onlyif",
"=",
"[",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._run_check_cmd | Alter the way a successful state run is determined | salt/state.py | def _run_check_cmd(self, low_data):
'''
Alter the way a successful state run is determined
'''
ret = {'result': False}
cmd_opts = {}
if 'shell' in self.opts['grains']:
cmd_opts['shell'] = self.opts['grains'].get('shell')
for entry in low_data['check_cm... | def _run_check_cmd(self, low_data):
'''
Alter the way a successful state run is determined
'''
ret = {'result': False}
cmd_opts = {}
if 'shell' in self.opts['grains']:
cmd_opts['shell'] = self.opts['grains'].get('shell')
for entry in low_data['check_cm... | [
"Alter",
"the",
"way",
"a",
"successful",
"state",
"run",
"is",
"determined"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L968-L985 | [
"def",
"_run_check_cmd",
"(",
"self",
",",
"low_data",
")",
":",
"ret",
"=",
"{",
"'result'",
":",
"False",
"}",
"cmd_opts",
"=",
"{",
"}",
"if",
"'shell'",
"in",
"self",
".",
"opts",
"[",
"'grains'",
"]",
":",
"cmd_opts",
"[",
"'shell'",
"]",
"=",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._load_states | Read the state loader value and loadup the correct states subsystem | salt/state.py | def _load_states(self):
'''
Read the state loader value and loadup the correct states subsystem
'''
if self.states_loader == 'thorium':
self.states = salt.loader.thorium(self.opts, self.functions, {}) # TODO: Add runners, proxy?
else:
self.states = salt.l... | def _load_states(self):
'''
Read the state loader value and loadup the correct states subsystem
'''
if self.states_loader == 'thorium':
self.states = salt.loader.thorium(self.opts, self.functions, {}) # TODO: Add runners, proxy?
else:
self.states = salt.l... | [
"Read",
"the",
"state",
"loader",
"value",
"and",
"loadup",
"the",
"correct",
"states",
"subsystem"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L993-L1001 | [
"def",
"_load_states",
"(",
"self",
")",
":",
"if",
"self",
".",
"states_loader",
"==",
"'thorium'",
":",
"self",
".",
"states",
"=",
"salt",
".",
"loader",
".",
"thorium",
"(",
"self",
".",
"opts",
",",
"self",
".",
"functions",
",",
"{",
"}",
")",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.load_modules | Load the modules into the state | salt/state.py | def load_modules(self, data=None, proxy=None):
'''
Load the modules into the state
'''
log.info('Loading fresh modules for state activity')
self.utils = salt.loader.utils(self.opts)
self.functions = salt.loader.minion_mods(self.opts, self.state_con,
... | def load_modules(self, data=None, proxy=None):
'''
Load the modules into the state
'''
log.info('Loading fresh modules for state activity')
self.utils = salt.loader.utils(self.opts)
self.functions = salt.loader.minion_mods(self.opts, self.state_con,
... | [
"Load",
"the",
"modules",
"into",
"the",
"state"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1003-L1035 | [
"def",
"load_modules",
"(",
"self",
",",
"data",
"=",
"None",
",",
"proxy",
"=",
"None",
")",
":",
"log",
".",
"info",
"(",
"'Loading fresh modules for state activity'",
")",
"self",
".",
"utils",
"=",
"salt",
".",
"loader",
".",
"utils",
"(",
"self",
".... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.module_refresh | Refresh all the modules | salt/state.py | def module_refresh(self):
'''
Refresh all the modules
'''
log.debug('Refreshing modules...')
if self.opts['grains'].get('os') != 'MacOS':
# In case a package has been installed into the current python
# process 'site-packages', the 'site' module needs to b... | def module_refresh(self):
'''
Refresh all the modules
'''
log.debug('Refreshing modules...')
if self.opts['grains'].get('os') != 'MacOS':
# In case a package has been installed into the current python
# process 'site-packages', the 'site' module needs to b... | [
"Refresh",
"all",
"the",
"modules"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1037-L1054 | [
"def",
"module_refresh",
"(",
"self",
")",
":",
"log",
".",
"debug",
"(",
"'Refreshing modules...'",
")",
"if",
"self",
".",
"opts",
"[",
"'grains'",
"]",
".",
"get",
"(",
"'os'",
")",
"!=",
"'MacOS'",
":",
"# In case a package has been installed into the curren... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.check_refresh | Check to see if the modules for this state instance need to be updated,
only update if the state is a file or a package and if it changed
something. If the file function is managed check to see if the file is a
possible module type, e.g. a python, pyx, or .so. Always refresh if the
funct... | salt/state.py | def check_refresh(self, data, ret):
'''
Check to see if the modules for this state instance need to be updated,
only update if the state is a file or a package and if it changed
something. If the file function is managed check to see if the file is a
possible module type, e.g. a ... | def check_refresh(self, data, ret):
'''
Check to see if the modules for this state instance need to be updated,
only update if the state is a file or a package and if it changed
something. If the file function is managed check to see if the file is a
possible module type, e.g. a ... | [
"Check",
"to",
"see",
"if",
"the",
"modules",
"for",
"this",
"state",
"instance",
"need",
"to",
"be",
"updated",
"only",
"update",
"if",
"the",
"state",
"is",
"a",
"file",
"or",
"a",
"package",
"and",
"if",
"it",
"changed",
"something",
".",
"If",
"the... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1056-L1096 | [
"def",
"check_refresh",
"(",
"self",
",",
"data",
",",
"ret",
")",
":",
"_reload_modules",
"=",
"False",
"if",
"data",
".",
"get",
"(",
"'reload_grains'",
",",
"False",
")",
":",
"log",
".",
"debug",
"(",
"'Refreshing grains...'",
")",
"self",
".",
"opts... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.verify_data | Verify the data, return an error statement if something is wrong | salt/state.py | def verify_data(self, data):
'''
Verify the data, return an error statement if something is wrong
'''
errors = []
if 'state' not in data:
errors.append('Missing "state" data')
if 'fun' not in data:
errors.append('Missing "fun" data')
if 'na... | def verify_data(self, data):
'''
Verify the data, return an error statement if something is wrong
'''
errors = []
if 'state' not in data:
errors.append('Missing "state" data')
if 'fun' not in data:
errors.append('Missing "fun" data')
if 'na... | [
"Verify",
"the",
"data",
"return",
"an",
"error",
"statement",
"if",
"something",
"is",
"wrong"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1098-L1186 | [
"def",
"verify_data",
"(",
"self",
",",
"data",
")",
":",
"errors",
"=",
"[",
"]",
"if",
"'state'",
"not",
"in",
"data",
":",
"errors",
".",
"append",
"(",
"'Missing \"state\" data'",
")",
"if",
"'fun'",
"not",
"in",
"data",
":",
"errors",
".",
"append... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.verify_chunks | Verify the chunks in a list of low data structures | salt/state.py | def verify_chunks(self, chunks):
'''
Verify the chunks in a list of low data structures
'''
err = []
for chunk in chunks:
err.extend(self.verify_data(chunk))
return err | def verify_chunks(self, chunks):
'''
Verify the chunks in a list of low data structures
'''
err = []
for chunk in chunks:
err.extend(self.verify_data(chunk))
return err | [
"Verify",
"the",
"chunks",
"in",
"a",
"list",
"of",
"low",
"data",
"structures"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1346-L1353 | [
"def",
"verify_chunks",
"(",
"self",
",",
"chunks",
")",
":",
"err",
"=",
"[",
"]",
"for",
"chunk",
"in",
"chunks",
":",
"err",
".",
"extend",
"(",
"self",
".",
"verify_data",
"(",
"chunk",
")",
")",
"return",
"err"
] | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.order_chunks | Sort the chunk list verifying that the chunks follow the order
specified in the order options. | salt/state.py | def order_chunks(self, chunks):
'''
Sort the chunk list verifying that the chunks follow the order
specified in the order options.
'''
cap = 1
for chunk in chunks:
if 'order' in chunk:
if not isinstance(chunk['order'], int):
... | def order_chunks(self, chunks):
'''
Sort the chunk list verifying that the chunks follow the order
specified in the order options.
'''
cap = 1
for chunk in chunks:
if 'order' in chunk:
if not isinstance(chunk['order'], int):
... | [
"Sort",
"the",
"chunk",
"list",
"verifying",
"that",
"the",
"chunks",
"follow",
"the",
"order",
"specified",
"in",
"the",
"order",
"options",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1355-L1386 | [
"def",
"order_chunks",
"(",
"self",
",",
"chunks",
")",
":",
"cap",
"=",
"1",
"for",
"chunk",
"in",
"chunks",
":",
"if",
"'order'",
"in",
"chunk",
":",
"if",
"not",
"isinstance",
"(",
"chunk",
"[",
"'order'",
"]",
",",
"int",
")",
":",
"continue",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.compile_high_data | "Compile" the high data as it is retrieved from the CLI or YAML into
the individual state executor structures | salt/state.py | def compile_high_data(self, high, orchestration_jid=None):
'''
"Compile" the high data as it is retrieved from the CLI or YAML into
the individual state executor structures
'''
chunks = []
for name, body in six.iteritems(high):
if name.startswith('__'):
... | def compile_high_data(self, high, orchestration_jid=None):
'''
"Compile" the high data as it is retrieved from the CLI or YAML into
the individual state executor structures
'''
chunks = []
for name, body in six.iteritems(high):
if name.startswith('__'):
... | [
"Compile",
"the",
"high",
"data",
"as",
"it",
"is",
"retrieved",
"from",
"the",
"CLI",
"or",
"YAML",
"into",
"the",
"individual",
"state",
"executor",
"structures"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1388-L1452 | [
"def",
"compile_high_data",
"(",
"self",
",",
"high",
",",
"orchestration_jid",
"=",
"None",
")",
":",
"chunks",
"=",
"[",
"]",
"for",
"name",
",",
"body",
"in",
"six",
".",
"iteritems",
"(",
"high",
")",
":",
"if",
"name",
".",
"startswith",
"(",
"'... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.reconcile_extend | Pull the extend data and add it to the respective high data | salt/state.py | def reconcile_extend(self, high):
'''
Pull the extend data and add it to the respective high data
'''
errors = []
if '__extend__' not in high:
return high, errors
ext = high.pop('__extend__')
for ext_chunk in ext:
for name, body in six.iter... | def reconcile_extend(self, high):
'''
Pull the extend data and add it to the respective high data
'''
errors = []
if '__extend__' not in high:
return high, errors
ext = high.pop('__extend__')
for ext_chunk in ext:
for name, body in six.iter... | [
"Pull",
"the",
"extend",
"data",
"and",
"add",
"it",
"to",
"the",
"respective",
"high",
"data"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1454-L1520 | [
"def",
"reconcile_extend",
"(",
"self",
",",
"high",
")",
":",
"errors",
"=",
"[",
"]",
"if",
"'__extend__'",
"not",
"in",
"high",
":",
"return",
"high",
",",
"errors",
"ext",
"=",
"high",
".",
"pop",
"(",
"'__extend__'",
")",
"for",
"ext_chunk",
"in",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.requisite_in | Extend the data reference with requisite_in arguments | salt/state.py | def requisite_in(self, high):
'''
Extend the data reference with requisite_in arguments
'''
req_in = {'require_in', 'watch_in', 'onfail_in', 'onchanges_in', 'use', 'use_in', 'prereq', 'prereq_in'}
req_in_all = req_in.union({'require', 'watch', 'onfail', 'onfail_stop', 'onchanges'... | def requisite_in(self, high):
'''
Extend the data reference with requisite_in arguments
'''
req_in = {'require_in', 'watch_in', 'onfail_in', 'onchanges_in', 'use', 'use_in', 'prereq', 'prereq_in'}
req_in_all = req_in.union({'require', 'watch', 'onfail', 'onfail_stop', 'onchanges'... | [
"Extend",
"the",
"data",
"reference",
"with",
"requisite_in",
"arguments"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1562-L1787 | [
"def",
"requisite_in",
"(",
"self",
",",
"high",
")",
":",
"req_in",
"=",
"{",
"'require_in'",
",",
"'watch_in'",
",",
"'onfail_in'",
",",
"'onchanges_in'",
",",
"'use'",
",",
"'use_in'",
",",
"'prereq'",
",",
"'prereq_in'",
"}",
"req_in_all",
"=",
"req_in",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State._call_parallel_target | The target function to call that will create the parallel thread/process | salt/state.py | def _call_parallel_target(self, name, cdata, low):
'''
The target function to call that will create the parallel thread/process
'''
# we need to re-record start/end duration here because it is impossible to
# correctly calculate further down the chain
utc_start_time = dat... | def _call_parallel_target(self, name, cdata, low):
'''
The target function to call that will create the parallel thread/process
'''
# we need to re-record start/end duration here because it is impossible to
# correctly calculate further down the chain
utc_start_time = dat... | [
"The",
"target",
"function",
"to",
"call",
"that",
"will",
"create",
"the",
"parallel",
"thread",
"/",
"process"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1789-L1830 | [
"def",
"_call_parallel_target",
"(",
"self",
",",
"name",
",",
"cdata",
",",
"low",
")",
":",
"# we need to re-record start/end duration here because it is impossible to",
"# correctly calculate further down the chain",
"utc_start_time",
"=",
"datetime",
".",
"datetime",
".",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_parallel | Call the state defined in the given cdata in parallel | salt/state.py | def call_parallel(self, cdata, low):
'''
Call the state defined in the given cdata in parallel
'''
# There are a number of possibilities to not have the cdata
# populated with what we might have expected, so just be smart
# enough to not raise another KeyError as the name... | def call_parallel(self, cdata, low):
'''
Call the state defined in the given cdata in parallel
'''
# There are a number of possibilities to not have the cdata
# populated with what we might have expected, so just be smart
# enough to not raise another KeyError as the name... | [
"Call",
"the",
"state",
"defined",
"in",
"the",
"given",
"cdata",
"in",
"parallel"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1832-L1854 | [
"def",
"call_parallel",
"(",
"self",
",",
"cdata",
",",
"low",
")",
":",
"# There are a number of possibilities to not have the cdata",
"# populated with what we might have expected, so just be smart",
"# enough to not raise another KeyError as the name is easily",
"# guessable and fallbac... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call | Call a state directly with the low data structure, verify data
before processing. | salt/state.py | def call(self, low, chunks=None, running=None, retries=1):
'''
Call a state directly with the low data structure, verify data
before processing.
'''
use_uptime = False
if os.path.isfile('/proc/uptime'):
use_uptime = True
with salt.utils.files.fopen... | def call(self, low, chunks=None, running=None, retries=1):
'''
Call a state directly with the low data structure, verify data
before processing.
'''
use_uptime = False
if os.path.isfile('/proc/uptime'):
use_uptime = True
with salt.utils.files.fopen... | [
"Call",
"a",
"state",
"directly",
"with",
"the",
"low",
"data",
"structure",
"verify",
"data",
"before",
"processing",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L1857-L2100 | [
"def",
"call",
"(",
"self",
",",
"low",
",",
"chunks",
"=",
"None",
",",
"running",
"=",
"None",
",",
"retries",
"=",
"1",
")",
":",
"use_uptime",
"=",
"False",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"'/proc/uptime'",
")",
":",
"use_uptime",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.format_slots | Read in the arguments from the low level slot syntax to make a last
minute runtime call to gather relevant data for the specific routine
Will parse strings, first level of dictionary values, and strings and
first level dict values inside of lists | salt/state.py | def format_slots(self, cdata):
'''
Read in the arguments from the low level slot syntax to make a last
minute runtime call to gather relevant data for the specific routine
Will parse strings, first level of dictionary values, and strings and
first level dict values inside of lis... | def format_slots(self, cdata):
'''
Read in the arguments from the low level slot syntax to make a last
minute runtime call to gather relevant data for the specific routine
Will parse strings, first level of dictionary values, and strings and
first level dict values inside of lis... | [
"Read",
"in",
"the",
"arguments",
"from",
"the",
"low",
"level",
"slot",
"syntax",
"to",
"make",
"a",
"last",
"minute",
"runtime",
"call",
"to",
"gather",
"relevant",
"data",
"for",
"the",
"specific",
"routine"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2159-L2209 | [
"def",
"format_slots",
"(",
"self",
",",
"cdata",
")",
":",
"# __slot__:salt.cmd.run(foo, bar, baz=qux)",
"SLOT_TEXT",
"=",
"'__slot__:'",
"ctx",
"=",
"(",
"(",
"'args'",
",",
"enumerate",
"(",
"cdata",
"[",
"'args'",
"]",
")",
")",
",",
"(",
"'kwargs'",
","... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.verify_retry_data | verifies the specified retry data | salt/state.py | def verify_retry_data(self, retry_data):
'''
verifies the specified retry data
'''
retry_defaults = {
'until': True,
'attempts': 2,
'splay': 0,
'interval': 30,
}
expected_data = {
'until': bool,
... | def verify_retry_data(self, retry_data):
'''
verifies the specified retry data
'''
retry_defaults = {
'until': True,
'attempts': 2,
'splay': 0,
'interval': 30,
}
expected_data = {
'until': bool,
... | [
"verifies",
"the",
"specified",
"retry",
"data"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2211-L2246 | [
"def",
"verify_retry_data",
"(",
"self",
",",
"retry_data",
")",
":",
"retry_defaults",
"=",
"{",
"'until'",
":",
"True",
",",
"'attempts'",
":",
"2",
",",
"'splay'",
":",
"0",
",",
"'interval'",
":",
"30",
",",
"}",
"expected_data",
"=",
"{",
"'until'",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_chunks | Iterate over a list of chunks and call them, checking for requires. | salt/state.py | def call_chunks(self, chunks):
'''
Iterate over a list of chunks and call them, checking for requires.
'''
# Check for any disabled states
disabled = {}
if 'state_runs_disabled' in self.opts['grains']:
for low in chunks[:]:
state_ = '{0}.{1}'.f... | def call_chunks(self, chunks):
'''
Iterate over a list of chunks and call them, checking for requires.
'''
# Check for any disabled states
disabled = {}
if 'state_runs_disabled' in self.opts['grains']:
for low in chunks[:]:
state_ = '{0}.{1}'.f... | [
"Iterate",
"over",
"a",
"list",
"of",
"chunks",
"and",
"call",
"them",
"checking",
"for",
"requires",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2248-L2295 | [
"def",
"call_chunks",
"(",
"self",
",",
"chunks",
")",
":",
"# Check for any disabled states",
"disabled",
"=",
"{",
"}",
"if",
"'state_runs_disabled'",
"in",
"self",
".",
"opts",
"[",
"'grains'",
"]",
":",
"for",
"low",
"in",
"chunks",
"[",
":",
"]",
":",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.check_failhard | Check if the low data chunk should send a failhard signal | salt/state.py | def check_failhard(self, low, running):
'''
Check if the low data chunk should send a failhard signal
'''
tag = _gen_tag(low)
if self.opts.get('test', False):
return False
if low.get('failhard', self.opts['failhard']) and tag in running:
if running... | def check_failhard(self, low, running):
'''
Check if the low data chunk should send a failhard signal
'''
tag = _gen_tag(low)
if self.opts.get('test', False):
return False
if low.get('failhard', self.opts['failhard']) and tag in running:
if running... | [
"Check",
"if",
"the",
"low",
"data",
"chunk",
"should",
"send",
"a",
"failhard",
"signal"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2297-L2308 | [
"def",
"check_failhard",
"(",
"self",
",",
"low",
",",
"running",
")",
":",
"tag",
"=",
"_gen_tag",
"(",
"low",
")",
"if",
"self",
".",
"opts",
".",
"get",
"(",
"'test'",
",",
"False",
")",
":",
"return",
"False",
"if",
"low",
".",
"get",
"(",
"'... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.check_pause | Check to see if this low chunk has been paused | salt/state.py | def check_pause(self, low):
'''
Check to see if this low chunk has been paused
'''
if not self.jid:
# Can't pause on salt-ssh since we can't track continuous state
return
pause_path = os.path.join(self.opts['cachedir'], 'state_pause', self.jid)
sta... | def check_pause(self, low):
'''
Check to see if this low chunk has been paused
'''
if not self.jid:
# Can't pause on salt-ssh since we can't track continuous state
return
pause_path = os.path.join(self.opts['cachedir'], 'state_pause', self.jid)
sta... | [
"Check",
"to",
"see",
"if",
"this",
"low",
"chunk",
"has",
"been",
"paused"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2310-L2353 | [
"def",
"check_pause",
"(",
"self",
",",
"low",
")",
":",
"if",
"not",
"self",
".",
"jid",
":",
"# Can't pause on salt-ssh since we can't track continuous state",
"return",
"pause_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"opts",
"[",
"'cach... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.reconcile_procs | Check the running dict for processes and resolve them | salt/state.py | def reconcile_procs(self, running):
'''
Check the running dict for processes and resolve them
'''
retset = set()
for tag in running:
proc = running[tag].get('proc')
if proc:
if not proc.is_alive():
ret_cache = os.path.jo... | def reconcile_procs(self, running):
'''
Check the running dict for processes and resolve them
'''
retset = set()
for tag in running:
proc = running[tag].get('proc')
if proc:
if not proc.is_alive():
ret_cache = os.path.jo... | [
"Check",
"the",
"running",
"dict",
"for",
"processes",
"and",
"resolve",
"them"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2355-L2385 | [
"def",
"reconcile_procs",
"(",
"self",
",",
"running",
")",
":",
"retset",
"=",
"set",
"(",
")",
"for",
"tag",
"in",
"running",
":",
"proc",
"=",
"running",
"[",
"tag",
"]",
".",
"get",
"(",
"'proc'",
")",
"if",
"proc",
":",
"if",
"not",
"proc",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.check_requisite | Look into the running data to check the status of all requisite
states | salt/state.py | def check_requisite(self, low, running, chunks, pre=False):
'''
Look into the running data to check the status of all requisite
states
'''
disabled_reqs = self.opts.get('disabled_requisites', [])
if not isinstance(disabled_reqs, list):
disabled_reqs = [disable... | def check_requisite(self, low, running, chunks, pre=False):
'''
Look into the running data to check the status of all requisite
states
'''
disabled_reqs = self.opts.get('disabled_requisites', [])
if not isinstance(disabled_reqs, list):
disabled_reqs = [disable... | [
"Look",
"into",
"the",
"running",
"data",
"to",
"check",
"the",
"status",
"of",
"all",
"requisite",
"states"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2387-L2572 | [
"def",
"check_requisite",
"(",
"self",
",",
"low",
",",
"running",
",",
"chunks",
",",
"pre",
"=",
"False",
")",
":",
"disabled_reqs",
"=",
"self",
".",
"opts",
".",
"get",
"(",
"'disabled_requisites'",
",",
"[",
"]",
")",
"if",
"not",
"isinstance",
"(... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.event | Fire an event on the master bus
If `fire_event` is set to True an event will be sent with the
chunk name in the tag and the chunk result in the event data.
If `fire_event` is set to a string such as `mystate/is/finished`,
an event will be sent with the string added to the tag and the c... | salt/state.py | def event(self, chunk_ret, length, fire_event=False):
'''
Fire an event on the master bus
If `fire_event` is set to True an event will be sent with the
chunk name in the tag and the chunk result in the event data.
If `fire_event` is set to a string such as `mystate/is/finished`... | def event(self, chunk_ret, length, fire_event=False):
'''
Fire an event on the master bus
If `fire_event` is set to True an event will be sent with the
chunk name in the tag and the chunk result in the event data.
If `fire_event` is set to a string such as `mystate/is/finished`... | [
"Fire",
"an",
"event",
"on",
"the",
"master",
"bus"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2574-L2611 | [
"def",
"event",
"(",
"self",
",",
"chunk_ret",
",",
"length",
",",
"fire_event",
"=",
"False",
")",
":",
"if",
"not",
"self",
".",
"opts",
".",
"get",
"(",
"'local'",
")",
"and",
"(",
"self",
".",
"opts",
".",
"get",
"(",
"'state_events'",
",",
"Tr... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_chunk | Check if a chunk has any requires, execute the requires and then
the chunk | salt/state.py | def call_chunk(self, low, running, chunks):
'''
Check if a chunk has any requires, execute the requires and then
the chunk
'''
low = self._mod_aggregate(low, running, chunks)
self._mod_init(low)
tag = _gen_tag(low)
if not low.get('prerequired'):
... | def call_chunk(self, low, running, chunks):
'''
Check if a chunk has any requires, execute the requires and then
the chunk
'''
low = self._mod_aggregate(low, running, chunks)
self._mod_init(low)
tag = _gen_tag(low)
if not low.get('prerequired'):
... | [
"Check",
"if",
"a",
"chunk",
"has",
"any",
"requires",
"execute",
"the",
"requires",
"and",
"then",
"the",
"chunk"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2613-L2841 | [
"def",
"call_chunk",
"(",
"self",
",",
"low",
",",
"running",
",",
"chunks",
")",
":",
"low",
"=",
"self",
".",
"_mod_aggregate",
"(",
"low",
",",
"running",
",",
"chunks",
")",
"self",
".",
"_mod_init",
"(",
"low",
")",
"tag",
"=",
"_gen_tag",
"(",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_listen | Find all of the listen routines and call the associated mod_watch runs | salt/state.py | def call_listen(self, chunks, running):
'''
Find all of the listen routines and call the associated mod_watch runs
'''
listeners = []
crefs = {}
for chunk in chunks:
crefs[(chunk['state'], chunk['__id__'], chunk['name'])] = chunk
if 'listen' in chu... | def call_listen(self, chunks, running):
'''
Find all of the listen routines and call the associated mod_watch runs
'''
listeners = []
crefs = {}
for chunk in chunks:
crefs[(chunk['state'], chunk['__id__'], chunk['name'])] = chunk
if 'listen' in chu... | [
"Find",
"all",
"of",
"the",
"listen",
"routines",
"and",
"call",
"the",
"associated",
"mod_watch",
"runs"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2843-L2914 | [
"def",
"call_listen",
"(",
"self",
",",
"chunks",
",",
"running",
")",
":",
"listeners",
"=",
"[",
"]",
"crefs",
"=",
"{",
"}",
"for",
"chunk",
"in",
"chunks",
":",
"crefs",
"[",
"(",
"chunk",
"[",
"'state'",
"]",
",",
"chunk",
"[",
"'__id__'",
"]"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.inject_default_call | Sets .call function to a state, if not there.
:param high:
:return: | salt/state.py | def inject_default_call(self, high):
'''
Sets .call function to a state, if not there.
:param high:
:return:
'''
for chunk in high:
state = high[chunk]
if not isinstance(state, collections.Mapping):
continue
for state_r... | def inject_default_call(self, high):
'''
Sets .call function to a state, if not there.
:param high:
:return:
'''
for chunk in high:
state = high[chunk]
if not isinstance(state, collections.Mapping):
continue
for state_r... | [
"Sets",
".",
"call",
"function",
"to",
"a",
"state",
"if",
"not",
"there",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2916-L2936 | [
"def",
"inject_default_call",
"(",
"self",
",",
"high",
")",
":",
"for",
"chunk",
"in",
"high",
":",
"state",
"=",
"high",
"[",
"chunk",
"]",
"if",
"not",
"isinstance",
"(",
"state",
",",
"collections",
".",
"Mapping",
")",
":",
"continue",
"for",
"sta... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_high | Process a high data call and ensure the defined states. | salt/state.py | def call_high(self, high, orchestration_jid=None):
'''
Process a high data call and ensure the defined states.
'''
self.inject_default_call(high)
errors = []
# If there is extension data reconcile it
high, ext_errors = self.reconcile_extend(high)
errors.ex... | def call_high(self, high, orchestration_jid=None):
'''
Process a high data call and ensure the defined states.
'''
self.inject_default_call(high)
errors = []
# If there is extension data reconcile it
high, ext_errors = self.reconcile_extend(high)
errors.ex... | [
"Process",
"a",
"high",
"data",
"call",
"and",
"ensure",
"the",
"defined",
"states",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L2938-L2986 | [
"def",
"call_high",
"(",
"self",
",",
"high",
",",
"orchestration_jid",
"=",
"None",
")",
":",
"self",
".",
"inject_default_call",
"(",
"high",
")",
"errors",
"=",
"[",
"]",
"# If there is extension data reconcile it",
"high",
",",
"ext_errors",
"=",
"self",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_template | Enforce the states in a template | salt/state.py | def call_template(self, template):
'''
Enforce the states in a template
'''
high = compile_template(template,
self.rend,
self.opts['renderer'],
self.opts['renderer_blacklist'],
... | def call_template(self, template):
'''
Enforce the states in a template
'''
high = compile_template(template,
self.rend,
self.opts['renderer'],
self.opts['renderer_blacklist'],
... | [
"Enforce",
"the",
"states",
"in",
"a",
"template"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3067-L3081 | [
"def",
"call_template",
"(",
"self",
",",
"template",
")",
":",
"high",
"=",
"compile_template",
"(",
"template",
",",
"self",
".",
"rend",
",",
"self",
".",
"opts",
"[",
"'renderer'",
"]",
",",
"self",
".",
"opts",
"[",
"'renderer_blacklist'",
"]",
",",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | State.call_template_str | Enforce the states in a template, pass the template as a string | salt/state.py | def call_template_str(self, template):
'''
Enforce the states in a template, pass the template as a string
'''
high = compile_template_str(template,
self.rend,
self.opts['renderer'],
... | def call_template_str(self, template):
'''
Enforce the states in a template, pass the template as a string
'''
high = compile_template_str(template,
self.rend,
self.opts['renderer'],
... | [
"Enforce",
"the",
"states",
"in",
"a",
"template",
"pass",
"the",
"template",
"as",
"a",
"string"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3083-L3097 | [
"def",
"call_template_str",
"(",
"self",
",",
"template",
")",
":",
"high",
"=",
"compile_template_str",
"(",
"template",
",",
"self",
".",
"rend",
",",
"self",
".",
"opts",
"[",
"'renderer'",
"]",
",",
"self",
".",
"opts",
"[",
"'renderer_blacklist'",
"]"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.__gen_opts | The options used by the High State object are derived from options
on the minion and the master, or just the minion if the high state
call is entirely local. | salt/state.py | def __gen_opts(self, opts):
'''
The options used by the High State object are derived from options
on the minion and the master, or just the minion if the high state
call is entirely local.
'''
# If the state is intended to be applied locally, then the local opts
... | def __gen_opts(self, opts):
'''
The options used by the High State object are derived from options
on the minion and the master, or just the minion if the high state
call is entirely local.
'''
# If the state is intended to be applied locally, then the local opts
... | [
"The",
"options",
"used",
"by",
"the",
"High",
"State",
"object",
"are",
"derived",
"from",
"options",
"on",
"the",
"minion",
"and",
"the",
"master",
"or",
"just",
"the",
"minion",
"if",
"the",
"high",
"state",
"call",
"is",
"entirely",
"local",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3124-L3169 | [
"def",
"__gen_opts",
"(",
"self",
",",
"opts",
")",
":",
"# If the state is intended to be applied locally, then the local opts",
"# should have all of the needed data, otherwise overwrite the local",
"# data items with data from the master",
"if",
"'local_state'",
"in",
"opts",
":",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._get_envs | Pull the file server environments out of the master options | salt/state.py | def _get_envs(self):
'''
Pull the file server environments out of the master options
'''
envs = ['base']
if 'file_roots' in self.opts:
envs.extend([x for x in list(self.opts['file_roots'])
if x not in envs])
env_order = self.opts.get('... | def _get_envs(self):
'''
Pull the file server environments out of the master options
'''
envs = ['base']
if 'file_roots' in self.opts:
envs.extend([x for x in list(self.opts['file_roots'])
if x not in envs])
env_order = self.opts.get('... | [
"Pull",
"the",
"file",
"server",
"environments",
"out",
"of",
"the",
"master",
"options"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3171-L3191 | [
"def",
"_get_envs",
"(",
"self",
")",
":",
"envs",
"=",
"[",
"'base'",
"]",
"if",
"'file_roots'",
"in",
"self",
".",
"opts",
":",
"envs",
".",
"extend",
"(",
"[",
"x",
"for",
"x",
"in",
"list",
"(",
"self",
".",
"opts",
"[",
"'file_roots'",
"]",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.get_tops | Gather the top files | salt/state.py | def get_tops(self):
'''
Gather the top files
'''
tops = DefaultOrderedDict(list)
include = DefaultOrderedDict(list)
done = DefaultOrderedDict(list)
found = 0 # did we find any contents in the top files?
# Gather initial top files
merging_strategy ... | def get_tops(self):
'''
Gather the top files
'''
tops = DefaultOrderedDict(list)
include = DefaultOrderedDict(list)
done = DefaultOrderedDict(list)
found = 0 # did we find any contents in the top files?
# Gather initial top files
merging_strategy ... | [
"Gather",
"the",
"top",
"files"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3193-L3313 | [
"def",
"get_tops",
"(",
"self",
")",
":",
"tops",
"=",
"DefaultOrderedDict",
"(",
"list",
")",
"include",
"=",
"DefaultOrderedDict",
"(",
"list",
")",
"done",
"=",
"DefaultOrderedDict",
"(",
"list",
")",
"found",
"=",
"0",
"# did we find any contents in the top ... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.merge_tops | Cleanly merge the top files | salt/state.py | def merge_tops(self, tops):
'''
Cleanly merge the top files
'''
merging_strategy = self.opts['top_file_merging_strategy']
try:
merge_attr = '_merge_tops_{0}'.format(merging_strategy)
merge_func = getattr(self, merge_attr)
if not hasattr(merge_f... | def merge_tops(self, tops):
'''
Cleanly merge the top files
'''
merging_strategy = self.opts['top_file_merging_strategy']
try:
merge_attr = '_merge_tops_{0}'.format(merging_strategy)
merge_func = getattr(self, merge_attr)
if not hasattr(merge_f... | [
"Cleanly",
"merge",
"the",
"top",
"files"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3315-L3333 | [
"def",
"merge_tops",
"(",
"self",
",",
"tops",
")",
":",
"merging_strategy",
"=",
"self",
".",
"opts",
"[",
"'top_file_merging_strategy'",
"]",
"try",
":",
"merge_attr",
"=",
"'_merge_tops_{0}'",
".",
"format",
"(",
"merging_strategy",
")",
"merge_func",
"=",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._merge_tops_merge | The default merging strategy. The base env is authoritative, so it is
checked first, followed by the remaining environments. In top files
from environments other than "base", only the section matching the
environment from the top file will be considered, and it too will be
ignored if tha... | salt/state.py | def _merge_tops_merge(self, tops):
'''
The default merging strategy. The base env is authoritative, so it is
checked first, followed by the remaining environments. In top files
from environments other than "base", only the section matching the
environment from the top file will b... | def _merge_tops_merge(self, tops):
'''
The default merging strategy. The base env is authoritative, so it is
checked first, followed by the remaining environments. In top files
from environments other than "base", only the section matching the
environment from the top file will b... | [
"The",
"default",
"merging",
"strategy",
".",
"The",
"base",
"env",
"is",
"authoritative",
"so",
"it",
"is",
"checked",
"first",
"followed",
"by",
"the",
"remaining",
"environments",
".",
"In",
"top",
"files",
"from",
"environments",
"other",
"than",
"base",
... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3335-L3384 | [
"def",
"_merge_tops_merge",
"(",
"self",
",",
"tops",
")",
":",
"top",
"=",
"DefaultOrderedDict",
"(",
"OrderedDict",
")",
"# Check base env first as it is authoritative",
"base_tops",
"=",
"tops",
".",
"pop",
"(",
"'base'",
",",
"DefaultOrderedDict",
"(",
"OrderedD... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._merge_tops_same | For each saltenv, only consider the top file from that saltenv. All
sections matching a given saltenv, which appear in a different
saltenv's top file, will be ignored. | salt/state.py | def _merge_tops_same(self, tops):
'''
For each saltenv, only consider the top file from that saltenv. All
sections matching a given saltenv, which appear in a different
saltenv's top file, will be ignored.
'''
top = DefaultOrderedDict(OrderedDict)
for cenv, ctops ... | def _merge_tops_same(self, tops):
'''
For each saltenv, only consider the top file from that saltenv. All
sections matching a given saltenv, which appear in a different
saltenv's top file, will be ignored.
'''
top = DefaultOrderedDict(OrderedDict)
for cenv, ctops ... | [
"For",
"each",
"saltenv",
"only",
"consider",
"the",
"top",
"file",
"from",
"that",
"saltenv",
".",
"All",
"sections",
"matching",
"a",
"given",
"saltenv",
"which",
"appear",
"in",
"a",
"different",
"saltenv",
"s",
"top",
"file",
"will",
"be",
"ignored",
"... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3386-L3447 | [
"def",
"_merge_tops_same",
"(",
"self",
",",
"tops",
")",
":",
"top",
"=",
"DefaultOrderedDict",
"(",
"OrderedDict",
")",
"for",
"cenv",
",",
"ctops",
"in",
"six",
".",
"iteritems",
"(",
"tops",
")",
":",
"if",
"all",
"(",
"[",
"x",
"==",
"{",
"}",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._merge_tops_merge_all | Merge the top files into a single dictionary | salt/state.py | def _merge_tops_merge_all(self, tops):
'''
Merge the top files into a single dictionary
'''
def _read_tgt(tgt):
match_type = None
states = []
for item in tgt:
if isinstance(item, dict):
match_type = item
... | def _merge_tops_merge_all(self, tops):
'''
Merge the top files into a single dictionary
'''
def _read_tgt(tgt):
match_type = None
states = []
for item in tgt:
if isinstance(item, dict):
match_type = item
... | [
"Merge",
"the",
"top",
"files",
"into",
"a",
"single",
"dictionary"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3449-L3485 | [
"def",
"_merge_tops_merge_all",
"(",
"self",
",",
"tops",
")",
":",
"def",
"_read_tgt",
"(",
"tgt",
")",
":",
"match_type",
"=",
"None",
"states",
"=",
"[",
"]",
"for",
"item",
"in",
"tgt",
":",
"if",
"isinstance",
"(",
"item",
",",
"dict",
")",
":",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.verify_tops | Verify the contents of the top file data | salt/state.py | def verify_tops(self, tops):
'''
Verify the contents of the top file data
'''
errors = []
if not isinstance(tops, dict):
errors.append('Top data was not formed as a dict')
# No further checks will work, bail out
return errors
for salten... | def verify_tops(self, tops):
'''
Verify the contents of the top file data
'''
errors = []
if not isinstance(tops, dict):
errors.append('Top data was not formed as a dict')
# No further checks will work, bail out
return errors
for salten... | [
"Verify",
"the",
"contents",
"of",
"the",
"top",
"file",
"data"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3487-L3536 | [
"def",
"verify_tops",
"(",
"self",
",",
"tops",
")",
":",
"errors",
"=",
"[",
"]",
"if",
"not",
"isinstance",
"(",
"tops",
",",
"dict",
")",
":",
"errors",
".",
"append",
"(",
"'Top data was not formed as a dict'",
")",
"# No further checks will work, bail out",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.get_top | Returns the high data derived from the top file | salt/state.py | def get_top(self):
'''
Returns the high data derived from the top file
'''
try:
tops = self.get_tops()
except SaltRenderError as err:
log.error('Unable to render top file: %s', err.error)
return {}
return self.merge_tops(tops) | def get_top(self):
'''
Returns the high data derived from the top file
'''
try:
tops = self.get_tops()
except SaltRenderError as err:
log.error('Unable to render top file: %s', err.error)
return {}
return self.merge_tops(tops) | [
"Returns",
"the",
"high",
"data",
"derived",
"from",
"the",
"top",
"file"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3538-L3547 | [
"def",
"get_top",
"(",
"self",
")",
":",
"try",
":",
"tops",
"=",
"self",
".",
"get_tops",
"(",
")",
"except",
"SaltRenderError",
"as",
"err",
":",
"log",
".",
"error",
"(",
"'Unable to render top file: %s'",
",",
"err",
".",
"error",
")",
"return",
"{",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.top_matches | Search through the top high data for matches and return the states
that this minion needs to execute.
Returns:
{'saltenv': ['state1', 'state2', ...]} | salt/state.py | def top_matches(self, top):
'''
Search through the top high data for matches and return the states
that this minion needs to execute.
Returns:
{'saltenv': ['state1', 'state2', ...]}
'''
matches = DefaultOrderedDict(OrderedDict)
# pylint: disable=cell-var-... | def top_matches(self, top):
'''
Search through the top high data for matches and return the states
that this minion needs to execute.
Returns:
{'saltenv': ['state1', 'state2', ...]}
'''
matches = DefaultOrderedDict(OrderedDict)
# pylint: disable=cell-var-... | [
"Search",
"through",
"the",
"top",
"high",
"data",
"for",
"matches",
"and",
"return",
"the",
"states",
"that",
"this",
"minion",
"needs",
"to",
"execute",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3549-L3601 | [
"def",
"top_matches",
"(",
"self",
",",
"top",
")",
":",
"matches",
"=",
"DefaultOrderedDict",
"(",
"OrderedDict",
")",
"# pylint: disable=cell-var-from-loop",
"for",
"saltenv",
",",
"body",
"in",
"six",
".",
"iteritems",
"(",
"top",
")",
":",
"if",
"self",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.load_dynamic | If autoload_dynamic_modules is True then automatically load the
dynamic modules | salt/state.py | def load_dynamic(self, matches):
'''
If autoload_dynamic_modules is True then automatically load the
dynamic modules
'''
if not self.opts['autoload_dynamic_modules']:
return
syncd = self.state.functions['saltutil.sync_all'](list(matches),
... | def load_dynamic(self, matches):
'''
If autoload_dynamic_modules is True then automatically load the
dynamic modules
'''
if not self.opts['autoload_dynamic_modules']:
return
syncd = self.state.functions['saltutil.sync_all'](list(matches),
... | [
"If",
"autoload_dynamic_modules",
"is",
"True",
"then",
"automatically",
"load",
"the",
"dynamic",
"modules"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3610-L3622 | [
"def",
"load_dynamic",
"(",
"self",
",",
"matches",
")",
":",
"if",
"not",
"self",
".",
"opts",
"[",
"'autoload_dynamic_modules'",
"]",
":",
"return",
"syncd",
"=",
"self",
".",
"state",
".",
"functions",
"[",
"'saltutil.sync_all'",
"]",
"(",
"list",
"(",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.render_state | Render a state file and retrieve all of the include states | salt/state.py | def render_state(self, sls, saltenv, mods, matches, local=False):
'''
Render a state file and retrieve all of the include states
'''
errors = []
if not local:
state_data = self.client.get_state(sls, saltenv)
fn_ = state_data.get('dest', False)
else... | def render_state(self, sls, saltenv, mods, matches, local=False):
'''
Render a state file and retrieve all of the include states
'''
errors = []
if not local:
state_data = self.client.get_state(sls, saltenv)
fn_ = state_data.get('dest', False)
else... | [
"Render",
"a",
"state",
"file",
"and",
"retrieve",
"all",
"of",
"the",
"include",
"states"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3624-L3807 | [
"def",
"render_state",
"(",
"self",
",",
"sls",
",",
"saltenv",
",",
"mods",
",",
"matches",
",",
"local",
"=",
"False",
")",
":",
"errors",
"=",
"[",
"]",
"if",
"not",
"local",
":",
"state_data",
"=",
"self",
".",
"client",
".",
"get_state",
"(",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._handle_iorder | Take a state and apply the iorder system | salt/state.py | def _handle_iorder(self, state):
'''
Take a state and apply the iorder system
'''
if self.opts['state_auto_order']:
for name in state:
for s_dec in state[name]:
if not isinstance(s_dec, six.string_types):
# PyDSL Ord... | def _handle_iorder(self, state):
'''
Take a state and apply the iorder system
'''
if self.opts['state_auto_order']:
for name in state:
for s_dec in state[name]:
if not isinstance(s_dec, six.string_types):
# PyDSL Ord... | [
"Take",
"a",
"state",
"and",
"apply",
"the",
"iorder",
"system"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3809-L3844 | [
"def",
"_handle_iorder",
"(",
"self",
",",
"state",
")",
":",
"if",
"self",
".",
"opts",
"[",
"'state_auto_order'",
"]",
":",
"for",
"name",
"in",
"state",
":",
"for",
"s_dec",
"in",
"state",
"[",
"name",
"]",
":",
"if",
"not",
"isinstance",
"(",
"s_... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._handle_state_decls | Add sls and saltenv components to the state | salt/state.py | def _handle_state_decls(self, state, sls, saltenv, errors):
'''
Add sls and saltenv components to the state
'''
for name in state:
if not isinstance(state[name], dict):
if name == '__extend__':
continue
if name == '__exclude... | def _handle_state_decls(self, state, sls, saltenv, errors):
'''
Add sls and saltenv components to the state
'''
for name in state:
if not isinstance(state[name], dict):
if name == '__extend__':
continue
if name == '__exclude... | [
"Add",
"sls",
"and",
"saltenv",
"components",
"to",
"the",
"state"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3846-L3901 | [
"def",
"_handle_state_decls",
"(",
"self",
",",
"state",
",",
"sls",
",",
"saltenv",
",",
"errors",
")",
":",
"for",
"name",
"in",
"state",
":",
"if",
"not",
"isinstance",
"(",
"state",
"[",
"name",
"]",
",",
"dict",
")",
":",
"if",
"name",
"==",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._handle_extend | Take the extend dec out of state and apply to the highstate global
dec | salt/state.py | def _handle_extend(self, state, sls, saltenv, errors):
'''
Take the extend dec out of state and apply to the highstate global
dec
'''
if 'extend' in state:
ext = state.pop('extend')
if not isinstance(ext, dict):
errors.append(('Extension va... | def _handle_extend(self, state, sls, saltenv, errors):
'''
Take the extend dec out of state and apply to the highstate global
dec
'''
if 'extend' in state:
ext = state.pop('extend')
if not isinstance(ext, dict):
errors.append(('Extension va... | [
"Take",
"the",
"extend",
"dec",
"out",
"of",
"state",
"and",
"apply",
"to",
"the",
"highstate",
"global",
"dec"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3903-L3933 | [
"def",
"_handle_extend",
"(",
"self",
",",
"state",
",",
"sls",
",",
"saltenv",
",",
"errors",
")",
":",
"if",
"'extend'",
"in",
"state",
":",
"ext",
"=",
"state",
".",
"pop",
"(",
"'extend'",
")",
"if",
"not",
"isinstance",
"(",
"ext",
",",
"dict",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._handle_exclude | Take the exclude dec out of the state and apply it to the highstate
global dec | salt/state.py | def _handle_exclude(self, state, sls, saltenv, errors):
'''
Take the exclude dec out of the state and apply it to the highstate
global dec
'''
if 'exclude' in state:
exc = state.pop('exclude')
if not isinstance(exc, list):
err = ('Exclude D... | def _handle_exclude(self, state, sls, saltenv, errors):
'''
Take the exclude dec out of the state and apply it to the highstate
global dec
'''
if 'exclude' in state:
exc = state.pop('exclude')
if not isinstance(exc, list):
err = ('Exclude D... | [
"Take",
"the",
"exclude",
"dec",
"out",
"of",
"the",
"state",
"and",
"apply",
"it",
"to",
"the",
"highstate",
"global",
"dec"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3935-L3946 | [
"def",
"_handle_exclude",
"(",
"self",
",",
"state",
",",
"sls",
",",
"saltenv",
",",
"errors",
")",
":",
"if",
"'exclude'",
"in",
"state",
":",
"exc",
"=",
"state",
".",
"pop",
"(",
"'exclude'",
")",
"if",
"not",
"isinstance",
"(",
"exc",
",",
"list... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.render_highstate | Gather the state files and render them into a single unified salt
high data structure. | salt/state.py | def render_highstate(self, matches):
'''
Gather the state files and render them into a single unified salt
high data structure.
'''
highstate = self.building_highstate
all_errors = []
mods = set()
statefiles = []
for saltenv, states in six.iteritem... | def render_highstate(self, matches):
'''
Gather the state files and render them into a single unified salt
high data structure.
'''
highstate = self.building_highstate
all_errors = []
mods = set()
statefiles = []
for saltenv, states in six.iteritem... | [
"Gather",
"the",
"state",
"files",
"and",
"render",
"them",
"into",
"a",
"single",
"unified",
"salt",
"high",
"data",
"structure",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L3948-L3995 | [
"def",
"render_highstate",
"(",
"self",
",",
"matches",
")",
":",
"highstate",
"=",
"self",
".",
"building_highstate",
"all_errors",
"=",
"[",
"]",
"mods",
"=",
"set",
"(",
")",
"statefiles",
"=",
"[",
"]",
"for",
"saltenv",
",",
"states",
"in",
"six",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState._check_pillar | Check the pillar for errors, refuse to run the state if there are
errors in the pillar and return the pillar errors | salt/state.py | def _check_pillar(self, force=False):
'''
Check the pillar for errors, refuse to run the state if there are
errors in the pillar and return the pillar errors
'''
if force:
return True
if '_errors' in self.state.opts['pillar']:
return False
... | def _check_pillar(self, force=False):
'''
Check the pillar for errors, refuse to run the state if there are
errors in the pillar and return the pillar errors
'''
if force:
return True
if '_errors' in self.state.opts['pillar']:
return False
... | [
"Check",
"the",
"pillar",
"for",
"errors",
"refuse",
"to",
"run",
"the",
"state",
"if",
"there",
"are",
"errors",
"in",
"the",
"pillar",
"and",
"return",
"the",
"pillar",
"errors"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4035-L4044 | [
"def",
"_check_pillar",
"(",
"self",
",",
"force",
"=",
"False",
")",
":",
"if",
"force",
":",
"return",
"True",
"if",
"'_errors'",
"in",
"self",
".",
"state",
".",
"opts",
"[",
"'pillar'",
"]",
":",
"return",
"False",
"return",
"True"
] | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.matches_whitelist | Reads over the matches and returns a matches dict with just the ones
that are in the whitelist | salt/state.py | def matches_whitelist(self, matches, whitelist):
'''
Reads over the matches and returns a matches dict with just the ones
that are in the whitelist
'''
if not whitelist:
return matches
ret_matches = {}
if not isinstance(whitelist, list):
wh... | def matches_whitelist(self, matches, whitelist):
'''
Reads over the matches and returns a matches dict with just the ones
that are in the whitelist
'''
if not whitelist:
return matches
ret_matches = {}
if not isinstance(whitelist, list):
wh... | [
"Reads",
"over",
"the",
"matches",
"and",
"returns",
"a",
"matches",
"dict",
"with",
"just",
"the",
"ones",
"that",
"are",
"in",
"the",
"whitelist"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4046-L4061 | [
"def",
"matches_whitelist",
"(",
"self",
",",
"matches",
",",
"whitelist",
")",
":",
"if",
"not",
"whitelist",
":",
"return",
"matches",
"ret_matches",
"=",
"{",
"}",
"if",
"not",
"isinstance",
"(",
"whitelist",
",",
"list",
")",
":",
"whitelist",
"=",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.call_highstate | Run the sequence to execute the salt highstate for this minion | salt/state.py | def call_highstate(self, exclude=None, cache=None, cache_name='highstate',
force=False, whitelist=None, orchestration_jid=None):
'''
Run the sequence to execute the salt highstate for this minion
'''
# Check that top file exists
tag_name = 'no_|-states_|-st... | def call_highstate(self, exclude=None, cache=None, cache_name='highstate',
force=False, whitelist=None, orchestration_jid=None):
'''
Run the sequence to execute the salt highstate for this minion
'''
# Check that top file exists
tag_name = 'no_|-states_|-st... | [
"Run",
"the",
"sequence",
"to",
"execute",
"the",
"salt",
"highstate",
"for",
"this",
"minion"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4063-L4142 | [
"def",
"call_highstate",
"(",
"self",
",",
"exclude",
"=",
"None",
",",
"cache",
"=",
"None",
",",
"cache_name",
"=",
"'highstate'",
",",
"force",
"=",
"False",
",",
"whitelist",
"=",
"None",
",",
"orchestration_jid",
"=",
"None",
")",
":",
"# Check that t... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.compile_highstate | Return just the highstate or the errors | salt/state.py | def compile_highstate(self):
'''
Return just the highstate or the errors
'''
err = []
top = self.get_top()
err += self.verify_tops(top)
matches = self.top_matches(top)
high, errors = self.render_highstate(matches)
err += errors
if err:
... | def compile_highstate(self):
'''
Return just the highstate or the errors
'''
err = []
top = self.get_top()
err += self.verify_tops(top)
matches = self.top_matches(top)
high, errors = self.render_highstate(matches)
err += errors
if err:
... | [
"Return",
"just",
"the",
"highstate",
"or",
"the",
"errors"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4144-L4158 | [
"def",
"compile_highstate",
"(",
"self",
")",
":",
"err",
"=",
"[",
"]",
"top",
"=",
"self",
".",
"get_top",
"(",
")",
"err",
"+=",
"self",
".",
"verify_tops",
"(",
"top",
")",
"matches",
"=",
"self",
".",
"top_matches",
"(",
"top",
")",
"high",
",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.compile_low_chunks | Compile the highstate but don't run it, return the low chunks to
see exactly what the highstate will execute | salt/state.py | def compile_low_chunks(self):
'''
Compile the highstate but don't run it, return the low chunks to
see exactly what the highstate will execute
'''
top = self.get_top()
matches = self.top_matches(top)
high, errors = self.render_highstate(matches)
# If ther... | def compile_low_chunks(self):
'''
Compile the highstate but don't run it, return the low chunks to
see exactly what the highstate will execute
'''
top = self.get_top()
matches = self.top_matches(top)
high, errors = self.render_highstate(matches)
# If ther... | [
"Compile",
"the",
"highstate",
"but",
"don",
"t",
"run",
"it",
"return",
"the",
"low",
"chunks",
"to",
"see",
"exactly",
"what",
"the",
"highstate",
"will",
"execute"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4160-L4185 | [
"def",
"compile_low_chunks",
"(",
"self",
")",
":",
"top",
"=",
"self",
".",
"get_top",
"(",
")",
"matches",
"=",
"self",
".",
"top_matches",
"(",
"top",
")",
"high",
",",
"errors",
"=",
"self",
".",
"render_highstate",
"(",
"matches",
")",
"# If there i... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | BaseHighState.compile_state_usage | Return all used and unused states for the minion based on the top match data | salt/state.py | def compile_state_usage(self):
'''
Return all used and unused states for the minion based on the top match data
'''
err = []
top = self.get_top()
err += self.verify_tops(top)
if err:
return err
matches = self.top_matches(top)
state_us... | def compile_state_usage(self):
'''
Return all used and unused states for the minion based on the top match data
'''
err = []
top = self.get_top()
err += self.verify_tops(top)
if err:
return err
matches = self.top_matches(top)
state_us... | [
"Return",
"all",
"used",
"and",
"unused",
"states",
"for",
"the",
"minion",
"based",
"on",
"the",
"top",
"match",
"data"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4187-L4223 | [
"def",
"compile_state_usage",
"(",
"self",
")",
":",
"err",
"=",
"[",
"]",
"top",
"=",
"self",
".",
"get_top",
"(",
")",
"err",
"+=",
"self",
".",
"verify_tops",
"(",
"top",
")",
"if",
"err",
":",
"return",
"err",
"matches",
"=",
"self",
".",
"top_... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | MasterState.load_modules | Load the modules into the state | salt/state.py | def load_modules(self, data=None, proxy=None):
'''
Load the modules into the state
'''
log.info('Loading fresh modules for state activity')
# Load a modified client interface that looks like the interface used
# from the minion, but uses remote execution
#
... | def load_modules(self, data=None, proxy=None):
'''
Load the modules into the state
'''
log.info('Loading fresh modules for state activity')
# Load a modified client interface that looks like the interface used
# from the minion, but uses remote execution
#
... | [
"Load",
"the",
"modules",
"into",
"the",
"state"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4298-L4315 | [
"def",
"load_modules",
"(",
"self",
",",
"data",
"=",
"None",
",",
"proxy",
"=",
"None",
")",
":",
"log",
".",
"info",
"(",
"'Loading fresh modules for state activity'",
")",
"# Load a modified client interface that looks like the interface used",
"# from the minion, but us... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | RemoteHighState.compile_master | Return the state data from the master | salt/state.py | def compile_master(self):
'''
Return the state data from the master
'''
load = {'grains': self.grains,
'opts': self.opts,
'cmd': '_master_state'}
try:
return self.channel.send(load, tries=3, timeout=72000)
except SaltReqTimeoutE... | def compile_master(self):
'''
Return the state data from the master
'''
load = {'grains': self.grains,
'opts': self.opts,
'cmd': '_master_state'}
try:
return self.channel.send(load, tries=3, timeout=72000)
except SaltReqTimeoutE... | [
"Return",
"the",
"state",
"data",
"from",
"the",
"master"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/state.py#L4348-L4358 | [
"def",
"compile_master",
"(",
"self",
")",
":",
"load",
"=",
"{",
"'grains'",
":",
"self",
".",
"grains",
",",
"'opts'",
":",
"self",
".",
"opts",
",",
"'cmd'",
":",
"'_master_state'",
"}",
"try",
":",
"return",
"self",
".",
"channel",
".",
"send",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | output | Output the data in lines, very nice for running commands | salt/output/txt.py | def output(data, **kwargs): # pylint: disable=unused-argument
'''
Output the data in lines, very nice for running commands
'''
ret = ''
if hasattr(data, 'keys'):
for key in data:
value = data[key]
# Don't blow up on non-strings
try:
for li... | def output(data, **kwargs): # pylint: disable=unused-argument
'''
Output the data in lines, very nice for running commands
'''
ret = ''
if hasattr(data, 'keys'):
for key in data:
value = data[key]
# Don't blow up on non-strings
try:
for li... | [
"Output",
"the",
"data",
"in",
"lines",
"very",
"nice",
"for",
"running",
"commands"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/output/txt.py#L16-L37 | [
"def",
"output",
"(",
"data",
",",
"*",
"*",
"kwargs",
")",
":",
"# pylint: disable=unused-argument",
"ret",
"=",
"''",
"if",
"hasattr",
"(",
"data",
",",
"'keys'",
")",
":",
"for",
"key",
"in",
"data",
":",
"value",
"=",
"data",
"[",
"key",
"]",
"# ... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | compare_and_update_config | Recursively compare two configs, writing any needed changes to the
update_config and capturing changes in the changes dict. | salt/utils/configcomparer.py | def compare_and_update_config(config, update_config, changes, namespace=''):
'''
Recursively compare two configs, writing any needed changes to the
update_config and capturing changes in the changes dict.
'''
if isinstance(config, dict):
if not update_config:
if config:
... | def compare_and_update_config(config, update_config, changes, namespace=''):
'''
Recursively compare two configs, writing any needed changes to the
update_config and capturing changes in the changes dict.
'''
if isinstance(config, dict):
if not update_config:
if config:
... | [
"Recursively",
"compare",
"two",
"configs",
"writing",
"any",
"needed",
"changes",
"to",
"the",
"update_config",
"and",
"capturing",
"changes",
"in",
"the",
"changes",
"dict",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/utils/configcomparer.py#L14-L112 | [
"def",
"compare_and_update_config",
"(",
"config",
",",
"update_config",
",",
"changes",
",",
"namespace",
"=",
"''",
")",
":",
"if",
"isinstance",
"(",
"config",
",",
"dict",
")",
":",
"if",
"not",
"update_config",
":",
"if",
"config",
":",
"# the updated c... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | managed | Manage a memcached key.
name
The key to manage
value
The value to set for that key
host
The memcached server IP address
port
The memcached server port
.. code-block:: yaml
foo:
memcached.managed:
- value: bar | salt/states/memcached.py | def managed(name,
value=None,
host=DEFAULT_HOST,
port=DEFAULT_PORT,
time=DEFAULT_TIME,
min_compress_len=DEFAULT_MIN_COMPRESS_LEN):
'''
Manage a memcached key.
name
The key to manage
value
The value to set for that key
hos... | def managed(name,
value=None,
host=DEFAULT_HOST,
port=DEFAULT_PORT,
time=DEFAULT_TIME,
min_compress_len=DEFAULT_MIN_COMPRESS_LEN):
'''
Manage a memcached key.
name
The key to manage
value
The value to set for that key
hos... | [
"Manage",
"a",
"memcached",
"key",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/states/memcached.py#L34-L101 | [
"def",
"managed",
"(",
"name",
",",
"value",
"=",
"None",
",",
"host",
"=",
"DEFAULT_HOST",
",",
"port",
"=",
"DEFAULT_PORT",
",",
"time",
"=",
"DEFAULT_TIME",
",",
"min_compress_len",
"=",
"DEFAULT_MIN_COMPRESS_LEN",
")",
":",
"ret",
"=",
"{",
"'name'",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | parse_hosts | Parse /etc/hosts file.
CLI Example:
.. code-block:: bash
salt '*' dnsutil.parse_hosts | salt/modules/dnsutil.py | def parse_hosts(hostsfile='/etc/hosts', hosts=None):
'''
Parse /etc/hosts file.
CLI Example:
.. code-block:: bash
salt '*' dnsutil.parse_hosts
'''
if not hosts:
try:
with salt.utils.files.fopen(hostsfile, 'r') as fp_:
hosts = salt.utils.stringutils.... | def parse_hosts(hostsfile='/etc/hosts', hosts=None):
'''
Parse /etc/hosts file.
CLI Example:
.. code-block:: bash
salt '*' dnsutil.parse_hosts
'''
if not hosts:
try:
with salt.utils.files.fopen(hostsfile, 'r') as fp_:
hosts = salt.utils.stringutils.... | [
"Parse",
"/",
"etc",
"/",
"hosts",
"file",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L32-L60 | [
"def",
"parse_hosts",
"(",
"hostsfile",
"=",
"'/etc/hosts'",
",",
"hosts",
"=",
"None",
")",
":",
"if",
"not",
"hosts",
":",
"try",
":",
"with",
"salt",
".",
"utils",
".",
"files",
".",
"fopen",
"(",
"hostsfile",
",",
"'r'",
")",
"as",
"fp_",
":",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | hosts_append | Append a single line to the /etc/hosts file.
CLI Example:
.. code-block:: bash
salt '*' dnsutil.hosts_append /etc/hosts 127.0.0.1 ad1.yuk.co,ad2.yuk.co | salt/modules/dnsutil.py | def hosts_append(hostsfile='/etc/hosts', ip_addr=None, entries=None):
'''
Append a single line to the /etc/hosts file.
CLI Example:
.. code-block:: bash
salt '*' dnsutil.hosts_append /etc/hosts 127.0.0.1 ad1.yuk.co,ad2.yuk.co
'''
host_list = entries.split(',')
hosts = parse_hosts(... | def hosts_append(hostsfile='/etc/hosts', ip_addr=None, entries=None):
'''
Append a single line to the /etc/hosts file.
CLI Example:
.. code-block:: bash
salt '*' dnsutil.hosts_append /etc/hosts 127.0.0.1 ad1.yuk.co,ad2.yuk.co
'''
host_list = entries.split(',')
hosts = parse_hosts(... | [
"Append",
"a",
"single",
"line",
"to",
"the",
"/",
"etc",
"/",
"hosts",
"file",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L63-L88 | [
"def",
"hosts_append",
"(",
"hostsfile",
"=",
"'/etc/hosts'",
",",
"ip_addr",
"=",
"None",
",",
"entries",
"=",
"None",
")",
":",
"host_list",
"=",
"entries",
".",
"split",
"(",
"','",
")",
"hosts",
"=",
"parse_hosts",
"(",
"hostsfile",
"=",
"hostsfile",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | hosts_remove | Remove a host from the /etc/hosts file. If doing so will leave a line
containing only an IP address, then the line will be deleted. This function
will leave comments and blank lines intact.
CLI Examples:
.. code-block:: bash
salt '*' dnsutil.hosts_remove /etc/hosts ad1.yuk.co
salt '*'... | salt/modules/dnsutil.py | def hosts_remove(hostsfile='/etc/hosts', entries=None):
'''
Remove a host from the /etc/hosts file. If doing so will leave a line
containing only an IP address, then the line will be deleted. This function
will leave comments and blank lines intact.
CLI Examples:
.. code-block:: bash
... | def hosts_remove(hostsfile='/etc/hosts', entries=None):
'''
Remove a host from the /etc/hosts file. If doing so will leave a line
containing only an IP address, then the line will be deleted. This function
will leave comments and blank lines intact.
CLI Examples:
.. code-block:: bash
... | [
"Remove",
"a",
"host",
"from",
"the",
"/",
"etc",
"/",
"hosts",
"file",
".",
"If",
"doing",
"so",
"will",
"leave",
"a",
"line",
"containing",
"only",
"an",
"IP",
"address",
"then",
"the",
"line",
"will",
"be",
"deleted",
".",
"This",
"function",
"will"... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L91-L119 | [
"def",
"hosts_remove",
"(",
"hostsfile",
"=",
"'/etc/hosts'",
",",
"entries",
"=",
"None",
")",
":",
"with",
"salt",
".",
"utils",
".",
"files",
".",
"fopen",
"(",
"hostsfile",
",",
"'r'",
")",
"as",
"fp_",
":",
"hosts",
"=",
"salt",
".",
"utils",
".... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | parse_zone | Parses a zone file. Can be passed raw zone data on the API level.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.parse_zone /var/lib/named/example.com.zone | salt/modules/dnsutil.py | def parse_zone(zonefile=None, zone=None):
'''
Parses a zone file. Can be passed raw zone data on the API level.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.parse_zone /var/lib/named/example.com.zone
'''
if zonefile:
try:
with salt.utils.files.fopen(zonefile,... | def parse_zone(zonefile=None, zone=None):
'''
Parses a zone file. Can be passed raw zone data on the API level.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.parse_zone /var/lib/named/example.com.zone
'''
if zonefile:
try:
with salt.utils.files.fopen(zonefile,... | [
"Parses",
"a",
"zone",
"file",
".",
"Can",
"be",
"passed",
"raw",
"zone",
"data",
"on",
"the",
"API",
"level",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L122-L197 | [
"def",
"parse_zone",
"(",
"zonefile",
"=",
"None",
",",
"zone",
"=",
"None",
")",
":",
"if",
"zonefile",
":",
"try",
":",
"with",
"salt",
".",
"utils",
".",
"files",
".",
"fopen",
"(",
"zonefile",
",",
"'r'",
")",
"as",
"fp_",
":",
"zone",
"=",
"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | _to_seconds | Converts a time value to seconds.
As per RFC1035 (page 45), max time is 1 week, so anything longer (or
unreadable) will be set to one week (604800 seconds). | salt/modules/dnsutil.py | def _to_seconds(timestr):
'''
Converts a time value to seconds.
As per RFC1035 (page 45), max time is 1 week, so anything longer (or
unreadable) will be set to one week (604800 seconds).
'''
timestr = timestr.upper()
if 'H' in timestr:
seconds = int(timestr.replace('H', '')) * 3600
... | def _to_seconds(timestr):
'''
Converts a time value to seconds.
As per RFC1035 (page 45), max time is 1 week, so anything longer (or
unreadable) will be set to one week (604800 seconds).
'''
timestr = timestr.upper()
if 'H' in timestr:
seconds = int(timestr.replace('H', '')) * 3600
... | [
"Converts",
"a",
"time",
"value",
"to",
"seconds",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L200-L221 | [
"def",
"_to_seconds",
"(",
"timestr",
")",
":",
"timestr",
"=",
"timestr",
".",
"upper",
"(",
")",
"if",
"'H'",
"in",
"timestr",
":",
"seconds",
"=",
"int",
"(",
"timestr",
".",
"replace",
"(",
"'H'",
",",
"''",
")",
")",
"*",
"3600",
"elif",
"'D'"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | A | Return the A record(s) for ``host``.
Always returns a list.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.A www.google.com | salt/modules/dnsutil.py | def A(host, nameserver=None):
'''
Return the A record(s) for ``host``.
Always returns a list.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.A www.google.com
'''
if _has_dig():
return __salt__['dig.A'](host, nameserver)
elif nameserver is None:
# fall back... | def A(host, nameserver=None):
'''
Return the A record(s) for ``host``.
Always returns a list.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.A www.google.com
'''
if _has_dig():
return __salt__['dig.A'](host, nameserver)
elif nameserver is None:
# fall back... | [
"Return",
"the",
"A",
"record",
"(",
"s",
")",
"for",
"host",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L249-L271 | [
"def",
"A",
"(",
"host",
",",
"nameserver",
"=",
"None",
")",
":",
"if",
"_has_dig",
"(",
")",
":",
"return",
"__salt__",
"[",
"'dig.A'",
"]",
"(",
"host",
",",
"nameserver",
")",
"elif",
"nameserver",
"is",
"None",
":",
"# fall back to the socket interfac... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | AAAA | Return the AAAA record(s) for ``host``.
Always returns a list.
.. versionadded:: 2014.7.5
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.AAAA www.google.com | salt/modules/dnsutil.py | def AAAA(host, nameserver=None):
'''
Return the AAAA record(s) for ``host``.
Always returns a list.
.. versionadded:: 2014.7.5
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.AAAA www.google.com
'''
if _has_dig():
return __salt__['dig.AAAA'](host, nameserver)
... | def AAAA(host, nameserver=None):
'''
Return the AAAA record(s) for ``host``.
Always returns a list.
.. versionadded:: 2014.7.5
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.AAAA www.google.com
'''
if _has_dig():
return __salt__['dig.AAAA'](host, nameserver)
... | [
"Return",
"the",
"AAAA",
"record",
"(",
"s",
")",
"for",
"host",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L274-L298 | [
"def",
"AAAA",
"(",
"host",
",",
"nameserver",
"=",
"None",
")",
":",
"if",
"_has_dig",
"(",
")",
":",
"return",
"__salt__",
"[",
"'dig.AAAA'",
"]",
"(",
"host",
",",
"nameserver",
")",
"elif",
"nameserver",
"is",
"None",
":",
"# fall back to the socket in... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | NS | Return a list of IPs of the nameservers for ``domain``
If 'resolve' is False, don't resolve names.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.NS google.com | salt/modules/dnsutil.py | def NS(domain, resolve=True, nameserver=None):
'''
Return a list of IPs of the nameservers for ``domain``
If 'resolve' is False, don't resolve names.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.NS google.com
'''
if _has_dig():
return __salt__['dig.NS'](domain, res... | def NS(domain, resolve=True, nameserver=None):
'''
Return a list of IPs of the nameservers for ``domain``
If 'resolve' is False, don't resolve names.
CLI Example:
.. code-block:: bash
salt ns1 dnsutil.NS google.com
'''
if _has_dig():
return __salt__['dig.NS'](domain, res... | [
"Return",
"a",
"list",
"of",
"IPs",
"of",
"the",
"nameservers",
"for",
"domain"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L301-L317 | [
"def",
"NS",
"(",
"domain",
",",
"resolve",
"=",
"True",
",",
"nameserver",
"=",
"None",
")",
":",
"if",
"_has_dig",
"(",
")",
":",
"return",
"__salt__",
"[",
"'dig.NS'",
"]",
"(",
"domain",
",",
"resolve",
",",
"nameserver",
")",
"return",
"'This func... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | MX | Return a list of lists for the MX of ``domain``.
If the 'resolve' argument is True, resolve IPs for the servers.
It's limited to one IP, because although in practice it's very rarely a
round robin, it is an acceptable configuration and pulling just one IP lets
the data be similar to the non-resolved v... | salt/modules/dnsutil.py | def MX(domain, resolve=False, nameserver=None):
'''
Return a list of lists for the MX of ``domain``.
If the 'resolve' argument is True, resolve IPs for the servers.
It's limited to one IP, because although in practice it's very rarely a
round robin, it is an acceptable configuration and pulling ju... | def MX(domain, resolve=False, nameserver=None):
'''
Return a list of lists for the MX of ``domain``.
If the 'resolve' argument is True, resolve IPs for the servers.
It's limited to one IP, because although in practice it's very rarely a
round robin, it is an acceptable configuration and pulling ju... | [
"Return",
"a",
"list",
"of",
"lists",
"for",
"the",
"MX",
"of",
"domain",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L340-L360 | [
"def",
"MX",
"(",
"domain",
",",
"resolve",
"=",
"False",
",",
"nameserver",
"=",
"None",
")",
":",
"if",
"_has_dig",
"(",
")",
":",
"return",
"__salt__",
"[",
"'dig.MX'",
"]",
"(",
"domain",
",",
"resolve",
",",
"nameserver",
")",
"return",
"'This fun... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | serial | Return, store and update a dns serial for your zone files.
zone: a keyword for a specific zone
update: store an updated version of the serial in a grain
If ``update`` is False, the function will retrieve an existing serial or
return the current date if no serial is stored. Nothing will be stored
... | salt/modules/dnsutil.py | def serial(zone='', update=False):
'''
Return, store and update a dns serial for your zone files.
zone: a keyword for a specific zone
update: store an updated version of the serial in a grain
If ``update`` is False, the function will retrieve an existing serial or
return the current date if n... | def serial(zone='', update=False):
'''
Return, store and update a dns serial for your zone files.
zone: a keyword for a specific zone
update: store an updated version of the serial in a grain
If ``update`` is False, the function will retrieve an existing serial or
return the current date if n... | [
"Return",
"store",
"and",
"update",
"a",
"dns",
"serial",
"for",
"your",
"zone",
"files",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/modules/dnsutil.py#L363-L401 | [
"def",
"serial",
"(",
"zone",
"=",
"''",
",",
"update",
"=",
"False",
")",
":",
"grains",
"=",
"{",
"}",
"key",
"=",
"'dnsserial'",
"if",
"zone",
":",
"key",
"+=",
"'_{0}'",
".",
"format",
"(",
"zone",
")",
"stored",
"=",
"__salt__",
"[",
"'grains.... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance._post_fork_init | Some things need to be init'd after the fork has completed
The easiest example is that one of these module types creates a thread
in the parent process, then once the fork happens you'll start getting
errors like "WARNING: Mixing fork() and threads detected; memory leaked." | salt/master.py | def _post_fork_init(self):
'''
Some things need to be init'd after the fork has completed
The easiest example is that one of these module types creates a thread
in the parent process, then once the fork happens you'll start getting
errors like "WARNING: Mixing fork() and threads ... | def _post_fork_init(self):
'''
Some things need to be init'd after the fork has completed
The easiest example is that one of these module types creates a thread
in the parent process, then once the fork happens you'll start getting
errors like "WARNING: Mixing fork() and threads ... | [
"Some",
"things",
"need",
"to",
"be",
"init",
"d",
"after",
"the",
"fork",
"has",
"completed",
"The",
"easiest",
"example",
"is",
"that",
"one",
"of",
"these",
"module",
"types",
"creates",
"a",
"thread",
"in",
"the",
"parent",
"process",
"then",
"once",
... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L179-L212 | [
"def",
"_post_fork_init",
"(",
"self",
")",
":",
"# Load Runners",
"ropts",
"=",
"dict",
"(",
"self",
".",
"opts",
")",
"ropts",
"[",
"'quiet'",
"]",
"=",
"True",
"runner_client",
"=",
"salt",
".",
"runner",
".",
"RunnerClient",
"(",
"ropts",
")",
"# Loa... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance.run | This is the general passive maintenance process controller for the Salt
master.
This is where any data that needs to be cleanly maintained from the
master is maintained. | salt/master.py | def run(self):
'''
This is the general passive maintenance process controller for the Salt
master.
This is where any data that needs to be cleanly maintained from the
master is maintained.
'''
salt.utils.process.appendproctitle(self.__class__.__name__)
#... | def run(self):
'''
This is the general passive maintenance process controller for the Salt
master.
This is where any data that needs to be cleanly maintained from the
master is maintained.
'''
salt.utils.process.appendproctitle(self.__class__.__name__)
#... | [
"This",
"is",
"the",
"general",
"passive",
"maintenance",
"process",
"controller",
"for",
"the",
"Salt",
"master",
"."
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L214-L245 | [
"def",
"run",
"(",
"self",
")",
":",
"salt",
".",
"utils",
".",
"process",
".",
"appendproctitle",
"(",
"self",
".",
"__class__",
".",
"__name__",
")",
"# init things that need to be done after the process is forked",
"self",
".",
"_post_fork_init",
"(",
")",
"# M... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance.handle_key_cache | Evaluate accepted keys and create a msgpack file
which contains a list | salt/master.py | def handle_key_cache(self):
'''
Evaluate accepted keys and create a msgpack file
which contains a list
'''
if self.opts['key_cache'] == 'sched':
keys = []
#TODO DRY from CKMinions
if self.opts['transport'] in ('zeromq', 'tcp'):
... | def handle_key_cache(self):
'''
Evaluate accepted keys and create a msgpack file
which contains a list
'''
if self.opts['key_cache'] == 'sched':
keys = []
#TODO DRY from CKMinions
if self.opts['transport'] in ('zeromq', 'tcp'):
... | [
"Evaluate",
"accepted",
"keys",
"and",
"create",
"a",
"msgpack",
"file",
"which",
"contains",
"a",
"list"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L247-L270 | [
"def",
"handle_key_cache",
"(",
"self",
")",
":",
"if",
"self",
".",
"opts",
"[",
"'key_cache'",
"]",
"==",
"'sched'",
":",
"keys",
"=",
"[",
"]",
"#TODO DRY from CKMinions",
"if",
"self",
".",
"opts",
"[",
"'transport'",
"]",
"in",
"(",
"'zeromq'",
",",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance.handle_key_rotate | Rotate the AES key rotation | salt/master.py | def handle_key_rotate(self, now):
'''
Rotate the AES key rotation
'''
to_rotate = False
dfn = os.path.join(self.opts['cachedir'], '.dfn')
try:
stats = os.stat(dfn)
# Basic Windows permissions don't distinguish between
# user/group/all. ... | def handle_key_rotate(self, now):
'''
Rotate the AES key rotation
'''
to_rotate = False
dfn = os.path.join(self.opts['cachedir'], '.dfn')
try:
stats = os.stat(dfn)
# Basic Windows permissions don't distinguish between
# user/group/all. ... | [
"Rotate",
"the",
"AES",
"key",
"rotation"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L272-L310 | [
"def",
"handle_key_rotate",
"(",
"self",
",",
"now",
")",
":",
"to_rotate",
"=",
"False",
"dfn",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"opts",
"[",
"'cachedir'",
"]",
",",
"'.dfn'",
")",
"try",
":",
"stats",
"=",
"os",
".",
"stat",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance.handle_git_pillar | Update git pillar | salt/master.py | def handle_git_pillar(self):
'''
Update git pillar
'''
try:
for pillar in self.git_pillar:
pillar.fetch_remotes()
except Exception as exc:
log.error('Exception caught while updating git_pillar',
exc_info=True) | def handle_git_pillar(self):
'''
Update git pillar
'''
try:
for pillar in self.git_pillar:
pillar.fetch_remotes()
except Exception as exc:
log.error('Exception caught while updating git_pillar',
exc_info=True) | [
"Update",
"git",
"pillar"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L312-L321 | [
"def",
"handle_git_pillar",
"(",
"self",
")",
":",
"try",
":",
"for",
"pillar",
"in",
"self",
".",
"git_pillar",
":",
"pillar",
".",
"fetch_remotes",
"(",
")",
"except",
"Exception",
"as",
"exc",
":",
"log",
".",
"error",
"(",
"'Exception caught while updati... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance.handle_schedule | Evaluate the scheduler | salt/master.py | def handle_schedule(self):
'''
Evaluate the scheduler
'''
try:
self.schedule.eval()
# Check if scheduler requires lower loop interval than
# the loop_interval setting
if self.schedule.loop_interval < self.loop_interval:
self... | def handle_schedule(self):
'''
Evaluate the scheduler
'''
try:
self.schedule.eval()
# Check if scheduler requires lower loop interval than
# the loop_interval setting
if self.schedule.loop_interval < self.loop_interval:
self... | [
"Evaluate",
"the",
"scheduler"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L323-L334 | [
"def",
"handle_schedule",
"(",
"self",
")",
":",
"try",
":",
"self",
".",
"schedule",
".",
"eval",
"(",
")",
"# Check if scheduler requires lower loop interval than",
"# the loop_interval setting",
"if",
"self",
".",
"schedule",
".",
"loop_interval",
"<",
"self",
".... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | Maintenance.handle_presence | Fire presence events if enabled | salt/master.py | def handle_presence(self, old_present):
'''
Fire presence events if enabled
'''
# On the first run it may need more time for the EventPublisher
# to come up and be ready. Set the timeout to account for this.
if self.presence_events and self.event.connect_pull(timeout=3):
... | def handle_presence(self, old_present):
'''
Fire presence events if enabled
'''
# On the first run it may need more time for the EventPublisher
# to come up and be ready. Set the timeout to account for this.
if self.presence_events and self.event.connect_pull(timeout=3):
... | [
"Fire",
"presence",
"events",
"if",
"enabled"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L336-L354 | [
"def",
"handle_presence",
"(",
"self",
",",
"old_present",
")",
":",
"# On the first run it may need more time for the EventPublisher",
"# to come up and be ready. Set the timeout to account for this.",
"if",
"self",
".",
"presence_events",
"and",
"self",
".",
"event",
".",
"co... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | FileserverUpdate.fill_buckets | Get the configured backends and the intervals for any backend which
supports them, and set up the update "buckets". There will be one
bucket for each thing being updated at a given interval. | salt/master.py | def fill_buckets(self):
'''
Get the configured backends and the intervals for any backend which
supports them, and set up the update "buckets". There will be one
bucket for each thing being updated at a given interval.
'''
update_intervals = self.fileserver.update_interva... | def fill_buckets(self):
'''
Get the configured backends and the intervals for any backend which
supports them, and set up the update "buckets". There will be one
bucket for each thing being updated at a given interval.
'''
update_intervals = self.fileserver.update_interva... | [
"Get",
"the",
"configured",
"backends",
"and",
"the",
"intervals",
"for",
"any",
"backend",
"which",
"supports",
"them",
"and",
"set",
"up",
"the",
"update",
"buckets",
".",
"There",
"will",
"be",
"one",
"bucket",
"for",
"each",
"thing",
"being",
"updated",
... | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L385-L436 | [
"def",
"fill_buckets",
"(",
"self",
")",
":",
"update_intervals",
"=",
"self",
".",
"fileserver",
".",
"update_intervals",
"(",
")",
"self",
".",
"buckets",
"=",
"{",
"}",
"for",
"backend",
"in",
"self",
".",
"fileserver",
".",
"backends",
"(",
")",
":",... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | FileserverUpdate.update_fileserver | Threading target which handles all updates for a given wait interval | salt/master.py | def update_fileserver(self, interval, backends):
'''
Threading target which handles all updates for a given wait interval
'''
def _do_update():
log.debug(
'Performing fileserver updates for items with an update '
'interval of %d', interval
... | def update_fileserver(self, interval, backends):
'''
Threading target which handles all updates for a given wait interval
'''
def _do_update():
log.debug(
'Performing fileserver updates for items with an update '
'interval of %d', interval
... | [
"Threading",
"target",
"which",
"handles",
"all",
"updates",
"for",
"a",
"given",
"wait",
"interval"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L438-L477 | [
"def",
"update_fileserver",
"(",
"self",
",",
"interval",
",",
"backends",
")",
":",
"def",
"_do_update",
"(",
")",
":",
"log",
".",
"debug",
"(",
"'Performing fileserver updates for items with an update '",
"'interval of %d'",
",",
"interval",
")",
"for",
"backend"... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
train | FileserverUpdate.run | Start the update threads | salt/master.py | def run(self):
'''
Start the update threads
'''
salt.utils.process.appendproctitle(self.__class__.__name__)
# Clean out the fileserver backend cache
salt.daemons.masterapi.clean_fsbackend(self.opts)
for interval in self.buckets:
self.update_threads[in... | def run(self):
'''
Start the update threads
'''
salt.utils.process.appendproctitle(self.__class__.__name__)
# Clean out the fileserver backend cache
salt.daemons.masterapi.clean_fsbackend(self.opts)
for interval in self.buckets:
self.update_threads[in... | [
"Start",
"the",
"update",
"threads"
] | saltstack/salt | python | https://github.com/saltstack/salt/blob/e8541fd6e744ab0df786c0f76102e41631f45d46/salt/master.py#L479-L496 | [
"def",
"run",
"(",
"self",
")",
":",
"salt",
".",
"utils",
".",
"process",
".",
"appendproctitle",
"(",
"self",
".",
"__class__",
".",
"__name__",
")",
"# Clean out the fileserver backend cache",
"salt",
".",
"daemons",
".",
"masterapi",
".",
"clean_fsbackend",
... | e8541fd6e744ab0df786c0f76102e41631f45d46 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.