return response_str
def init_node_proxy(self, ssl_ctx: Any) -> None:
- node_proxy_data = json.dumps({'keyring': self.keyring,
- 'host': self.host})
- node_proxy_data = node_proxy_data.encode('ascii')
- result = self.query_endpoint(data=node_proxy_data,
+ node_proxy_meta = {
+ 'cephx': {
+ 'name': self.host,
+ 'secret': self.keyring
+ }
+ }
+ result = self.query_endpoint(data=json.dumps(node_proxy_meta).encode('ascii'),
endpoint='/node-proxy/idrac',
ssl_ctx=ssl_ctx)
result_json = json.loads(result)
'host': result_json['result']['addr'],
'username': result_json['result']['username'],
'password': result_json['result']['password'],
- 'data': node_proxy_data,
+ 'cephx': node_proxy_meta['cephx'],
'mgr_target_ip': self.target_ip,
'mgr_target_port': self.target_port,
}
def get_system(self) -> Dict[str, Dict[str, Dict]]:
result = {
- 'storage': self.get_storage(),
- 'processors': self.get_processors(),
- 'network': self.get_network(),
- 'memory': self.get_memory(),
- 'power': self.get_power(),
- 'fans': self.get_fans()
+ 'host': self.get_host(),
+ 'sn': self.get_sn(),
+ 'status': {
+ 'storage': self.get_storage(),
+ 'processors': self.get_processors(),
+ 'network': self.get_network(),
+ 'memory': self.get_memory(),
+ 'power': self.get_power(),
+ 'fans': self.get_fans()
+ }
}
return result
+import socket
from .util import Config
from typing import Dict, Any
from .baseclient import BaseClient
def get_storage(self) -> Dict[str, Dict[str, Dict]]:
raise NotImplementedError()
+ def get_sn(self) -> str:
+ raise NotImplementedError()
+
+ def get_host(self) -> str:
+ return socket.gethostname()
+
def start_update_loop(self) -> None:
raise NotImplementedError()
log = Logger(__name__, level=config.__dict__['logging']['level'])
- self.data = json.loads(self.__dict__['data'])
-
# create the redfish system and the obsever
log.logger.info(f"Server initialization...")
try:
try:
reporter_agent = Reporter(self.system,
- self.data,
+ self.__dict__['cephx'],
f"https://{self.__dict__['mgr_target_ip']}:{self.__dict__['mgr_target_port']}/node-proxy/data")
except RuntimeError:
log.logger.error("Can't initialize the reporter.")
return normalize_dict(result)
+ def get_sn(self) -> str:
+ return self._system['SKU']
+
def get_status(self) -> Dict[str, Dict[str, Dict]]:
return self._system['status']
class Reporter:
- def __init__(self, system: Any, data: Dict[str, Any], observer_url: str) -> None:
+ def __init__(self, system: Any, cephx: Dict[str, Any], observer_url: str) -> None:
self.system = system
self.observer_url = observer_url
self.finish = False
- self.data = data
+ self.cephx = cephx
self.log = Logger(__name__)
self.log.logger.info(f'Observer url set to {self.observer_url}')
self.log.logger.info('data ready to be sent to the mgr.')
if not self.system.get_system() == self.system.previous_data:
self.log.logger.info('data has changed since last iteration.')
- self.data['data'] = self.system.get_system()
+ self.data = {}
+ self.data['cephx'] = self.cephx
+ self.data['patch'] = self.system.get_system()
try:
# TODO: add a timeout parameter to the reporter in the config file
self.log.logger.info(f"sending data to {self.observer_url}")
if self.validate_node_proxy_data(data):
idrac_details = self.mgr.get_store('node_proxy/idrac')
idrac_details_json = json.loads(idrac_details)
- results['result'] = idrac_details_json[data["host"]]
+ results['result'] = idrac_details_json[data["cephx"]["name"]]
else:
results['result'] = self.validate_msg
def validate_node_proxy_data(self, data: Dict[str, Any]) -> bool:
self.validate_msg = 'valid node-proxy data received.'
cherrypy.response.status = 200
- if 'host' not in data:
+ if 'cephx' not in data:
cherrypy.response.status = 400
self.validate_msg = 'The field \'host\' must be provided.'
- elif 'keyring' not in data:
+ elif 'secret' not in data['cephx']:
cherrypy.response.status = 400
self.validate_msg = 'The agent keyring must be provided.'
- elif not self.mgr.agent_cache.agent_keys.get(data['host']):
+ elif not self.mgr.agent_cache.agent_keys.get(data['cephx']['name']):
cherrypy.response.status = 400
- self.validate_msg = f'Make sure the agent is running on {data["host"]}'
- elif data['keyring'] != self.mgr.agent_cache.agent_keys[data['host']]:
+ self.validate_msg = f'Make sure the agent is running on {data["cephx"]["name"]}'
+ elif data['cephx']['secret'] != self.mgr.agent_cache.agent_keys[data['cephx']['name']]:
cherrypy.response.status = 403
- self.validate_msg = f'Got wrong keyring from agent on host {data["host"]}.'
+ self.validate_msg = f'Got wrong keyring from agent on host {data["cephx"]["name"]}.'
return cherrypy.response.status == 200
data: Dict[str, Any]) -> List[Dict[str, str]]:
nok_members: List[Dict[str, str]] = []
- for member in data[component].keys():
+ for member in data.keys():
# Force a fake error for testing purpose
if component == 'storage':
_status = 'critical'
_status = 'critical'
state = "[Fake error] power supply unplugged."
else:
- _status = data[component][member]['status']['health'].lower()
+ _status = data[member]['status']['health'].lower()
if _status.lower() != 'ok':
- # state = data[component][member]['status']['state']
+ # state = data[member]['status']['state']
_member = dict(
member=member,
status=_status,
'fans': 'HARDWARE_FANS'
}
- for component in data['data'].keys():
+ for component in data['patch']['status'].keys():
self.mgr.remove_health_warning(mapping[component])
- nok_members = self.get_nok_members(component,
- data['data'])
+ nok_members = self.get_nok_members(component, data['patch']['status'][component])
if nok_members:
count = len(nok_members)
data: Dict[str, Any] = cherrypy.request.json
if self.validate_node_proxy_data(data):
- host = data['host']
- self.mgr.node_proxy.save(host, data['data'])
+ host = data['cephx']['name']
+ self.mgr.node_proxy.save(host, data['patch'])
self.raise_alert(data)
results["result"] = self.validate_msg
except AttributeError:
try:
result = self.common(**kw)
- except RuntimeError:
+ except RuntimeError as e:
cherrypy.response.status = 404
- result = {}
+ result = {"error": f"{e}"}
return {"error": "Not a valid endpoint."}
finally:
return result
def fullreport(self, **kw: Any) -> Dict[str, Any]:
hostname = kw.get('hostname')
if hostname not in self.data.keys():
- return self.data
+ return [self.data[h] for h in self.data.keys()]
else:
return self.data[hostname]
for host, data in results.items():
_result[host] = {}
- for component, details in data.items():
- res = any([member['status']['health'].lower() != 'ok' for member in data[component].values()])
+ for component, details in data['status'].items():
+ res = any([member['status']['health'].lower() != 'ok' for member in data['status'][component].values()])
_result[host][component] = mapper[res]
if hostname and hostname in results.keys():
for host, data in self.data.items():
try:
- _result[host] = data[cmd]
+ _result[host] = data['status'][cmd]
except KeyError:
raise RuntimeError(f'Invalid node-proxy category {cmd}')
projects / ceph.git / commitdiff