def salt_grains(self, msg, args):
''' executes a salt command on systems
example:
!salt grains 'os:Centos' cmd.run 'cat /etc/hosts'
'''
if len(args) < 2:
response = '2 parameters required. see !help salt'
self.send(msg.frm,
response,
message_type=msg.type,
in_reply_to=msg,
groupchat_nick_reply=True)
return
targets = args.pop(0)
action = args.pop(0)
api = pepper.Pepper(self.config['api_url'], debug_http=False)
auth = api.login(self.config['api_user'], self.config['api_pass'],
self.config['api_auth'])
ret = api.local(targets,
action,
arg=args,
kwarg=None,
expr_form='grain')
results = json.dumps(ret, sort_keys=True, indent=4)
self.send(msg.frm,
self.pastebin(results),
message_type=msg.type,
in_reply_to=msg,
groupchat_nick_reply=True)
def run(self):
'''
Parse all arguments and call salt-api
'''
self.parse()
# move logger instantiation to method?
logger.addHandler(logging.StreamHandler())
logger.setLevel(max(logging.ERROR - (self.options.verbose * 10), 1))
load = self.parse_cmd()
api = pepper.Pepper(
self.parse_url(),
debug_http=self.options.debug_http,
ignore_ssl_errors=self.options.ignore_ssl_certificate_errors)
self.login(api)
if self.options.fail_if_minions_dont_respond:
for exit_code, ret in self.poll_for_returns(api, load):
yield exit_code, json.dumps(ret, sort_keys=True, indent=4)
else:
ret = self.low(api, load)
exit_code = 0
yield exit_code, json.dumps(ret, sort_keys=True, indent=4)
def update_asset_info(asset=None):
"""
:param asset: should be list type
:return: None
"""
salt_api = pepper.Pepper(SALT_API['url'], ignore_ssl_errors=True)
salt_api.login(SALT_API['username'], SALT_API['password'], eauth='pam')
if asset:
ret = salt_api.local(asset, 'grains.items',
expr_form='list')['return'][0]
else:
ret = salt_api.local('*', 'grains.items')['return'][0]
print(ret)
for k, v in ret.items():
if Asset.objects.filter(sn=v['serialnumber']).exists():
obj = Asset.objects.get(sn=v['serialnumber'])
_update_asset(obj, v)
elif Asset.objects.filter(ip=IpAddress.objects.get(
ip_address=k)).exists():
obj = Asset.objects.get(ip=IpAddress.objects.get(ip_address=k))
_update_asset(obj, v)
else:
_create_asset(v)
def run(self):
'''
Parse all arguments and call salt-api
'''
# set up logging
rootLogger = logging.getLogger(name=None)
rootLogger.addHandler(logging.StreamHandler())
rootLogger.setLevel(max(logging.ERROR - (self.options.verbose * 10),
1))
api = pepper.Pepper(
self.parse_url(),
debug_http=self.options.debug_http,
ignore_ssl_errors=self.options.ignore_ssl_certificate_errors)
self.login(api)
load = self.parse_cmd(api)
for entry in load:
if not entry.get('client', '').startswith('wheel'):
entry['full_return'] = True
if self.options.fail_if_minions_dont_respond:
for exit_code, ret in self.poll_for_returns(
api, load): # pragma: no cover
yield exit_code, json.dumps(ret, sort_keys=True, indent=4)
else:
ret = self.low(api, load)
exit_code = 0
yield exit_code, json.dumps(ret, sort_keys=True, indent=4)
def salt_api(app):
"""Init the salt-api connector"""
g.user = current_user
if g.user.is_anonymous:
g.salt = None
elif g.user.auth:
g.salt = pepper.Pepper(app.config['SALT_URI'])
g.salt.auth = g.user.auth
else:
g.salt = None
def pepper(self, irc, msg, args, systems, action, params):
"""{vm-name | vm-glob} <module> [<params>]
Example: .pepper dil-vm-app-*.* cmd.rum 'cat /etc/hosts'
Returns the link to pastebin of the pepper output
"""
tgt, fun = systems, action
api = pepper.Pepper(self.api_url, debug_http=False)
auth = api.login(self.api_user, self.api_password, self.api_eauth)
ret = api.local(tgt, fun, arg=params, kwarg=None, expr_form='pcre')
results = json.dumps(ret, sort_keys=True, indent=4)
irc.reply(self.paste_code(results))
def run(self):
'''
Parse all arguments and call salt-api
'''
self.parse()
# move logger instantiation to method?
logger.addHandler(logging.StreamHandler())
logger.setLevel(max(logging.ERROR - (self.options.verbose * 10), 1))
load = self.parse_cmd()
api = pepper.Pepper(
self.parse_url(),
debug_http=self.options.debug_http,
ignore_ssl_errors=self.options.ignore_ssl_certificate_errors)
if self.options.mktoken:
token_file = self.options.cache
try:
with open(token_file, 'rt') as f:
api.auth = json.load(f)
if api.auth['expire'] < time.time() + 30:
logger.error('Login token expired')
raise Exception('Login token expired')
api.req('/stats')
except Exception as e:
if e.args[0] is not 2:
logger.error(
'Unable to load login token from {0} {1}'.format(
token_file, str(e)))
auth = api.login(*self.parse_login())
try:
oldumask = os.umask(0)
fdsc = os.open(token_file, os.O_WRONLY | os.O_CREAT, 0o600)
with os.fdopen(fdsc, 'wt') as f:
json.dump(auth, f)
except Exception as e:
logger.error('Unable to save token to {0} {1}'.format(
token_file, str(e)))
finally:
os.umask(oldumask)
else:
auth = api.login(*self.parse_login())
if self.options.fail_if_minions_dont_respond:
for exit_code, ret in self.poll_for_returns(api, load):
yield exit_code, json.dumps(ret, sort_keys=True, indent=4)
else:
ret = api.low(load)
exit_code = 0
yield exit_code, json.dumps(ret, sort_keys=True, indent=4)
def _connect(self):
try:
username = self._bot_config.SALT_API_USERNAME
password = self._bot_config.SALT_API_PASSWORD
eauth = self._bot_config.SALT_API_EAUTH
url = self._bot_config.SALT_API_URL
if self._api_endpoint is None:
self._api_endpoint = pepper.Pepper(url, debug_http=False)
self._api_endpoint.login(username=username,
password=password,
eauth=eauth)
return self._api_endpoint
except:
raise Exception("Could no establish connection with Salt API")
def authenticate(cls, login, password):
"""Performe the authentication against salt-api"""
salt = pepper.Pepper(current_app.config['SALT_URI'])
auth = None
try:
auth = salt.login(login, password, 'pam')
authenticated = True
except urllib2.URLError:
flash('Error connecting to salt master', 'warning')
authenticated = False
except pepper.libpepper.PepperException as err:
flash(err, 'warning')
authenticated = False
user = cls(login, auth)
if authenticated:
USER[user.username] = user
return user, authenticated
def run(self):
'''
Parse all arguments and call salt-api
'''
self.parse()
# move logger instantiation to method?
logger.addHandler(logging.StreamHandler())
logger.setLevel(max(logging.ERROR - (self.options.verbose * 10), 1))
load = self.parse_cmd()
creds = iter(self.parse_login())
api = pepper.Pepper(creds.next(), debug_http=self.options.debug_http)
auth = api.login(*list(creds))
if self.options.fail_if_minions_dont_respond:
exit_code, ret = self.poll_for_returns(api, load)
else:
ret = api.low(load)
exit_code = 0
return (exit_code, json.dumps(ret, sort_keys=True, indent=4))
def __init__(self, debug_http=False, *args, **kwargs):
self.configure(**kwargs)
self._pepper = pepper.Pepper(self.confs['SALTAPI_URL'],
debug_http=debug_http)
def run(self):
'''
Parse all arguments and call salt-api
'''
self.parse()
# move logger instantiation to method?
logger.addHandler(logging.StreamHandler())
logger.setLevel(max(logging.ERROR - (self.options.verbose * 10), 1))
if len(self.args) < 2:
self.parser.error("Command not specified")
tgt, fun = self.args[0:2]
login_details = self.get_login_details()
# Auth values placeholder; grab interactively at CLI or from config file
salturl = login_details['SALTAPI_URL']
saltuser = login_details['SALTAPI_USER']
saltpass = login_details['SALTAPI_PASS']
salteauth = login_details['SALTAPI_EAUTH']
api = pepper.Pepper(salturl, debug_http=self.options.debug_http)
auth = api.login(saltuser, saltpass, salteauth)
nodesJidRet = api.local_async(tgt=tgt,
fun='test.ping',
expr_form=self.options.expr_form)
nodesJid = nodesJidRet['return'][0]['jid']
time.sleep(self.seconds_to_wait)
nodesRet = api.lookup_jid(nodesJid)
if fun == 'test.ping':
return (0,
json.dumps(nodesRet['return'][0], sort_keys=True,
indent=4))
nodes = nodesRet['return'][0].keys()
if nodes == []:
return (0, json.dumps({}))
commandJidRet = api.local_async(tgt=nodes,
fun=fun,
arg=self.args[2:],
expr_form='list')
commandJid = commandJidRet['return'][0]['jid']
# keep trying until all expected nodes return
commandRet = api.lookup_jid(commandJid)
returnedNodes = commandRet['return'][0].keys()
total_time = self.seconds_to_wait
while set(returnedNodes) != set(nodes):
if total_time > self.options.timeout:
break
time.sleep(self.seconds_to_wait)
commandRet = api.lookup_jid(commandJid)
returnedNodes = commandRet['return'][0].keys()
if set(returnedNodes) != set(
nodes) and self.options.fail_if_minions_dont_respond is True:
exit_code = 1
else:
exit_code = 0
return (exit_code,
json.dumps(commandRet['return'][0], sort_keys=True, indent=4))
def pepper_client(session_salt_api, salt_api_port):
client = pepper.Pepper('http://localhost:{0}'.format(salt_api_port))
client.login('pepper', 'pepper', 'sharedsecret')
return client
