def update_monitoring(request):
"""Enable/disable monitoring for this machine using the hosted mist.io
service.
"""
user = user_from_request(request)
cloud_id = request.matchdict['cloud']
machine_id = request.matchdict['machine']
params = params_from_request(request)
if not user.mist_api_token:
log.info("trying to authenticate to service first")
email = params.get('email')
password = params.get('password')
if not email or not password:
raise UnauthorizedError("You need to authenticate to mist.io.")
payload = {'email': email, 'password': password}
try:
ret = requests.post(config.CORE_URI + '/auth', params=payload,
verify=config.SSL_VERIFY)
except requests.exceptions.SSLError as exc:
log.error("%r", exc)
raise SSLError()
if ret.status_code == 200:
ret_dict = json.loads(ret.content)
with user.lock_n_load():
user.email = email
user.mist_api_token = ret_dict.pop('token', '')
user.save()
log.info("succesfully check_authed")
elif ret.status_code in [400, 401]:
with user.lock_n_load():
user.email = ""
user.mist_api_token = ""
user.save()
raise UnauthorizedError("You need to authenticate to mist.io.")
else:
raise UnauthorizedError("You need to authenticate to mist.io.")
action = params.get('action') or 'enable'
name = params.get('name', '')
public_ips = params.get('public_ips', [])
dns_name = params.get('dns_name', '')
no_ssh = bool(params.get('no_ssh', False))
dry = bool(params.get('dry', False))
if action == 'enable':
ret_dict = methods.enable_monitoring(
user, cloud_id, machine_id, name, dns_name, public_ips,
no_ssh=no_ssh, dry=dry
)
elif action == 'disable':
methods.disable_monitoring(user, cloud_id, machine_id, no_ssh=no_ssh)
ret_dict = {}
else:
raise BadRequestError()
return ret_dict
def update_monitoring(request):
"""Enable/disable monitoring for this machine using the hosted mist.io
service.
"""
user = user_from_request(request)
cloud_id = request.matchdict['cloud']
machine_id = request.matchdict['machine']
params = params_from_request(request)
if not user.mist_api_token:
log.info("trying to authenticate to service first")
email = params.get('email')
password = params.get('password')
if not email or not password:
raise UnauthorizedError("You need to authenticate to mist.io.")
payload = {'email': email, 'password': password}
try:
ret = requests.post(config.CORE_URI + '/auth',
params=payload,
verify=config.SSL_VERIFY)
except requests.exceptions.SSLError as exc:
log.error("%r", exc)
raise SSLError()
if ret.status_code == 200:
ret_dict = json.loads(ret.content)
with user.lock_n_load():
user.email = email
user.mist_api_token = ret_dict.pop('mist_api_token', '')
user.save()
log.info("succesfully check_authed")
else:
raise UnauthorizedError("You need to authenticate to mist.io.")
action = params.get('action') or 'enable'
name = params.get('name', '')
public_ips = params.get('public_ips', [])
dns_name = params.get('dns_name', '')
no_ssh = bool(params.get('no_ssh', False))
dry = bool(params.get('dry', False))
if action == 'enable':
ret_dict = methods.enable_monitoring(user,
cloud_id,
machine_id,
name,
dns_name,
public_ips,
no_ssh=no_ssh,
dry=dry)
elif action == 'disable':
methods.disable_monitoring(user, cloud_id, machine_id, no_ssh=no_ssh)
ret_dict = {}
else:
raise BadRequestError()
return ret_dict
def update_monitoring(request):
"""Enable/disable monitoring for this machine using the hosted mist.io
service.
"""
user = user_from_request(request)
backend_id = request.matchdict['backend']
machine_id = request.matchdict['machine']
if not user.mist_api_token:
log.info("trying to authenticate to service first")
email = request.json_body.get('email')
password = request.json_body.get('password')
if not email or not password:
raise UnauthorizedError("You need to authenticate to mist.io.")
payload = {'email': email, 'password': password}
ret = requests.post(config.CORE_URI + '/auth', params=payload, verify=False)
if ret.status_code == 200:
ret_dict = json.loads(ret.content)
with user.lock_n_load():
user.email = email
user.mist_api_token = ret_dict.pop('mist_api_token', '')
user.save()
log.info("succesfully check_authed")
else:
raise UnauthorizedError("You need to authenticate to mist.io.")
action = request.json_body['action'] or 'enable'
name = request.json_body.get('name', '')
public_ips = request.json_body.get('public_ips', [])
dns_name = request.json_body.get('dns_name', '')
payload = {
'action': action,
'name': name,
'public_ips': ",".join(public_ips),
'dns_name': dns_name,
# tells core not to try to run ssh command to (un)deploy collectd
'no_ssh': True,
}
if action == 'enable':
stdout = methods.enable_monitoring(
user, backend_id, machine_id, name, dns_name, public_ips
)
elif action == 'disable':
stdout = methods.disable_monitoring(user, backend_id, machine_id)
else:
raise BadRequestError()
return {'cmd_output': stdout}
def post_deploy_steps(self, email, backend_id, machine_id, monitoring, command,
key_id=None, username=None, password=None, port=22):
from mist.io.methods import ssh_command, connect_provider, enable_monitoring
from mist.io.methods import notify_user, notify_admin
if multi_user:
from mist.core.methods import enable_monitoring
else:
from mist.io.methods import enable_monitoring
user = user_from_email(email)
try:
# find the node we're looking for and get its hostname
conn = connect_provider(user.backends[backend_id])
nodes = conn.list_nodes()
node = None
for n in nodes:
if n.id == machine_id:
node = n
break
if node and len(node.public_ips):
# filter out IPv6 addresses
ips = filter(lambda ip: ':' not in ip, node.public_ips)
host = ips[0]
else:
raise self.retry(exc=Exception(), countdown=120, max_retries=5)
try:
from mist.io.shell import Shell
shell = Shell(host)
# connect with ssh even if no command, to create association
# to be able to enable monitoring
key_id, ssh_user = shell.autoconfigure(
user, backend_id, node.id, key_id, username, password, port
)
if command:
start_time = time()
retval, output = shell.command(command)
execution_time = time() - start_time
output = output.decode('utf-8','ignore')
msg = ("Command: %s\n"
"Return value: %s\n"
"Duration: %d seconds\n"
"Output:%s\n") % (command, retval,
execution_time, output)
msg = msg.encode('utf-8', 'ignore')
msg_title = "Deployment script %s for machine %s (%s)" % (
'failed' if retval else 'succeeded',
node.name, node.id
)
notify_user(user, msg_title, msg)
shell.disconnect()
if monitoring:
try:
enable_monitoring(user, backend_id, node.id,
name=node.name, dns_name=node.extra.get('dns_name',''),
public_ips=ips, no_ssh=False, dry=False,
)
except Exception as e:
print repr(e)
notify_user(user, "Enable monitoring failed for machine %s (%s)" % (node.name, node.id), repr(e))
notify_admin('Enable monitoring on creation failed for user %s machine %s: %r' % (email, node.name, e))
except (ServiceUnavailableError, SSHException) as exc:
raise self.retry(exc=exc, countdown=60, max_retries=5)
except Exception as exc:
if str(exc).startswith('Retry'):
raise
amqp_log("Deployment script failed for machine %s in backend %s by user %s after 5 retries: %s" % (node.id, backend_id, email, repr(exc)))
notify_user(user, "Deployment script failed for machine %s after 5 retries" % node.id)
notify_admin("Deployment script failed for machine %s in backend %s by user %s after 5 retries" % (node.id, backend_id, email), repr(exc))
def post_deploy_steps(self,
email,
backend_id,
machine_id,
monitoring,
command,
key_id=None,
username=None,
password=None,
port=22):
from mist.io.methods import ssh_command, connect_provider, enable_monitoring
from mist.io.methods import notify_user, notify_admin
if multi_user:
from mist.core.methods import enable_monitoring
from mist.core.helpers import log_event
else:
from mist.io.methods import enable_monitoring
log_event = lambda *args, **kwargs: None
user = user_from_email(email)
try:
# find the node we're looking for and get its hostname
conn = connect_provider(user.backends[backend_id])
nodes = conn.list_nodes()
node = None
for n in nodes:
if n.id == machine_id:
node = n
break
if node and len(node.public_ips):
# filter out IPv6 addresses
ips = filter(lambda ip: ':' not in ip, node.public_ips)
host = ips[0]
else:
raise self.retry(exc=Exception(), countdown=120, max_retries=5)
try:
from mist.io.shell import Shell
shell = Shell(host)
# connect with ssh even if no command, to create association
# to be able to enable monitoring
key_id, ssh_user = shell.autoconfigure(user, backend_id, node.id,
key_id, username, password,
port)
backend = user.backends[backend_id]
msg = "Backend:\n Name: %s\n Id: %s\n" % (backend.title,
backend_id)
msg += "Machine:\n Name: %s\n Id: %s\n" % (node.name, node.id)
if command:
log_dict = {
'email': email,
'event_type': 'job',
'backend_id': backend_id,
'machine_id': machine_id,
'job_id': uuid.uuid4().hex,
'command': command,
'host': host,
'key_id': key_id,
'ssh_user': ssh_user,
}
log_event(action='deployment_script_started', **log_dict)
start_time = time()
retval, output = shell.command(command)
execution_time = time() - start_time
output = output.decode('utf-8', 'ignore')
title = "Deployment script %s" % ('failed'
if retval else 'succeeded')
notify_user(user,
title,
backend_id=backend_id,
machine_id=machine_id,
machine_name=node.name,
command=command,
output=output,
duration=execution_time,
retval=retval,
error=retval > 0)
log_event(action='deployment_script_finished',
error=retval > 0,
return_value=retval,
stdout=output,
**log_dict)
shell.disconnect()
if monitoring:
try:
enable_monitoring(
user,
backend_id,
node.id,
name=node.name,
dns_name=node.extra.get('dns_name', ''),
public_ips=ips,
no_ssh=False,
dry=False,
)
except Exception as e:
print repr(e)
notify_user(
user, "Enable monitoring failed for machine %s (%s)" %
(node.name, node.id), repr(e))
notify_admin(
'Enable monitoring on creation failed for user %s machine %s: %r'
% (email, node.name, e))
except (ServiceUnavailableError, SSHException) as exc:
raise self.retry(exc=exc, countdown=60, max_retries=5)
except Exception as exc:
if str(exc).startswith('Retry'):
raise
notify_user(
user, "Deployment script failed for machine %s after 5 retries" %
node.id)
notify_admin(
"Deployment script failed for machine %s in backend %s by user %s after 5 retries"
% (node.id, backend_id, email), repr(exc))
log_event(
email=email,
event_type='job',
action='deployment_script_failed',
backend_id=backend_id,
machine_id=machine_id,
enable_monitoring=bool(monitoring),
command=command,
error="Couldn't connect to run post deploy steps (5 attempts).",
)
def update_monitoring(request):
"""Enable/disable monitoring for this machine using the hosted mist.io
service.
"""
user = user_from_request(request)
backend_id = request.matchdict['backend']
machine_id = request.matchdict['machine']
if not user.mist_api_token:
log.info("trying to authenticate to service first")
email = request.json_body.get('email')
password = request.json_body.get('password')
if not email or not password:
raise UnauthorizedError("You need to authenticate to mist.io.")
payload = {'email': email, 'password': password}
try:
ret = requests.post(config.CORE_URI + '/auth',
params=payload,
verify=config.SSL_VERIFY)
except requests.exceptions.SSLError as exc:
log.error("%r", exc)
raise SSLError()
if ret.status_code == 200:
ret_dict = json.loads(ret.content)
with user.lock_n_load():
user.email = email
user.mist_api_token = ret_dict.pop('mist_api_token', '')
user.save()
log.info("succesfully check_authed")
else:
raise UnauthorizedError("You need to authenticate to mist.io.")
action = request.json_body['action'] or 'enable'
name = request.json_body.get('name', '')
public_ips = request.json_body.get('public_ips', [])
dns_name = request.json_body.get('dns_name', '')
no_ssh = bool(request.json_body.get('no_ssh', False))
dry = bool(request.json_body.get('dry', False))
payload = {
'action': action,
'name': name,
'public_ips': ",".join(public_ips),
'dns_name': dns_name,
# tells core not to try to run ssh command to (un)deploy collectd
'no_ssh': True,
'dry': dry,
}
if action == 'enable':
ret_dict = methods.enable_monitoring(user,
backend_id,
machine_id,
name,
dns_name,
public_ips,
no_ssh=no_ssh,
dry=dry)
elif action == 'disable':
stdout = methods.disable_monitoring(user,
backend_id,
machine_id,
no_ssh=no_ssh)
ret_dict = {'cmd_output': stdout}
else:
raise BadRequestError()
return ret_dict
def post_deploy_steps(self, email, backend_id, machine_id, monitoring, command,
key_id=None, username=None, password=None, port=22):
from mist.io.methods import ssh_command, connect_provider, enable_monitoring
from mist.io.methods import notify_user, notify_admin
if multi_user:
from mist.core.methods import enable_monitoring
from mist.core.helpers import log_event
else:
from mist.io.methods import enable_monitoring
log_event = lambda *args, **kwargs: None
user = user_from_email(email)
try:
# find the node we're looking for and get its hostname
conn = connect_provider(user.backends[backend_id])
nodes = conn.list_nodes()
node = None
for n in nodes:
if n.id == machine_id:
node = n
break
if node and len(node.public_ips):
# filter out IPv6 addresses
ips = filter(lambda ip: ':' not in ip, node.public_ips)
host = ips[0]
else:
raise self.retry(exc=Exception(), countdown=120, max_retries=5)
try:
from mist.io.shell import Shell
shell = Shell(host)
# connect with ssh even if no command, to create association
# to be able to enable monitoring
key_id, ssh_user = shell.autoconfigure(
user, backend_id, node.id, key_id, username, password, port
)
backend = user.backends[backend_id]
msg = "Backend:\n Name: %s\n Id: %s\n" % (backend.title,
backend_id)
msg += "Machine:\n Name: %s\n Id: %s\n" % (node.name,
node.id)
if command:
log_dict = {
'email': email,
'event_type': 'job',
'backend_id': backend_id,
'machine_id': machine_id,
'job_id': uuid.uuid4().hex,
'command': command,
'host': host,
'key_id': key_id,
'ssh_user': ssh_user,
}
log_event(action='deployment_script_started', **log_dict)
start_time = time()
retval, output = shell.command(command)
execution_time = time() - start_time
output = output.decode('utf-8','ignore')
title = "Deployment script %s" % ('failed' if retval
else 'succeeded')
notify_user(user, title,
backend_id=backend_id,
machine_id=machine_id,
machine_name=node.name,
command=command,
output=output,
duration=execution_time,
retval=retval,
error=retval > 0)
log_event(action='deployment_script_finished',
error=retval > 0,
return_value=retval,
stdout=output,
**log_dict)
shell.disconnect()
if monitoring:
try:
enable_monitoring(user, backend_id, node.id,
name=node.name, dns_name=node.extra.get('dns_name',''),
public_ips=ips, no_ssh=False, dry=False,
)
except Exception as e:
print repr(e)
notify_user(user, "Enable monitoring failed for machine %s (%s)" % (node.name, node.id), repr(e))
notify_admin('Enable monitoring on creation failed for user %s machine %s: %r' % (email, node.name, e))
except (ServiceUnavailableError, SSHException) as exc:
raise self.retry(exc=exc, countdown=60, max_retries=5)
except Exception as exc:
if str(exc).startswith('Retry'):
raise
notify_user(user, "Deployment script failed for machine %s after 5 retries" % node.id)
notify_admin("Deployment script failed for machine %s in backend %s by user %s after 5 retries" % (node.id, backend_id, email), repr(exc))
log_event(
email=email,
event_type='job',
action='deployment_script_failed',
backend_id=backend_id,
machine_id=machine_id,
enable_monitoring=bool(monitoring),
command=command,
error="Couldn't connect to run post deploy steps (5 attempts).",
)
