def _configure_exchange(self, retry=False): """Configure the RabbitMQ exchange with defaults available""" try: self._virtual_host = self._conf_reader._get_value_with_default( self.LOGGINGPROCESSOR, self.VIRT_HOST, 'SSPL') self._exchange_name = self._conf_reader._get_value_with_default( self.LOGGINGPROCESSOR, self.EXCHANGE_NAME, 'sspl-in') self._queue_name = self._conf_reader._get_value_with_default( self.LOGGINGPROCESSOR, self.QUEUE_NAME, 'iem-queue') self._routing_key = self._conf_reader._get_value_with_default( self.LOGGINGPROCESSOR, self.ROUTING_KEY, 'iem-key') self._username = self._conf_reader._get_value_with_default( self.LOGGINGPROCESSOR, self.USER_NAME, 'sspluser') self._password = self._conf_reader._get_value_with_default( self.LOGGINGPROCESSOR, self.PASSWORD, 'sspl4ever') cluster_id = self._conf_reader._get_value_with_default( self.SYSTEM_INFORMATION_KEY, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION_KEY).get( self.CLUSTER_ID_KEY), '') # Decrypt RabbitMQ Password decryption_key = encryptor.gen_key(cluster_id, ServiceTypes.RABBITMQ.value) self._password = encryptor.decrypt(decryption_key, self._password.encode('ascii'), "LoggingProcessor") self._connection = RabbitMQSafeConnection( self._username, self._password, self._virtual_host, self._exchange_name, self._routing_key, self._queue_name) except Exception as ex: logger.error("_configure_exchange: %s" % ex)
def _read_config(self): """Configure the RabbitMQ exchange with defaults available""" try: self._virtual_host = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.VIRT_HOST, 'SSPL') # Read common RabbitMQ configuration self._primary_rabbitmq_host = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.PRIMARY_RABBITMQ_HOST, 'localhost') # Read RabbitMQ configuration for sensor messages self._queue_name = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.QUEUE_NAME, 'sensor-queue') self._exchange_name = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.EXCHANGE_NAME, 'sspl-out') self._routing_key = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.ROUTING_KEY, 'sensor-key') # Read RabbitMQ configuration for Ack messages self._ack_queue_name = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.ACK_QUEUE_NAME, 'sensor-queue') self._ack_routing_key = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.ACK_ROUTING_KEY, 'sensor-key') self._username = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.USER_NAME, 'sspluser') self._password = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.PASSWORD, '') self._signature_user = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.SIGNATURE_USERNAME, 'sspl-ll') self._signature_token = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.SIGNATURE_TOKEN, 'FAKETOKEN1234') self._signature_expires = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.SIGNATURE_EXPIRES, "3600") self._iem_route_addr = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.IEM_ROUTE_ADDR, '') self._iem_route_exchange_name = self._conf_reader._get_value_with_default( self.RABBITMQPROCESSOR, self.IEM_ROUTE_EXCHANGE_NAME, 'sspl-in') cluster_id = self._conf_reader._get_value_with_default( self.SYSTEM_INFORMATION_KEY, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION_KEY).get( self.CLUSTER_ID_KEY), '') # Decrypt RabbitMQ Password decryption_key = encryptor.gen_key(cluster_id, ServiceTypes.RABBITMQ.value) self._password = encryptor.decrypt(decryption_key, self._password.encode('ascii'), "RabbitMQegressProcessor") if self._iem_route_addr != "": logger.info(" Routing IEMs to host: %s" % self._iem_route_addr) logger.info(" Using IEM exchange: %s" % self._iem_route_exchange_name) except Exception as ex: logger.error("RabbitMQegressProcessor, _read_config: %r" % ex)
def __init__(self): super(RealStorEnclosure, self).__init__() # WS Request common headers self.ws = WebServices() self.common_reqheaders = {} self.encl_conf = self.CONF_SECTION_MC self.system_persistent_cache = self.encl_cache + "system/" self.faults_persistent_cache = self.system_persistent_cache + "faults.json" # Read in mc value from configuration file self.mc1 = Conf.get(GLOBAL_CONF, CNTRLR_PRIMARY_IP_KEY, self.DEFAULT_MC_IP) self.mc1_wsport = str( Conf.get(GLOBAL_CONF, CNTRLR_PRIMARY_PORT_KEY, '')) self.mc2 = Conf.get(GLOBAL_CONF, CNTRLR_SECONDARY_IP_KEY, self.DEFAULT_MC_IP) self.mc2_wsport = str( Conf.get(GLOBAL_CONF, CNTRLR_SECONDARY_PORT_KEY, '')) self.active_ip = self.mc1 self.active_wsport = self.mc1_wsport self.user = Conf.get(GLOBAL_CONF, CNTRLR_USER_KEY, self.DEFAULT_USER) _secret = Conf.get(GLOBAL_CONF, CNTRLR_SECRET_KEY, self.DEFAULT_PASSWD) self.mc_interface = Conf.get(SSPL_CONF, f"{STORAGE_ENCLOSURE}>{MGMT_INTERFACE}", "cliapi") self.pollfreq = int( Conf.get(SSPL_CONF, f"{self.CONF_REALSTORSENSORS}>{POLLING_FREQUENCY}", self.DEFAULT_POLL)) self.site_id = Conf.get(GLOBAL_CONF, SITE_ID_KEY, "DC01") self.rack_id = Conf.get(GLOBAL_CONF, RACK_ID_KEY, "RC01") self.node_id = Conf.get(GLOBAL_CONF, NODE_ID_KEY, "SN01") self.cluster_id = Conf.get(GLOBAL_CONF, CLUSTER_ID_KEY, "CC01") # Decrypt MC secret decryption_key = encryptor.gen_key( ENCLOSURE, ServiceTypes.STORAGE_ENCLOSURE.value) self.__passwd = encryptor.decrypt(decryption_key, _secret, "RealStoreEncl") if self.mc_interface not in self.realstor_supported_interfaces: logger.error("Unspported Realstor interface configured," " monitoring and alerts generation may hamper") return # login to mc to get session key, required for querying resources # periodically self.login()
def _configure_exchange(self, retry=False): """Configure the RabbitMQ exchange with defaults available""" # Make methods locally available get_value_with_default = self._conf_reader._get_value_with_default try: self._virtual_host = get_value_with_default( self.RABBITMQPROCESSOR, self.VIRT_HOST, 'SSPL') self._primary_rabbitmq_host = get_value_with_default( self.RABBITMQPROCESSOR, self.PRIMARY_RABBITMQ_HOST, 'localhost') self._exchange_name = get_value_with_default( self.RABBITMQPROCESSOR, self.EXCHANGE_NAME, 'sspl-in') self._queue_name = get_value_with_default(self.RABBITMQPROCESSOR, self.QUEUE_NAME, 'actuator-req-queue') self._routing_key = get_value_with_default(self.RABBITMQPROCESSOR, self.ROUTING_KEY, 'actuator-req-key') self._username = get_value_with_default(self.RABBITMQPROCESSOR, self.USER_NAME, 'sspluser') self._password = get_value_with_default(self.RABBITMQPROCESSOR, self.PASSWORD, 'sspl4ever') cluster_id = get_value_with_default( self.SYSTEM_INFORMATION_KEY, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION_KEY).get( self.CLUSTER_ID_KEY), '') node_id = get_value_with_default( self.SYSTEM_INFORMATION_KEY, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION_KEY).get( self.NODE_ID_KEY), '') # Decrypt RabbitMQ Password decryption_key = encryptor.gen_key(cluster_id, ServiceTypes.RABBITMQ.value) self._password = encryptor.decrypt(decryption_key, self._password.encode('ascii'), "RabbitMQingressProcessor") # Create a routing key unique to this instance unique_routing_key = f'{self._routing_key}_node{node_id}' logger.info(f"Connecting using routing key: {unique_routing_key}") self._connection = RabbitMQSafeConnection( self._username, self._password, self._virtual_host, self._exchange_name, unique_routing_key, self._queue_name) except Exception as ex: logger.error("RabbitMQingressProcessor, _configure_exchange: %r" % ex)
def _configure_exchange(self, retry=False): """Configure the RabbitMQ exchange with defaults available""" # Make methods locally available try: self._virtual_host = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.VIRT_HOST}", 'SSPL') # Read common RabbitMQ configuration self._primary_rabbitmq_host = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.PRIMARY_RABBITMQ_HOST}", 'localhost') # Read RabbitMQ configuration for sensor messages self._queue_name = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.QUEUE_NAME}", 'actuator-req-queue') self._exchange_name = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.EXCHANGE_NAME}", 'sspl-in') self._routing_key = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.ROUTING_KEY}", 'actuator-req-key') self._username = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.USER_NAME}", 'sspluser') self._password = Conf.get(SSPL_CONF, f"{self.RABBITMQPROCESSOR}>{self.PASSWORD}",'') cluster_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{self.CLUSTER_ID_KEY}",'CC01') node_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{self.NODE_ID_KEY}",'SN01') # Decrypt RabbitMQ Password decryption_key = encryptor.gen_key(cluster_id, ServiceTypes.RABBITMQ.value) self._password = encryptor.decrypt(decryption_key, self._password.encode('ascii'), "RabbitMQingressProcessor") # Create a routing key unique to this instance unique_routing_key = f'{self._routing_key}_node{node_id}' logger.info(f"Connecting using routing key: {unique_routing_key}") self._connection = RabbitMQSafeConnection( self._username, self._password, self._virtual_host, self._exchange_name, unique_routing_key, self._queue_name ) except Exception as ex: logger.error("RabbitMQingressProcessor, _configure_exchange: %r" % ex)
def _configure_exchange(self, retry=False): """Configure the RabbitMQ exchange with defaults available""" try: self._virtual_host = Conf.get( SSPL_CONF, f"{self.LOGGINGPROCESSOR}>{self.VIRT_HOST}", 'SSPL') self._exchange_name = Conf.get( SSPL_CONF, f"{self.LOGGINGPROCESSOR}>{self.EXCHANGE_NAME}", 'sspl-in') self._queue_name = Conf.get( SSPL_CONF, f"{self.LOGGINGPROCESSOR}>{self.QUEUE_NAME}", 'iem-queue') self._routing_key = Conf.get( SSPL_CONF, f"{self.LOGGINGPROCESSOR}>{self.ROUTING_KEY}", 'iem-key') self._username = Conf.get( SSPL_CONF, f"{self.LOGGINGPROCESSOR}>{self.USER_NAME}", 'sspluser') self._password = Conf.get( SSPL_CONF, f"{self.LOGGINGPROCESSOR}>{self.PASSWORD}", 'sspl4ever') cluster_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{self.CLUSTER_ID_KEY}", 'CC01') # Decrypt RabbitMQ Password decryption_key = encryptor.gen_key(cluster_id, ServiceTypes.RABBITMQ.value) self._password = encryptor.decrypt(decryption_key, self._password.encode('ascii'), "LoggingProcessor") self._connection = RabbitMQSafeConnection( self._username, self._password, self._virtual_host, self._exchange_name, self._routing_key, self._queue_name) except Exception as ex: logger.error("_configure_exchange: %s" % ex)
def confReader(self): path_to_conf_file = "/etc/sspl.conf" try: conf_reader = ConfigReader(is_test=True, test_config_path=path_to_conf_file) except (IOError, ConfigReader.Error) as err: # We don't have logger yet, need to find log_level from conf file first print("[ Error ] when validating the configuration file %s :" % \ path_to_conf_file) print(err) print("Exiting ...") exit(os.EX_USAGE) self._virtualhost = conf_reader._get_value_with_default( self.module_name, self.VIRTUALHOST, 'SSPL') # Need to keep cluster_id string here to generate decryption key self.cluster_id = conf_reader._get_value_with_default( self.SYSTEM_INFORMATION, self.CLUSTER_ID, 'CC01') # Ingress configuration if self.module_name == "RABBITMQINGRESSPROCESSOR": # Configuration to send message self._ingress_queue = conf_reader._get_value_with_default( self.module_name, self.QUEUE_NAME, 'actuator-req-queue') self._ingress_exchange = conf_reader._get_value_with_default( self.module_name, self.EXCHANGE_NAME, 'sspl-in') self._ingress_key = conf_reader._get_value_with_default( self.module_name, self.ROUTINGKEY, 'actuator-req-key') # Configuration to recieve sensor messages self._egress_queue = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.QUEUE_NAME, 'sensor-queue') self._egress_exchange = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.EXCHANGE_NAME, 'sspl-out') self._egress_key = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.ROUTINGKEY, 'sensor-key') elif self.module_name == "PLANECNTRLRMQINGRESSPROCESSOR": self._ingress_queue = conf_reader._get_value_with_default( self.module_name, self.QUEUE_NAME, 'ras_status') # Egress Queue if self.module_name == "RABBITMQEGRESSPROCESSOR": self._egress_queue = conf_reader._get_value_with_default( self.module_name, self.QUEUE_NAME, 'sensor-queue') elif self.module_name == "PLANECNTRLRMQEGRESSPROCESSOR": self._egress_queue = conf_reader._get_value_with_default( self.module_name, self.QUEUE_NAME, 'ras_control') self._ackexchangename = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.ACKEXCHANGE_NAME, 'sspl-out') self._ackqueuename = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.ACKQUEUE_NAME, 'actuator-resp-queue') self._ackroutingkey = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.ACKROUTINGKEY, 'actuator-resp-key') self._exchangename = conf_reader._get_value_with_default( self.module_name, self.EXCHANGE_NAME, 'sspl-in') self._routingkey = conf_reader._get_value_with_default( self.module_name, self.ROUTINGKEY, 'sensor-key') self._username = conf_reader._get_value_with_default( self.module_name, self.USERNAME, 'sspluser') self._password = conf_reader._get_value_with_default( self.module_name, self.PASSWORD, 'sspl4ever') self._signature_user = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.SIGNATURE_USERNAME, 'sspl-ll') self._signature_token = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.SIGNATURE_TOKEN, 'ALOIUD986798df69a8koDISLKJ282983') self._signature_expires = conf_reader._get_value_with_default( 'RABBITMQEGRESSPROCESSOR', self.SIGNATURE_EXPIRES, "3600") if self.module_name == "PLANECNTRLRMQEGRESSPROCESSOR": self._primary_rabbitmq_server = conf_reader._get_value_with_default( self.module_name, self.PRIMARY_RABBITMQ, 'localhost') self._secondary_rabbitmq_server = conf_reader._get_value_with_default( self.module_name, self.SECONDARY_RABBITMQ, 'localhost') else: self._primary_rabbitmq_server = "localhost" self._secondary_rabbitmq_server = "localhost" decryption_key = encryptor.gen_key(self.cluster_id, ServiceTypes.RABBITMQ.value) self._password = encryptor.decrypt(decryption_key, self._password.encode('ascii'), "TestRabbitmqEgressProcessor") self._current_rabbitmq_server = self._primary_rabbitmq_server
def _run_ipmitool_subcommand(self, subcommand, grep_args=None): """Executes ipmitool sub-commands, and optionally greps the output.""" self.ACTIVE_IPMI_TOOL = self.IPMITOOL host_conf_cmd = "" # Set ipmitool to ipmisimtool if activated. if os.path.exists(f"{DATA_PATH}/server/activate_ipmisimtool"): cmd = self.IPMISIMTOOL + " sel info" _, _, retcode = SimpleProcess(cmd).run() if retcode in [0, 2]: self.ACTIVE_IPMI_TOOL = self.IPMISIMTOOL logger.debug("IPMI simulator is activated.") # Fetch channel info from config file and cache. _channel_interface = Conf.get( SSPL_CONF, "%s>%s" % (BMC_INTERFACE, BMC_CHANNEL_IF)) _active_interface = store.get(BMCInterface.ACTIVE_BMC_IF.value, None) if isinstance(_active_interface, bytes): _active_interface = _active_interface.decode() # Set host_conf_cmd based on channel info. if (self.ACTIVE_IPMI_TOOL != self.IPMISIMTOOL and _active_interface in BMCInterface.LAN_IF.value): bmc_ip = Conf.get(GLOBAL_CONF, BMC_IP_KEY, '') bmc_user = Conf.get(GLOBAL_CONF, BMC_USER_KEY, 'ADMIN') bmc_secret = Conf.get(GLOBAL_CONF, BMC_SECRET_KEY, 'ADMIN') decryption_key = encryptor.gen_key(MACHINE_ID, ServiceTypes.SERVER_NODE.value) bmc_pass = encryptor.decrypt(decryption_key, bmc_secret, self.NAME) host_conf_cmd = BMCInterface.LAN_CMD.value.format( _active_interface, bmc_ip, bmc_user, bmc_pass) # generate the final cmd and execute on shell. command = " ".join([self.ACTIVE_IPMI_TOOL, host_conf_cmd, subcommand]) command = shlex.split(command) out, error, retcode = SimpleProcess(command).run() # Decode bytes encoded strings. if not isinstance(out, str): out = out.decode(self.IPMI_ENCODING) if not isinstance(error, str): error = error.decode(self.IPMI_ENCODING) # Grep the output as per grep_args provided. if grep_args is not None and retcode == 0: final_list = [] for l in out.split('\n'): if re.search(grep_args, l) is not None: final_list += [l] out = '\n'.join(final_list) # Assign error_msg to err from output if retcode and not error: out, error = error, out # Remove '\n' from error, for matching errors to error stings. if error: error = error.replace('\n', '') return out, error, retcode
def __init__(self): super(RealStorEnclosure, self).__init__() # WS Request common headers self.ws = WebServices() self.common_reqheaders = {} self.encl_conf = self.CONF_SECTION_MC self.system_persistent_cache = self.encl_cache + "system/" self.faults_persistent_cache = self.system_persistent_cache + "faults.json" # Read in mc value from configuration file self.mc1 = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get(self.encl_conf).get("primary_controller_ip"), self.DEFAULT_MC_IP) self.mc1_wsport = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get(self.encl_conf).get("primary_controller_port"), '') self.mc2 = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get(self.encl_conf).get("secondary_controller_ip"), self.DEFAULT_MC_IP) self.mc2_wsport = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get( self.encl_conf).get("secondary_controller_port"), '') self.active_ip = self.mc1 self.active_wsport = self.mc1_wsport self.user = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get(self.encl_conf).get("user"), self.DEFAULT_USER) self.passwd = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get(self.encl_conf).get("password"), self.DEFAULT_PASSWD) self.mc_interface = self.conf_reader._get_value_with_default( self.encl_conf, COMMON_CONFIGS.get(self.encl_conf).get("mgmt_interface"), "cliapi") self.pollfreq = int( self.conf_reader._get_value_with_default(self.CONF_REALSTORSENSORS, "polling_frequency", self.DEFAULT_POLL)) self.site_id = self.conf_reader._get_value_with_default( self.SYSTEM_INFORMATION, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION).get(self.SITE_ID), '001') self.rack_id = self.conf_reader._get_value_with_default( self.SYSTEM_INFORMATION, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION).get(self.RACK_ID), '001') self.node_id = self.conf_reader._get_value_with_default( self.SYSTEM_INFORMATION, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION).get(self.NODE_ID), '001') # Need to keep cluster_id string here to generate decryption key self.cluster_id = self.conf_reader._get_value_with_default( self.SYSTEM_INFORMATION, COMMON_CONFIGS.get(self.SYSTEM_INFORMATION).get(self.CLUSTER_ID), '001') # Decrypt MC Password decryption_key = encryptor.gen_key( self.cluster_id, ServiceTypes.STORAGE_ENCLOSURE.value) self.passwd = encryptor.decrypt(decryption_key, self.passwd.encode('ascii'), "RealStoreEncl") if self.mc_interface not in self.realstor_supported_interfaces: logger.error("Unspported Realstor interface configured," " monitoring and alerts generation may hamper") return # login to mc to get session key, required for querying resources # periodically self.login()
def __init__(self): super(RealStorEnclosure, self).__init__() # WS Request common headers self.ws = WebServices() self.common_reqheaders = {} self.encl_conf = self.CONF_SECTION_MC self.system_persistent_cache = self.encl_cache + "system/" self.faults_persistent_cache = self.system_persistent_cache + "faults.json" # Read in mc value from configuration file self.mc1 = Conf.get( GLOBAL_CONF, f"{STORAGE}>{ENCLOSURE}>{CONTROLLER}>{PRIMARY}>{IP}", self.DEFAULT_MC_IP) self.mc1_wsport = str( Conf.get(GLOBAL_CONF, f"{STORAGE}>{ENCLOSURE}>{CONTROLLER}>{PRIMARY}>{PORT}", '')) self.mc2 = Conf.get(GLOBAL_CONF, f"{STORAGE}>{ENCLOSURE}>{SECONDARY}>{IP}", self.DEFAULT_MC_IP) self.mc2_wsport = str( Conf.get(GLOBAL_CONF, f"{STORAGE}>{ENCLOSURE}>{CONTROLLER}>{SECONDARY}>{PORT}", '')) self.active_ip = self.mc1 self.active_wsport = self.mc1_wsport self.user = Conf.get(GLOBAL_CONF, f"{STORAGE}>{ENCLOSURE}>{CONTROLLER}>{USER}", self.DEFAULT_USER) self.passwd = Conf.get(GLOBAL_CONF, f"{STORAGE}>{ENCLOSURE}>{CONTROLLER}>{SECRET}", self.DEFAULT_PASSWD) self.mc_interface = Conf.get(SSPL_CONF, f"{STORAGE_ENCLOSURE}>{MGMT_INTERFACE}", "cliapi") self.pollfreq = int( Conf.get(SSPL_CONF, f"{self.CONF_REALSTORSENSORS}>{POLLING_FREQUENCY}", self.DEFAULT_POLL)) self.site_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{self.SITE_ID}", 'DC01') self.rack_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{self.RACK_ID}", 'RC01') self.node_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{SRVNODE}>{self.NODE_ID}", 'SN01') # Need to keep cluster_id string here to generate decryption key self.cluster_id = Conf.get(GLOBAL_CONF, f"{CLUSTER}>{self.CLUSTER_ID}", 'CC01') # Decrypt MC Password decryption_key = encryptor.gen_key( self.cluster_id, ServiceTypes.STORAGE_ENCLOSURE.value) self.passwd = encryptor.decrypt(decryption_key, self.passwd.encode('ascii'), "RealStoreEncl") if self.mc_interface not in self.realstor_supported_interfaces: logger.error("Unspported Realstor interface configured," " monitoring and alerts generation may hamper") return # login to mc to get session key, required for querying resources # periodically self.login()
from framework.utils.conf_utils import ( GLOBAL_CONF, Conf, ENCLOSURE, CNTRLR_PRIMARY_IP_KEY, CNTRLR_PRIMARY_PORT_KEY, CNTRLR_SECONDARY_IP_KEY, CNTRLR_SECONDARY_PORT_KEY, CNTRLR_USER_KEY, CNTRLR_SECRET_KEY, ENCLOSURE) from framework.utils.encryptor import gen_key, decrypt login_headers = {'datatype': 'json'} timeout = 20 HTTP_OK = 200 primary_ip = Conf.get(GLOBAL_CONF, CNTRLR_PRIMARY_IP_KEY) secondary_ip = Conf.get(GLOBAL_CONF, CNTRLR_SECONDARY_IP_KEY) primary_port = Conf.get(GLOBAL_CONF, CNTRLR_PRIMARY_PORT_KEY) secondary_port = Conf.get(GLOBAL_CONF, CNTRLR_SECONDARY_PORT_KEY) cntrlr_user = Conf.get(GLOBAL_CONF, CNTRLR_USER_KEY) cntrlr_secret = Conf.get(GLOBAL_CONF, CNTRLR_SECRET_KEY) cntrlr_key = gen_key(ENCLOSURE, "storage_enclosure") cntrlr_passwd = decrypt(cntrlr_key, cntrlr_secret) def show_system(ip, port, sessionKey): url = f"http://{ip}:{port}/api/show/system" # request headers for next request request_headers = {'datatype': 'json', 'sessionKey': sessionKey} # make the request response = requests.get(url, headers=request_headers, timeout=timeout) print(response) try: # process the response if response and response.status_code == HTTP_OK: jresponse = json.loads(response.content) if jresponse['status'][0]['return-code'] == 0: