def get(self, many=False):
"""Function retrieves predefined log files from worker"""
if not self.node.is_online():
raise NodeIsNotOperational()
single_log_file = self.data.get('logname', None)
if single_log_file:
# make sure that file is among allowed files,
# otherwise any file with read permission can be retrieved
if single_log_file in self.log_files:
self.log_files = (single_log_file, )
else:
logger.error(
'Error retrieving log file %s, file not among allowed files!',
single_log_file)
raise ObjectNotFound(object_name=single_log_file)
worker = self.node.worker('fast')
logger.debug('Retrieving log files from node "%s"', self.node)
log_files_result = worker_command('system_read_logs',
worker,
log_files=self.log_files,
timeout=10)
if log_files_result is None:
raise GatewayTimeout('Node worker is not responding')
return SuccessTaskResponse(self.request,
log_files_result,
dc_bound=self.dc_bound)
def _update(self, version, key=None, cert=None):
node = self.node
worker = node.worker(Q_FAST)
logger.debug('Running node "%s" system update to version: "%s"', node,
version)
reply = worker_command('system_update',
worker,
version=version,
key=key,
cert=cert,
timeout=600)
if reply is None:
raise GatewayTimeout('Node worker is not responding')
response_class, result = process_update_reply(reply, node, version)
response = response_class(self.request,
result,
task_id=self.task_id,
obj=node,
msg=LOG_SYSTEM_UPDATE,
detail_dict=result,
dc_bound=False)
if response.status_code == 200:
# Restart all erigonesd workers
ctrl = NodeServiceControl(node)
for service in ctrl.app_services:
ctrl.restart(service)
return response
def _execute_cmd(self, cmd, **kwargs):
"""Run a worker panel command and return the command dict"""
cmd = cmd.format(**kwargs)
worker = self.node.worker('fast')
reply = worker_command('execute', worker, cmd=cmd.split())
if reply is None:
raise GatewayTimeout('Node worker is not responding')
return reply
def system_version(self):
from que.utils import worker_command
version = cache.get(self._system_version_key)
if not version:
worker = self.worker('fast')
version = worker_command('system_version', worker,
timeout=0.5) or ''
if version:
cache.set(self._system_version_key, version,
self.SYSTEM_VERSION_EXPIRES)
return version
def _update_v2(self, version, key=None, cert=None):
from api.system.update.utils import process_update_reply
node = self.node
worker = node.worker(Q_FAST)
logger.info(
'Running oldstyle (v2.x) node "%s" system update to version: "%s"',
node, version)
reply = worker_command('system_update',
worker,
version=version,
key=key,
cert=cert,
timeout=600)
if reply is None:
raise GatewayTimeout('Node worker is not responding')
result, error = process_update_reply(reply, node, version)
if error:
response_class = FailureTaskResponse
else:
response_class = SuccessTaskResponse
detail_dict = result.copy()
detail_dict['version'] = version
response = response_class(self.request,
result,
obj=node,
msg=LOG_SYSTEM_UPDATE,
dc_bound=False,
detail_dict=detail_dict)
if response.status_code == 200:
# Restart all erigonesd workers
ctrl = NodeServiceControl(node)
for service in ctrl.app_services:
ctrl.restart(service)
return response
def system_version(self):
from que.utils import worker_command
worker = self.worker('fast')
return worker_command('system_version', worker, timeout=0.3) or ''
def put(self):
assert self.request.dc.is_default()
ser = UpdateSerializer(self.request, data=self.data)
if not ser.is_valid():
return FailureTaskResponse(self.request,
ser.errors,
dc_bound=False)
node = self.node
version = ser.data['version']
key = ser.data.get('key')
cert = ser.data.get('cert')
del node.system_version # Request latest version in next command
node_version = node.system_version
if not (isinstance(node_version, text_type) and node_version):
raise NodeIsNotOperational(
'Node version information could not be retrieved')
node_version = node_version.split(':')[-1] # remove edition prefix
if version == ('v' + node_version) and not ser.data.get('force'):
raise PreconditionRequired('Node is already up-to-date')
if node.status != node.OFFLINE:
raise NodeIsNotOperational(
'Unable to perform update on node that is not in maintenance state'
)
if node_version.startswith('2.'):
# Old-style (pre 3.0) update mechanism
return self._update_v2(version, key=key, cert=cert)
# Upload key and cert and get command array
worker = node.worker(Q_FAST)
update_cmd = worker_command('system_update_command',
worker,
version=version,
key=key,
cert=cert,
force=ser.data.get('force'),
timeout=10)
if update_cmd is None:
raise GatewayTimeout('Node worker is not responding')
if not isinstance(update_cmd, list):
raise PreconditionRequired(
'Node update command could be retrieved')
msg = LOG_SYSTEM_UPDATE
_apiview_ = {
'view': 'system_node_update',
'method': self.request.method,
'hostname': node.hostname,
'version': version,
}
meta = {
'apiview': _apiview_,
'msg': msg,
'node_uuid': node.uuid,
'output': {
'returncode': 'returncode',
'stdout': 'message'
},
'check_returncode': True,
}
lock = self.LOCK % node.hostname
cmd = '%s 2>&1' % ' '.join(update_cmd)
tid, err = execute(self.request,
node.owner.id,
cmd,
meta=meta,
lock=lock,
queue=node.fast_queue,
tg=TG_DC_UNBOUND)
if err:
return FailureTaskResponse(self.request, err, dc_bound=False)
else:
return TaskResponse(self.request,
tid,
msg=msg,
obj=node,
api_view=_apiview_,
data=self.data,
dc_bound=False,
detail_dict=ser.detail_dict(force_full=True))
