def _key_value_verify(self, key: str, phase: str): """Verify if there exists a corresponding value for given key.""" value = Conf.get(self.index, key) if not value: Log.debug("Validation failed for %s in %s phase" % (key ,phase)) raise Exception("Validation failed for %s in %s phase" % (key ,phase)) else: if ((Conf.get(self.prov, 'CONFIG>OPENLDAP_BASE_DN') == key) and (not bool(re.match("^dc=[a-zA-Z0-9]+(,dc=[a-zA-Z0-9]+)+[a-zA-Z0-9]$", value)))): Log.debug("Validation failed for %s in %s phase" % (key ,phase)) raise Exception("Validation failed for %s in %s phase" % (key ,phase)) elif (key.endswith("hostname")): try: NetworkV().validate('connectivity',[value]) except Exception: Log.debug("Validation failed for %s in %s phase" % (key, phase)) raise Exception("Validation failed for %s in %s phase" % (key, phase)) elif (key.endswith("server_nodes")): if isinstance(value, str): value = literal_eval(value) for node_machine_id in value: host_name = Conf.get(self.index, f'server_node>{node_machine_id}>hostname') try: NetworkV().validate('connectivity',[host_name]) except Exception: Log.debug("Validation failed for %s in %s phase" % (key, phase)) raise Exception("Validation failed for %s in %s phase" % (key, phase))
def validate(self): """Check for required packages are installed.""" # RPM dependency rpm_deps = {"cortx-sspl-test": None} # python 3rd party package dependency pip3_3ps_packages_test = {"Flask": "1.1.1"} pkg_validator = PkgV() pkg_validator.validate_pip3_pkgs(host=socket.getfqdn(), pkgs=pip3_3ps_packages_test, skip_version_check=False) pkg_validator.validate_rpm_pkgs(host=socket.getfqdn(), pkgs=rpm_deps, skip_version_check=True) # Load global, sspl and test configs Conf.load(SSPL_CONFIG_INDEX, sspl_config_path) Conf.load(SSPL_TEST_CONFIG_INDEX, sspl_test_config_path) # Take copy of supplied config passed to sspl_test and load it with open(self.sspl_test_gc_copy_file, "w") as f: f.write("") self.sspl_test_gc_copy_url = "yaml://%s" % self.sspl_test_gc_copy_file Conf.load(SSPL_TEST_GLOBAL_CONFIG, self.sspl_test_gc_copy_url) Conf.load("global_config", self.sspl_test_gc_url) Conf.copy("global_config", SSPL_TEST_GLOBAL_CONFIG) # Validate input configs machine_id = Utility.get_machine_id() self.node_type = Conf.get(SSPL_TEST_GLOBAL_CONFIG, "server_node>%s>type" % machine_id) enclosure_id = Conf.get( SSPL_TEST_GLOBAL_CONFIG, "server_node>%s>storage>enclosure_id" % machine_id) self.enclosure_type = Conf.get( SSPL_TEST_GLOBAL_CONFIG, "storage_enclosure>%s>type" % enclosure_id)
def test_conf_store_get_with_wrong_key(self): """Test by getting the invalid wrong key.""" load_config('set_local_7', 'json:///tmp/file1.json') try: Conf.get('set_local_7', 'bridge>lte_type[2]>..>location') except Exception as err: self.assertEqual('Invalid key name ', err.desc)
def reset(config_path: str): """Remove/Delete all the data/logs that was created by user/testing.""" from cortx.utils.message_bus.error import MessageBusError try: # use gconf to deregister IEM from cortx.utils.message_bus import MessageBusAdmin, MessageBus from cortx.utils.message_bus import MessageProducer Conf.load(GCONF_INDEX, config_path, skip_reload=True) message_bus_backend = Conf.get('config', MSG_BUS_BACKEND_KEY) message_server_endpoints = Conf.get('config',\ f'{EXTERNAL_KEY}>{message_bus_backend}>endpoints') MessageBus.init(message_server_endpoints) mb = MessageBusAdmin(admin_id='reset') message_types_list = mb.list_message_types() if message_types_list: for message_type in message_types_list: producer = MessageProducer(producer_id=message_type,\ message_type=message_type, method='sync') producer.delete() except MessageBusError as e: raise SetupError(e.rc, "Can not reset Message Bus. %s", e) except Exception as e: raise SetupError( errors.ERR_OP_FAILED, "Internal error, can not \ reset Message Bus. %s", e) return 0
def _get_kafka_server_list(conf_url): """ Reads the ConfStore and derives keys related to message bus """ from cortx.utils.conf_store import Conf Conf.load("cluster_config", conf_url) keylist = ["cortx>software>common>message_bus_type", "cortx>software>kafka>servers"] ConfKeysV().validate("exists", "cluster_config", keylist) msg_bus_type = Conf.get("cluster_config", \ "cortx>software>common>message_bus_type") if msg_bus_type != "kafka": raise SetupError(errno.EINVAL, \ "Message Bus do not support type %s" % msg_bus_type) # Read the required keys all_servers = Conf.get("cluster_config", \ "cortx>software>kafka>servers") no_servers = len(all_servers) kafka_server_list = [] port_list = [] for i in range(no_servers): # check if port is mentioned rc = all_servers[i].find(':') if rc == -1: port_list.append("9092") kafka_server_list.append(all_servers[i]) else: port_list.append(all_servers[i][rc + 1:]) kafka_server_list.append(all_servers[i][:rc]) if len(kafka_server_list) == 0: raise SetupError(errno.EINVAL, \ "No valid Kafka server info provided for Config Key \ 'cortx>software>kafka>servers' ") return kafka_server_list, port_list
def get_nodelist(self, fetch_from: str = None) -> list: """ Get nodelist from provisioner or confstore Args: fetch_from (str): Options from where to fetch. Returns: list: List of nodes. """ nodelist: list = [] fetch_from = Cmd.HA_CONFSTORE if fetch_from is None else fetch_from if fetch_from == Cmd.HA_CONFSTORE: cluster_nodes = self._confstore.get( const.CLUSTER_CONFSTORE_NODES_KEY) if cluster_nodes is None: return nodelist for key in cluster_nodes: nodelist.append(key.split('/')[-1]) elif fetch_from == Cmd.PROV_CONFSTORE: nodes_schema = Conf.get(self._index, "server_node") machine_ids: list = list(nodes_schema.keys()) for machine in machine_ids: nodelist.append( Conf.get( self._index, f"server_node.{machine}.network.data.private_fqdn")) else: raise SetupError( f"Failed to get nodelist, Invalid options {fetch_from}") Log.info( f"Found total Nodes: {len(nodelist)}, Nodes: {nodelist}, in {fetch_from}" ) return nodelist
def main(argv: list): try: if sys.argv[1] == "post_install": Conf.init(delim='.') Conf.load(const.HA_GLOBAL_INDEX, f"yaml://{const.SOURCE_CONFIG_FILE}") log_path = Conf.get(const.HA_GLOBAL_INDEX, "LOG.path") log_level = Conf.get(const.HA_GLOBAL_INDEX, "LOG.level") Log.init(service_name='ha_setup', log_path=log_path, level=log_level) else: ConfigManager.init("ha_setup") desc = "HA Setup command" command = Cmd.get_command(desc, argv[1:]) command.process() sys.stdout.write( f"Mini Provisioning {sys.argv[1]} configured successfully.\n") except Exception as err: Log.error("%s\n" % traceback.format_exc()) sys.stderr.write( f"Setup command:{argv[1]} failed for cortx-ha. Error: {err}\n") return errno.EINVAL
def validate(self): if not self.args: raise SetupError( errno.EINVAL, "%s - Argument validation failure. Global config is needed", self.name) if (len(self.args) != 2) or (self.args[0] != "--config"): raise SetupError(errno.EINVAL, "%s - Argument validation failure. Check Usage.", self.name) global_config = self.args[1] Conf.load('global_config', global_config) role = Conf.get('global_config', 'release>setup') if not role: raise SetupError(errno.EINVAL, "%s - validation failure. %s", self.name, "Role not found in %s" % (global_config)) from cortx.sspl.bin.sspl_constants import setups if role not in setups: raise SetupError(errno.EINVAL, "%s - validataion failure. %s", self.name, "Role %s is not supported. Check Usage" % role) product = Conf.get('global_config', 'release>product') if not product: raise SetupError(errno.EINVAL, "%s - validation failure. %s", self.name, "Product not found in %s" % (global_config))
def _get_kafka_server_list(conf_url: str): """ Reads the ConfStore and derives keys related to message bus """ Conf.load('cluster_config', conf_url) key_list = ['cortx>software>common>message_bus_type', \ 'cortx>software>kafka>servers'] ConfKeysV().validate('exists', 'cluster_config', key_list) msg_bus_type = Conf.get('cluster_config', key_list[0]) if msg_bus_type != 'kafka': raise SetupError(errno.EINVAL, "Message Bus do not support type \ %s", msg_bus_type) # Read the required keys all_servers = Conf.get('cluster_config', key_list[1]) no_servers = len(all_servers) kafka_server_list = [] port_list = [] for i in range(no_servers): # check if port is mentioned rc = all_servers[i].find(':') if rc == -1: port_list.append('9092') kafka_server_list.append(all_servers[i]) else: port_list.append(all_servers[i][rc + 1:]) kafka_server_list.append(all_servers[i][:rc]) if len(kafka_server_list) == 0: raise SetupError(errno.EINVAL, "No valid Kafka server info \ provided for config key: %s", key_list[1]) return kafka_server_list, port_list
def configure_lnet(self): ''' Get iface and /etc/modprobe.d/lnet.conf params from conf store. Configure lnet. Start lnet service ''' try: iface = Conf.get(self._index, f'cluster>{self._server_id}')['network']['data']['private_interfaces'] iface = iface[0] except: raise MotrError(errno.EINVAL, "private_interfaces[0] not found\n") sys.stdout.write(f"Validate private_interfaces[0]: {iface}\n") cmd = f"ip addr show {iface}" execute_command(self, cmd) try: iface_type = Conf.get(self._index, f'cluster>{self._server_id}')['network']['data']['interface_type'] except: raise MotrError(errno.EINVAL, "interface_type not found\n") lnet_config = (f"options lnet networks={iface_type}({iface}) " f"config_on_load=1 lnet_peer_discovery_disabled=1\n") sys.stdout.write(f"lnet config: {lnet_config}") with open(LNET_CONF_FILE, "w") as fp: fp.write(lnet_config) restart_services(self, ["lnet"])
def _register_for_resp(self): """ Register to wait for a response to the sent request. """ # Unique consumer_group for each actuator response self.consumer_group = self._uuid self.consumer_id = Conf.get(const.HA_GLOBAL_INDEX, f"ACTUATOR_MANAGER{_DELIM}consumer_id") self.resp_message_type = Conf.get( const.HA_GLOBAL_INDEX, f"ACTUATOR_MANAGER{_DELIM}resp_message_type") self.consumer = MessageBus.get_consumer( consumer_id=str(self.consumer_id), consumer_group=self.consumer_group, message_type=self.resp_message_type, callback=self.process_resp, offset="latest", timeout=ACTUATOR_MSG_WAIT_TIME) # Start the thread to listen to response self.consumer.start() Log.debug( f"Waiting to get response on message_type {self.resp_message_type}" )
def get_config_entries(self): """Returns config that needs to add in elasticsearch.yml file.""" # Read required config from provisioner config. srvnodes = [] server_nodes_id = [] machine_id = Conf.machine_id node_name = Conf.get(self.index, f'server_node>{machine_id}>name') # Total nodes in cluster. cluster_id = Conf.get(self.index, f'server_node>{machine_id}>cluster_id') if cluster_id is None: raise ElasticsearchSetupError(errno.EINVAL, "cluster_id is none.") storage_set = Conf.get(self.index, f'cluster>{cluster_id}>storage_set') if storage_set: server_nodes_id = storage_set[0]["server_nodes"] if server_nodes_id: for machine_id in server_nodes_id: srvnodes.append( Conf.get(self.index, f'server_node>{machine_id}>name')) # Config entries needs to add in elasticsearch.yml file. config_entries = [ f"cluster.name: {self.elasticsearch_cluster_name}", f"node.name: {node_name}", f"network.bind_host: {['localhost', node_name]}", f"network.publish_host: {[node_name]}", f"discovery.seed_hosts: {srvnodes}", f"cluster.initial_master_nodes: {srvnodes}", f"http.port: {self.http_port}" ] return config_entries
def read_ldap_credentials(self): """Read ldap credentials (rootdn, sgiam) from the openldap_config file.""" try: # Load the openldap config file index_id = 'openldap_config_file_read_index' Conf.load(index_id, f'yaml://{self.openldap_config_file}') # Read the cluster id from openldap_config file self.cluster_id = Conf.get(index_id, f'{self.cluster_id_key}') cipher_key = Cipher.generate_key( self.cluster_id, self.get_confkey('CONFSTORE_OPENLDAP_CONST_KEY')) # rootdn username/password self.ldap_root_user = Conf.get(index_id, f'{self.rootdn_user_key}') encrypted_rootdn_pass = Conf.get(index_id, f'{self.rootdn_pass_key}') if encrypted_rootdn_pass != None: self.rootdn_passwd = Cipher.decrypt( cipher_key, bytes(str(encrypted_rootdn_pass), 'utf-8')) except Exception as e: Log.error(f'read ldap credentials failed, error: {e}') raise e
def __init__(self): """ Initialize a MessageBus and load its configurations """ Conf.load('config_file', 'json:///etc/cortx/cortx.conf', skip_reload=True) # if Log.logger is already initialized by some parent process # the same file will be used to log all the messagebus related # logs, else standard message_bus.log will be used. if not Log.logger: log_level = Conf.get('config_file', 'utils>log_level', 'INFO') Log.init('message_bus', '/var/log/cortx/utils/message_bus', \ level=log_level, backup_count=5, file_size_in_mb=5) try: Conf.load('message_bus', self.conf_file, skip_reload=True) self._broker_conf = Conf.get('message_bus', 'message_broker') broker_type = self._broker_conf['type'] Log.info(f"MessageBus initialized as {broker_type}") except ConfError as e: Log.error(f"MessageBusError: {e.rc} Error while parsing" \ f" configuration file {self.conf_file}. {e}.") raise MessageBusError(e.rc, "Error while parsing " + \ "configuration file %s. %s.", self.conf_file, e) except Exception as e: Log.error(f"MessageBusError: {e.rc} Error while parsing" \ f" configuration file {self.conf_file}. {e}.") raise MessageBusError(errno.ENOENT, "Error while parsing " + \ "configuration file %s. %s.", self.conf_file, e) self._broker = MessageBrokerFactory.get_instance(broker_type, \ self._broker_conf)
def main(): from cortx.utils.conf_store import Conf argv = sys.argv # Get the log path tmpl_file = argv[3] Conf.load(GCONF_INDEX, tmpl_file) log_dir = Conf.get(GCONF_INDEX, CLUSTER_CONF_LOG_KEY) utils_log_path = os.path.join(log_dir, f'utils/{Conf.machine_id}') # Get the log level log_level = Conf.get(GCONF_INDEX, 'utils>log_level', 'INFO') Log.init('utils_setup', utils_log_path, level=log_level, backup_count=5, \ file_size_in_mb=5) try: desc = "CORTX Utils Setup command" Log.info(f"Starting utils_setup {argv[1]} ") command = Cmd.get_command(desc, argv[1:]) rc = command.process() except SetupError as e: sys.stderr.write("error: %s\n\n" % str(e)) sys.stderr.write("%s\n" % traceback.format_exc()) Cmd.usage(argv[0]) rc = e.rc except Exception as e: sys.stderr.write("error: %s\n\n" % str(e)) sys.stderr.write("%s\n" % traceback.format_exc()) rc = errno.EINVAL Log.info(f"Command {command} {argv[1]} finished with exit " \ f"code {rc}")
def validate(self, phase: str): """Perform validations for phase.""" try: Conf.load(phase, f'json://{self._preqs_conf_file}') prereqs_block = Conf.get(phase, f'{phase}') if prereqs_block: pip3s = Conf.get(phase, f'{phase}>pip3s') if pip3s: PkgV().validate('pip3s', pip3s) rpms = Conf.get(phase, f'{phase}>rpms') if rpms: PkgV().validate('rpms', rpms) services = Conf.get(phase, f'{phase}>services') if services: for service in services: pid = os.popen('pidof ' + service).read() if pid is None: Log.debug( 'Validation failed for service %s in %s phase' % (service, phase)) raise Exception( 'Validation failed for service %s in %s phase' % (service, phase)) files = Conf.get(phase, f'{phase}>files') if files: PathV().validate('exists', files) Log.debug("%s - pre-requisite validation complete" % phase) except Exception: Log.debug("%s - pre-requisite validation failed" % phase) raise Exception("prereqs validation failed") return 0
def cleanup(pre_factory: bool, config_path: str): """Remove/Delete all the data that was created after post install.""" # delete message_types from cortx.utils.message_bus.error import MessageBusError try: # use gconf to clean and delete all message type in messagebus from cortx.utils.message_bus import MessageBus, MessageBusAdmin Conf.load(GCONF_INDEX, config_path, skip_reload=True) message_bus_backend = Conf.get(GCONF_INDEX, MSG_BUS_BACKEND_KEY) message_server_endpoints = Conf.get(GCONF_INDEX,\ f'{EXTERNAL_KEY}>{message_bus_backend}>endpoints') MessageBus.init(message_server_endpoints) mb = MessageBusAdmin(admin_id='cleanup') message_types_list = mb.list_message_types() if message_types_list: mb.deregister_message_type(message_types_list) except MessageBusError as e: raise SetupError(e.rc, "Can not cleanup Message Bus. %s", e) except Exception as e: raise SetupError( errors.ERR_OP_FAILED, "Can not cleanup Message \ Bus. %s", e) return 0
def process(*args): """Process input parameters""" if len(args) < 2: raise CortxProvisionerError( errno.EINVAL, 'Please provide solution_config and conf_store ' 'url as input parameters.') elif len(args) >= 2: solution_conf_url = args[0] cortx_conf_url = args[1] ConfigValidator.load_config(solution_conf_url, cortx_conf_url) if Conf.get(ConfigValidator._solution_index, 'cluster') is not None: ConfigValidator()._check_storage_sets() ConfigValidator()._check_number_of_nodes() ConfigValidator()._validate_components() if Conf.get(ConfigValidator._solution_index, 'cortx') is not None: ConfigValidator()._check_external_services() # if cluster/cortx both keys are not present in file means file is # empty or file doesn't have required config. if (Conf.get(ConfigValidator._solution_index, 'cluster') is None and Conf.get(ConfigValidator._solution_index, 'cortx') is None): raise CortxProvisionerError( errno.EINVAL, 'File is empty OR Cluster config and cortx config is not present in file.' )
def upgrade(config_path: str, change_set_path: str): """Perform upgrade steps.""" Conf.load(DELTA_INDEX, change_set_path) Conf.load(GCONF_INDEX, config_path, skip_reload=True) delta_keys = Conf.get_keys(DELTA_INDEX) # if message_bus_backend changed, add new and delete old msg bus entries if CHANGED_PREFIX + MSG_BUS_BACKEND_KEY in delta_keys: new_msg_bus_backend = Conf.get( DELTA_INDEX, CHANGED_PREFIX + MSG_BUS_BACKEND_KEY).split('|')[1] Conf.set(GCONF_INDEX, MSG_BUS_BACKEND_KEY, new_msg_bus_backend) for key in delta_keys: if NEW_PREFIX + EXTERNAL_KEY + new_msg_bus_backend in key: new_key = key.split(NEW_PREFIX)[1] new_val = Conf.get(DELTA_INDEX, key).split('|')[1] Conf.set(GCONF_INDEX, new_key, new_val) if DELETED_PREFIX + EXTERNAL_KEY + new_msg_bus_backend in key: delete_key = key.split(DELETED_PREFIX)[1] Conf.delete(GCONF_INDEX, delete_key) # update existing messagebus parameters else: msg_bus_backend = Conf.get(GCONF_INDEX, MSG_BUS_BACKEND_KEY) for key in delta_keys: if CHANGED_PREFIX + EXTERNAL_KEY + msg_bus_backend in key: new_val = Conf.get(DELTA_INDEX, key).split('|')[1] change_key = key.split(CHANGED_PREFIX)[1] Conf.set(GCONF_INDEX, change_key, new_val) Conf.save(GCONF_INDEX) Utils.init(config_path) return 0
def _get_cluster_data(config_path): Conf.load('cluster_conf', config_path) message_bus_backend = Conf.get('cluster_conf',\ 'cortx>utils>message_bus_backend') message_server_endpoints = Conf.get('cluster_conf',\ f'cortx>external>{message_bus_backend}>endpoints') cluster_id = Conf.get('cluster_conf', 'cluster>id') return message_server_endpoints, cluster_id
def test_conf_store_get_null_index(self): """Test by getting the null index key.""" load_config('set_local_5', 'json:///tmp/file1.json') try: Conf.get('set_local_5', 'bridge>lte_type[]') except Exception as err: self.assertEqual('Invalid key index for the key lte_type', err.desc)
def update_sensor_info(config_index): key = 'monitor' sensors = dict() sensors["REALSTORSENSORS"] = "true" sensors["NODEHWSENSOR"] = "true" sensors["DISKMONITOR"] = "true" sensors["SERVICEMONITOR"] = "true" sensors["RAIDSENSOR"] = "true" sensors["SASPORTSENSOR"] = "true" sensors["MEMFAULTSENSOR"] = "true" sensors["CPUFAULTSENSOR"] = "true" try: with open("/etc/machine-id") as f: machine_id = f.read().strip("\n") except Exception as err: raise SetupError(1, "Failed to get machine-id. - %s" % (err)) srvnode = Conf.get(GLOBAL_CONFIG_INDEX, "cluster>server_nodes>%s" % (machine_id)) enclosure_id = Conf.get(GLOBAL_CONFIG_INDEX, "cluster>%s>storage>enclosure_id" % (srvnode)) node_key_id = Conf.get(GLOBAL_CONFIG_INDEX, 'cluster>server_nodes>%s' % (machine_id)) storage_type = Conf.get(GLOBAL_CONFIG_INDEX, 'storage>%s>type' % enclosure_id) if storage_type and storage_type.lower() in ["virtual", "jbod"]: sensors["REALSTORSENSORS"] = "false" server_type = Conf.get(GLOBAL_CONFIG_INDEX, 'cluster>%s>node_type' % (node_key_id)) if server_type and server_type.lower() in ["virtual"]: sensors["NODEHWSENSOR"] = "false" sensors["SASPORTSENSOR"] = "false" sensors["MEMFAULTSENSOR"] = "false" sensors["CPUFAULTSENSOR"] = "false" sensors["RAIDSENSOR"] = "false" # Onward LDR_R2, consul will be abstracted out and it won't exit as hard dependeny of SSPL # Note: SSPL has backward compatibility to LDR_R1 and there consul is a dependency of SSPL. if SSPL_STORE_TYPE == "consul": host = os.getenv('CONSUL_HOST', CONSUL_HOST) port = os.getenv('CONSUL_PORT', CONSUL_PORT) try: consul_conn = consul.Consul(host=host, port=port) for sect, value in sensors.items(): consul_conn.kv.put("sspl/config/%s/monitor" % sect, value) except Exception as cerror: print("Error in connecting with consul: {}".format(cerror)) # Update sensor information in config for sect, value in sensors.items(): Conf.set(config_index, '%s>%s' % (sect, key), value) Conf.save(config_index)
def __init__(self): """ Init method. """ super(ClusterResourceParser, self).__init__() self.cluster_id = Conf.get(const.HA_GLOBAL_INDEX, f"COMMON_CONFIG{_DELIM}cluster_id") self.site_id = Conf.get(const.HA_GLOBAL_INDEX, f"COMMON_CONFIG{_DELIM}site_id") self.rack_id = Conf.get(const.HA_GLOBAL_INDEX, f"COMMON_CONFIG{_DELIM}rack_id") Log.info("ClusterResource Parser is initialized ...")
def get_changed_keys(self): """Get flattened dict of {old_key:key_key}.""" changed_keys = {} if Conf.get(NEW_CONF, CHANGED): for changed_key in Conf.get(NEW_CONF, CHANGED): changed_key_payload = KvPayload(changed_key) key = changed_key_payload.get_keys()[0] changed_keys[key] = changed_key_payload.get(key) return changed_keys
def _validate_provisioning_status(_conf_idx: str, node_id: str, apply_phase: str): """Validate provisioning.""" ret_code = 0 recent_phase = Conf.get(_conf_idx, f'node>{node_id}>provisioning>phase') recent_status = Conf.get(_conf_idx, f'node>{node_id}>provisioning>status') msg = f'Recent phase for this node is {recent_phase} and ' + \ f'recent status is {recent_status}. ' # {apply_phase: {recent_phase: {recent_status: [boolean_result,rc]}}} validations_checks = { ProvisionerStages.DEPLOYMENT.value: { ProvisionerStages.DEPLOYMENT.value: { ProvisionerStatus.DEFAULT.value: [True, 0], ProvisionerStatus.ERROR.value: [True, 0], ProvisionerStatus.PROGRESS.value: [True, 0], ProvisionerStatus.SUCCESS.value: [False, 0] }, ProvisionerStages.UPGRADE.value: { ProvisionerStatus.DEFAULT.value: [True, 0], ProvisionerStatus.ERROR.value: [True, 0], ProvisionerStatus.PROGRESS.value: [True, 0], ProvisionerStatus.SUCCESS.value: [True, 0] }}, ProvisionerStages.UPGRADE.value: { ProvisionerStages.DEPLOYMENT.value: { ProvisionerStatus.DEFAULT.value: [False, 1], ProvisionerStatus.ERROR.value: [False, 1], ProvisionerStatus.PROGRESS.value: [False, 1], ProvisionerStatus.SUCCESS.value: [True, 0] }, ProvisionerStages.UPGRADE.value: { ProvisionerStatus.DEFAULT.value: [True, 0], ProvisionerStatus.ERROR.value: [True, 0], ProvisionerStatus.PROGRESS.value: [True, 0], ProvisionerStatus.SUCCESS.value: [True, 0] } }} if recent_phase is None and recent_status is None: Log.info(msg + f'Performing {apply_phase} on this node.') return True, ret_code if (not validations_checks.get(apply_phase) or not validations_checks.get(apply_phase).get(recent_phase) or not validations_checks.get(apply_phase).get(recent_phase).get(recent_status)): Log.error('Invalid phase or status.') ret_code = 1 return False, ret_code validate_result = validations_checks.get(apply_phase).get(recent_phase).get(recent_status) if validate_result[1] != 0: Log.error(msg + f'{apply_phase} is not possible on this node.') if apply_phase == ProvisionerStages.UPGRADE.value: # Reset status. recent_status = Conf.set(_conf_idx, f'node>{node_id}>provisioning>status', ProvisionerStatus.DEFAULT.value) else: Log.info(msg) return validate_result[0], validate_result[1]
def __init__(self): """Init method for sspl setup config.""" self._script_dir = os.path.dirname(os.path.abspath(__file__)) # Load sspl and global configs Conf.load(consts.SSPL_CONFIG_INDEX, consts.sspl_config_path) global_config_url = Conf.get( consts.SSPL_CONFIG_INDEX, "SYSTEM_INFORMATION>global_config_copy_url") Conf.load(consts.GLOBAL_CONFIG_INDEX, global_config_url) self.product = Conf.get(consts.GLOBAL_CONFIG_INDEX, 'release>product')
def update_sensor_info(): key = 'monitor' sensors = dict() sensors["REALSTORSENSORS"] = "true" sensors["NODEHWSENSOR"] = "true" sensors["SYSTEMDWATCHDOG"] = "true" sensors["RAIDSENSOR"] = "true" sensors["SASPORTSENSOR"] = "true" sensors["MEMFAULTSENSOR"] = "true" sensors["CPUFAULTSENSOR"] = "true" try: with open("/etc/machine-id") as f: node_key_id = f.read().strip("\n") except Exception as err: print("Failed to get machine-id. - %s" % (err)) storage_type = Conf.get('global_config', 'storage>enclosure_1>type') if storage_type and storage_type.lower() in ["virtual", "jbod"]: sensors["REALSTORSENSORS"] = "false" server_type = Conf.get('global_config', 'cluster>%s>node_type' % (node_key_id)) if server_type and server_type.lower() in ["virtual"]: sensors["NODEHWSENSOR"] = "false" sensors["SASPORTSENSOR"] = "false" sensors["MEMFAULTSENSOR"] = "false" sensors["CPUFAULTSENSOR"] = "false" sensors["RAIDSENSOR"] = "false" for sect, value in sensors.items(): Conf.set('sspl', '%s>%s' % (sect, key), value) Conf.save('sspl') # Onward LDR_R2, consul will be abstracted out and it won't exit as hard dependeny of SSPL # Note: SSPL has backward compatibility to LDR_R1 and there consul is a dependency of SSPL. if SSPL_STORE_TYPE == "consul": host = os.getenv('CONSUL_HOST', CONSUL_HOST) port = os.getenv('CONSUL_PORT', CONSUL_PORT) try: consul_conn = consul.Consul(host=host, port=port) for sect, value in sensors.items(): consul_conn.kv.put("sspl/config/%s/monitor" % sect, value) except Exception as cerror: print("Error in connecting with consul: {}".format(cerror)) # Update sensor information for sspl_test test_file_config_path = "/opt/seagate/%s/sspl/sspl_test/conf/sspl_tests.conf" % PRODUCT_FAMILY Conf.load('sspl_test', 'yaml://%s' % test_file_config_path) for sect, value in sensors.items(): Conf.set('sspl_test', '%s>%s' % (sect, key), value) Conf.save('sspl_test')
def __init__(self): """initial variables and ConfStor setup.""" self.role = None self.dp = True # Load sspl and global configs Conf.load(SSPL_CONFIG_INDEX, sspl_config_path) global_config_url = Conf.get( SSPL_CONFIG_INDEX, "SYSTEM_INFORMATION>global_config_copy_url") Conf.load(GLOBAL_CONFIG_INDEX, global_config_url) self.role = Conf.get(GLOBAL_CONFIG_INDEX, 'release>setup')
def test_json_message_kv_store(self): """Tests jsonmessage basic operation.""" index = 'json_message_kv_store_index' Conf.load(index, 'jsonmessage:{"key1":"val1"}') self.assertEqual(Conf.get(index, 'key1'), 'val1') Conf.set(index, 'key2', 'val2') self.assertEqual(Conf.get_keys(index), ['key1', 'key2']) Conf.set(index, 'key2>key3>key4', 'val4') Conf.delete(index, 'key2>key3>key4') self.assertEqual(Conf.get(index, 'key2>key3>key4'), None)
def setUpClass(cls, cluster_conf_path: str = 'yaml:///etc/cortx/cluster.conf'): if TestMessage._cluster_conf_path: cls.cluster_conf_path = TestMessage._cluster_conf_path else: cls.cluster_conf_path = cluster_conf_path Conf.load('config', cls.cluster_conf_path, skip_reload=True) TestMessage._cluster_id = Conf.get('config', 'cluster>id') TestMessage._message_server_endpoints = Conf.get('config',\ 'cortx>external>kafka>endpoints')