def do_drop(self, params=None): db_url = cfg.read_param("database_url", "Please provide us the URL of the database") if db_url is None: print() logger.error("no URL specified: aborting!") return -1 if params and len(params) > 0: db_name = params[0] else: db_name = cfg.read_param("database_name", "Please provide the database to drop", DEFAULT_DB_NAME) db = self.getdb(db_url, db_name) if db is None: return -1 # check to see if the database has already been created if db.exists(): if cfg.read_param("database_force_drop", "Do you really want to drop the '{}' database". format(db_name), False, True): db.drop() else: logger.info("database '{}' not dropped!".format(db_name)) else: logger.warning("database '{}' does not exist!".format(db_name))
def __print_hep(self, packet): # this works as a HEP parser logger.debug("initial packet size is {}".format(len(packet))) while len(packet) > 0: if len(packet) < 4: return packet # currently only HEPv3 is accepted if packet[0:4] != b'HEP3': logger.warning("packet not HEPv3: [{}]".format(packet[0:4])) return None length = int.from_bytes(packet[4:6], byteorder="big", signed=False) if length > len(packet): logger.debug("partial packet: {} out of {}".format( len(packet), length)) # wait for entire packet to parse it return packet logger.debug("packet size is {}".format(length)) # skip the header hep_packet = HEPpacket(packet[6:length]) try: hep_packet.parse() except HEPpacketException: return None packet = packet[length:] print(hep_packet) return packet
def do_delete(self, params=None): if len(params) < 1: name = cfg.read_param( None, "Please provide the username you want to delete") if not name: logger.warning("no username to delete!") return -1 else: name = params[0] username, domain = self.user_get_domain(name) db = self.user_db_connect() if not db: return -1 delete_dict = {USER_NAME_COL: username, USER_DOMAIN_COL: domain} # check if the user already exists if not db.entry_exists(USER_TABLE, delete_dict): logger.error("User {}@{} does not exist".format(username, domain)) return -1 db.delete(USER_TABLE, delete_dict) logger.info("Successfully deleted {}@{}".format(username, domain)) db.destroy() return True
def do_alter_role(self, params=None): """ alter role attributes (connect to given template database) """ db_url = cfg.read_param( "template_url", "Please provide the URL to connect as template") if db_url is None: logger.error("no URL specified: aborting!") return -1 db_template = cfg.read_param( "database_template", "Please provide the database template name", DEFAULT_DB_TEMPLATE) if db_template is None: logger.error("no URL specified: aborting!") return -1 # create an object store database instance db = self.get_db(db_url, db_template) if db is None: return -1 role_name = None role_options = None role_password = None if len(params) > 0: role_name = ''.join(params[0]) if role_name is None: role_name = cfg.read_param( "role_name", "Please provide the role name to alter", DEFAULT_ROLE_NAME) logger.debug("role_name: '%s'", role_name) if db.exists_role(role_name) is True: if len(params) > 1: role_options = params[1] if len(params) > 2: role_password = params[2] if role_options is None: role_list = cfg.read_param( "role_options", "Please adapt the role options to alter", DEFAULT_ROLE_OPTIONS) if len(role_list) > 0: role_options = ' '.join(role_list) logger.debug("role_options: '%s'", role_options) if role_password is None: role_password = getpass("New password: "******"role_password: '******'", role_password) if db.alter_role(role_name, role_options, role_password) is False: logger.error("alter role '%s' didn't succeed", role_name) db.destroy() else: logger.warning("can't alter non existing role '%s'", role_name)
def user_get_password(self): while True: pw1 = getpass.getpass("Please enter new password: "******"Please repeat the password: "******"passwords are not the same! Please retry...") else: return pw1
def push_chunk(self, vendor_id, type_id, payload): if vendor_id != 0: logger.warning("Unknown vendor id {}".format(vendor_id)) raise HEPpacketException if type_id == 0x0001: if len(payload) != 1: raise HEPpacketException self.family = payload[0] elif type_id == 0x0002: if len(payload) != 1: raise HEPpacketException if not payload[0] in protocol_ids: self.protocol = str(payload[0]) else: self.protocol = protocol_ids[payload[0]] elif type_id >= 0x0003 and type_id <= 0x0006: expected_payload_len = 4 if type_id <= 0x0004 else 16 if len(payload) != expected_payload_len: raise HEPpacketException if type_id == 0x0003 or type_id == 0x0005: self.src_addr = payload else: self.dst_addr = payload elif type_id == 0x0007 or type_id == 0x0008: if len(payload) != 2: raise HEPpacketException port = int.from_bytes(payload, byteorder="big", signed=False) if type_id == 7: self.src_port = port else: self.dst_port = port elif type_id == 0x0009 or type_id == 0x000a: if len(payload) != 4: raise HEPpacketException timespec = int.from_bytes(payload, byteorder="big", signed=False) if type_id == 0x0009: self.ts = timespec else: self.tms = timespec elif type_id == 0x000b: if len(payload) != 1: raise HEPpacketException if not payload[0] in protocol_types: self.type = str(payload[0]) else: self.type = protocol_types[payload[0]] elif type_id == 0x000c: pass # capture id not used now elif type_id == 0x000f: self.data = payload elif type_id == 0x0011: self.correlation = payload else: logger.warning("unhandled payload type {}".format(type_id))
def do_add(self, params): """ add a given table to the database (connection via URL) """ if len(params) < 1: logger.error("No module to add added") return -1 module = params[0] db_url = cfg.read_param("database_url", "Please provide us the URL of the database") if db_url is None: print() logger.error("no URL specified: aborting!") return -1 if len(params) < 2: db_name = cfg.read_param( "database_name", "Please provide the database to add the module to", DEFAULT_DB_NAME) else: db_name = params[1] # create an object store database instance db = self.get_db(db_url, db_name) if db is None: return -1 if not db.exists(): logger.warning("database '{}' does not exist!".format(db_name)) return -1 db_schema = db.dialect schema_path = self.get_schema_path(db_schema) if schema_path is None: return -1 module_file_path = os.path.join(schema_path, "{}-create.sql".format(module)) if not os.path.isfile(module_file_path): logger.warning( "cannot find OpenSIPS DB file: '{}'!".format(module_file_path)) return -1 db.connect(db_name) try: db.create_module(module_file_path) except osdbError as ex: logger.error("cannot import: {}".format(ex)) return -1 db.destroy() logger.info("Module {} has been successfully added!".format(module)) return True
def do_drop(self, params=None): """ drop a given database object (connection via URL) """ db_url = self.ask_db_url() if db_url is None: return -1 if params and len(params) > 0: db_name = params[0] else: db_name = cfg.read_param("database_name", "Please provide the database to drop", DEFAULT_DB_NAME) # create an object store database instance db = self.get_db(db_url, db_name) if db is None: return -1 if db.dialect == "postgres": if params and len(params) > 1: role_name = params[1] else: role_name = cfg.read_param( "role_name", "Please provide the associated role name " + "to access the database", DEFAULT_ROLE_NAME) # check to see if the database has already been created if db.exists(): if cfg.read_param( "database_force_drop", "Do you really want to drop the '{}' database".format( db_name), False, True): if db.drop(): logger.info("database '%s' dropped!", db_name) else: logger.info("database '%s' not dropped!", db_name) if db.dialect == "postgres": if db.exists_role(role_name) is True: if cfg.read_param( "role_force_drop", "Do you really want to drop the '{}' role". format(role_name), False, True): # call function with parameter list params = [role_name] self.do_drop_role(params) else: logger.info("database '{}' not dropped!".format(db_name)) else: logger.warning("database '{}' does not exist!".format(db_name))
def history_write(self): """ save history file """ history_file = cfg.get('history_file') logger.debug("saving history in {}".format(history_file)) os.makedirs(os.path.expanduser(os.path.dirname(history_file)), exist_ok=True) try: readline.write_history_file(os.path.expanduser(history_file)) except PermissionError: logger.warning("failed to write CLI history to {} " + "(no permission)".format(history_file))
def user_get_domain(self, name): s = name.split('@') if len(s) > 2: logger.warning("invalid username {}".format(name)) return None elif len(s) == 1: domain = cfg.read_param("domain", "Please provide the domain of the user") if not domain: logger.warning("no domain specified for {}".format(name)) return None return name, domain return s[0], s[1]
def do_password(self, params=None): if len(params) < 1: name = cfg.read_param( None, "Please provide the username to change the password for") if not name: logger.error("empty username") return -1 else: name = params[0] username, domain = self.user_get_domain(name) db, osips_ver = self.user_db_connect() if not db: return -1 user_dict = {USER_NAME_COL: username, USER_DOMAIN_COL: domain} # check if the user already exists if not db.entry_exists(USER_TABLE, user_dict): logger.warning("User {}@{} does not exist".format( username, domain)) return -1 if len(params) > 1: password = params[1] else: password = self.user_get_password() if password is None: logger.error("Password not specified: " + "cannot change passowrd for user {}@{}".format( user, domain)) return -1 plain_text_pw = cfg.getBool("plain_text_passwords") update_dict = { USER_HA1_COL: self.user_get_ha1(username, domain, password), USER_PASS_COL: password if plain_text_pw else "" } if osips_ver < '3.2': update_dict[USER_HA1B_COL] = self.user_get_ha1b( username, domain, password) db.update(USER_TABLE, update_dict, user_dict) logger.info("Successfully changed password for {}@{}".format( username, domain)) db.destroy() return True
def do_add(self, params=None): if len(params) < 1: name = cfg.read_param( None, "Please provide the username you want to add") if not name: logger.warning("no username to add!") return -1 else: name = params[0] username, domain = self.user_get_domain(name) db, osips_ver = self.user_db_connect() if not db: return -1 insert_dict = {USER_NAME_COL: username, USER_DOMAIN_COL: domain} # check if the user already exists if db.entry_exists(USER_TABLE, insert_dict): logger.error("User {}@{} already exists".format(username, domain)) return -1 if len(params) > 1: password = params[1] else: password = self.user_get_password() if password is None: logger.error( "password not specified: cannot add user {}@{}".format( user, domain)) return -1 insert_dict[USER_HA1_COL] = \ self.user_get_ha1(username, domain, password) # only populate the 'ha1b' column on 3.1 or older OpenSIPS DBs if osips_ver < '3.2': insert_dict[USER_HA1B_COL] = \ self.user_get_ha1b(username, domain, password) insert_dict[USER_PASS_COL] = \ password if cfg.getBool("plain_text_passwords") else "" db.insert(USER_TABLE, insert_dict) logger.info("Successfully added {}@{}".format(username, domain)) db.destroy() return True
def do_drop_role(self, params=None): """ drop a given role (connection to given template via URL) """ db_url = cfg.read_param( "template_url", "Please provide the URL to connect as template") if db_url is None: print() logger.error("no URL specified: aborting!") return -1 db_template = cfg.read_param( "database_template", "Please provide the database template name", DEFAULT_DB_TEMPLATE) if db_template is None: logger.error("no URL specified: aborting!") return -1 # create an object store database instance db = self.get_db(db_url, db_template) if db is None: return -1 role_name = None if len(params) >= 1: role_name = ''.join(params[0]) if role_name is None: role_name = cfg.read_param("role_name", "Please provide the role name to drop", DEFAULT_ROLE_NAME) if db.exists_role(role_name=role_name) is True: if cfg.read_param( "rule_force_drop", "Do you really want to drop the role '{}'".format( role_name), False, True): db.drop_role(role_name) db.destroy() else: logger.info("role '{}' not dropped!".format(role_name)) else: logger.warning("role '{}' does not exist!".format(role_name))
def do_drop(self, params=None): """ drop a given database object (connection via URL) For PostgreSQL, perform this operation using 'postgres' as role + DB """ if params and len(params) > 0: db_name = params[0] else: db_name = cfg.read_param("database_name", "Please provide the database to drop") admin_db_url = self.get_admin_db_url(db_name) if admin_db_url is None: return -1 if admin_db_url.lower().startswith("postgres"): admin_db_url = osdb.set_url_db(admin_db_url, 'postgres') # create an object store database instance db = self.get_db(admin_db_url, db_name) if db is None: return -1 # check to see if the database has already been created if db.exists(): if cfg.read_param( "database_force_drop", "Do you really want to drop the '{}' database".format( db_name), False, True, isbool=True): if db.drop(): logger.info("database '%s' dropped!", db_name) else: logger.info("database '%s' not dropped!", db_name) else: logger.info("database '{}' not dropped!".format(db_name)) else: logger.warning("database '{}' does not exist!".format(db_name)) db.destroy() return -1 db.destroy() return 0
def do_password(self, params=None): if len(params) < 1: name = cfg.read_param( None, "Please provide the username you want to change the password") if not name: logger.warning("no username to change password!") return -1 else: name = params[0] username, domain = self.user_get_domain(name) db = self.user_db_connect() if not db: return -1 user_dict = {USER_NAME_COL: username, USER_DOMAIN_COL: domain} # check if the user already exists if not db.entry_exists(USER_TABLE, user_dict): logger.warning("User {}@{} does not exist".format( username, domain)) return -1 if len(params) > 1: password = params[1] else: password = self.user_get_password() if password is None: logger.error("password not specified: " + "cannot change passowrd for user {}@{}".format( user, domain)) return -1 plain_text_pw = cfg.getBool("plain_text_passwords") update_dict = { USER_HA1_COL: self.user_get_ha1(username, domain, password), USER_HA1B_COL: self.user_get_ha1b(username, domain, password), USER_PASS_COL: "" if not plain_text_pw else password } db.update(USER_TABLE, update_dict, user_dict) logger.debug( "User's {}@{} password has been been successfully changed".format( username, domain)) db.destroy() return True
def preloop(self): """ preload a history file """ history_file = cfg.get('history_file') logger.debug("using history file {}".format(history_file)) try: readline.read_history_file(os.path.expanduser(history_file)) except PermissionError: logger.warning("failed to read CLI history from {} " + "(no permission)".format(history_file)) except FileNotFoundError: pass readline.set_history_length(int(cfg.get('history_file_size'))) if not self.registered_atexit: atexit.register(self.history_write)
def __init__(self, options): """ contructor for OpenSIPS-Cli """ self.debug = options.debug self.execute = options.execute self.command = options.command self.modules_dir_inserted = None if self.debug: logger.setLevel("DEBUG") if not options.config: cfg_file = None for f in defaults.CFG_PATHS: if os.path.isfile(f) and os.access(f, os.R_OK): # found a valid config file cfg_file = f break else: cfg_file = options.config if not cfg_file: logger.debug("no config file found in any of {}".format(", ".join( defaults.CFG_PATHS))) else: logger.debug("using config file {}".format(cfg_file)) # __init__ of the configuration file cfg.parse(cfg_file) if not cfg.has_instance(options.instance): logger.warning( "Unknown instance '{}'! Using default instance '{}'!".format( options.instance, defaults.DEFAULT_SECTION)) instance = defaults.DEFAULT_SECTION else: instance = options.instance cfg.set_instance(instance) cfg.set_custom_options(options.extra_options) if not self.execute: # __init__ of cmd.Cmd module cmd.Cmd.__init__(self) # Opening the current working instance self.update_instance(cfg.current_instance)
def do_add(self, params=None): if len(params) < 1: name = cfg.read_param( None, "Please provide the username you want to add") if not name: logger.warning("no username to add!") return -1 else: name = params[0] username, domain = self.user_get_domain(name) db = self.user_db_connect() if not db: return -1 insert_dict = {USER_NAME_COL: username, USER_DOMAIN_COL: domain} # check if the user already exists if db.entry_exists(USER_TABLE, insert_dict): logger.warning("User {}@{} already exists".format( username, domain)) return -1 if len(params) > 1: password = params[1] else: password = self.user_get_password() if password is None: logger.error( "password not specified: cannot add user {}@{}".format( user, domain)) return -1 insert_dict[USER_HA1_COL] = \ self.user_get_ha1(username, domain, password) insert_dict[USER_HA1B_COL] = \ self.user_get_ha1b(username, domain, password) plain_text_pw = cfg.getBool("plain_text_passwords") insert_dict[USER_PASS_COL] = \ "" if not plain_text_pw else password db.insert(USER_TABLE, insert_dict) logger.debug("User {}@{} has been successfully added!".format( username, domain)) db.destroy() return True
def do_update(self, params=None): """ method that implements update command """ command_obj = OrderedDict() command_obj["command"] = "update" command_obj["module"] = "" command_obj["table"] = "" command_obj["update.id"] = "" command_obj["values"] = OrderedDict() if len(params) < 1: db_name = cfg.read_param(None, "Please provide the database you want to update") if not db_name: logger.warning("no database to update!") return -1 else: db_name = params[0] command_obj["module"] = db_name if len(params) < 2: table_name = cfg.read_param(None, "Please provide the table you want to update") if not table_name: logger.warning("no table to update!") return -1 else: table_name = params[1] command_obj["table"] = table_name if len(params) < 3: update_id = cfg.read_param(None, "Please provide the id you want to update(update.id=<>)") if not update_id: logger.warning("no id to update") return -1 else: update_id = params[2] command_obj["update.id"] = update_id.split('=')[1] if len(params) < 4: col_names = cfg.read_param(None, "Please provide at least a column you want to update (<column>=<>)") if not col_names: logger.warning("no column to update!") return -1 else: col_names = params[3:] for col in col_names: command_obj["values"][col.split('=')[0]] = col.split('=')[1] return command_obj
def connect(self, db_name=None): """ connect to database """ if db_name is not None: self.db_name = db_name # TODO: do this only for SQLAlchemy if self.dialect == "postgres": database_url = "{}/{}".format(self.db_url, self.db_name) if sqlalchemy_utils.database_exists(database_url) is True: engine = sqlalchemy.create_engine(database_url, isolation_level='AUTOCOMMIT') self.__conn = engine.connect() # connect the Session object to our engine self.Session.configure(bind=self.__engine) # instanciate the Session object self.session = self.Session() logger.warning("connected to database URL '%s'", database_url) else: self.__conn.execute("USE {}".format(self.db_name))
def do_get_role(self, params=None): """ get role attributes (connection to given template via URL) """ db_url = cfg.read_param( "template_url", "Please provide the URL to connect as template") if db_url is None: logger.error("no URL specified: aborting!") return -1 db_template = cfg.read_param( "database_template", "Please provide the database template name", DEFAULT_DB_TEMPLATE) if db_template is None: logger.error("no URL specified: aborting!") return -1 # create an object store database instance db = self.get_db(db_url, db_template) if db is None: return -1 if len(params) < 1: role_name = cfg.read_param( "role_name", "Please provide the role name to alter", DEFAULT_ROLE_NAME) else: role_name = params[0] logger.debug("role_name: '%s'", role_name) if db.exists_role(role_name) is True: if db.get_role(role_name) is False: logger.error("get role '%s' didn't succeed", role_name) else: logger.warning( "can't get options of non existing role '{}'".format( role_name))
def do_trap(self, params): self.pids = [] self.gdb_outputs = {} self.process_info = "" trap_file = cfg.get("trap_file") logger.info("Trapping {} in {}".format(PROCESS_NAME, trap_file)) if params and len(params) > 0: self.pids = params else: thread = Thread(target=self.get_pids) thread.start() thread.join(timeout=1) if len(self.pids) == 0: logger.warning("could not get OpenSIPS pids through MI!") try: ps_pids = subprocess.check_output(["pidof",PROCESS_NAME]) self.pids = ps_pids.decode().split() except: logger.warning("could not find any OpenSIPS running!") self.pids = [] if len(self.pids) < 1: logger.error("could not find OpenSIPS' pids") return -1 logger.debug("Dumping PIDs: {}".format(", ".join(self.pids))) threads = [] for pid in self.pids: thread = Thread(target=self.get_gdb_output, args=(pid,)) thread.start() threads.append(thread) for thread in threads: thread.join() if len(self.gdb_outputs) == 0: logger.error("could not get output of gdb") return -1 with open(trap_file, "w") as tf: tf.write(self.process_info) for pid in self.pids: if pid not in self.gdb_outputs: logger.warning("No output from pid {}".format(pid)) continue try: procinfo = subprocess.check_output( ["ps", "--no-headers", "-ww", "-fp", pid]).decode()[:-1] except: procinfo = "UNKNOWN" tf.write("\n\n---start {} ({})\n{}". format(pid, procinfo, self.gdb_outputs[pid])) print("Trap file: {}".format(trap_file))
def do_add(self, params=None): """ method that implements add command """ command_obj = OrderedDict() command_obj["command"] = "add" command_obj["module"] = "" command_obj["table"] = "" command_obj["values"] = OrderedDict() if len(params) < 1: db_name = cfg.read_param(None, "Please provide the database you want to add to") if not db_name: logger.warning("no database to add!") return -1 else: db_name = params[0] command_obj["module"] = db_name if len(params) < 2: table_name = cfg.read_param(None, "Please provide the table you want to add to") if not table_name: logger.warning("no table to add!") return -1 else: table_name = params[1] command_obj["table"] = table_name if len(params) < 3: col_names = cfg.read_param(None, "Please provide at least a column you want to add to (<column>=<>)") if not col_names: logger.warning("no column to add!") return -1 else: col_names = params[2:] for col in col_names: command_obj["values"][col.split('=')[0]] = col.split('=')[1] return command_obj
def do_show(self, params=None): """ method that implements the show command """ command_obj = OrderedDict() command_obj["command"] = "show" command_obj["module"] = "" command_obj["table"] = "" command_obj["values"] = [] if len(params) < 1: db_name = cfg.read_param(None, "Please provide the database you want to display from") if not db_name: logger.warning("no database to show!") return -1 else: db_name = params[0] command_obj["module"] = db_name if len(params) < 2: table_name = cfg.read_param(None, "Please provide the table you want to display from") if not table_name: logger.warning("no table to show!") return -1 else: table_name = params[1] command_obj["table"] = table_name if len(params) < 3: col_names = cfg.read_param(None, "Please provide at least a column to display from") if not col_names: logger.warning("no column to show!") return -1 else: col_names = params[2:] command_obj["values"] = [c for c in col_names] return command_obj
def do_delete(self, params=None): """ method that implements delete command """ command_obj = OrderedDict() command_obj["command"] = "delete" command_obj["module"] = "" command_obj["table"] = "" command_obj["delete.id"] = "" if len(params) < 1: db_name = cfg.read_param(None, "Please provide the database you want to delete from") if not db_name: logger.warning("no database to delete!") return -1 else: db_name = params[0] command_obj["module"] = db_name if len(params) < 2: table_name = cfg.read_param(None, "Please provide the table you want to delete from") if not table_name: logger.warning("no table to delete!") return -1 else: table_name = params[1] command_obj["table"] = table_name if len(params) < 3: delete_id = cfg.read_param(None, "Please provide the id you want to delete(update.id=<>)") if not delete_id: logger.warning("no id to delete!") return -1 else: delete_id = params[2] command_obj["delete.id"] = delete_id.split('=')[1] return command_obj
def create_tables(self, db_name, db_url, admin_db, tables=[], create_std=True): """ create database tables """ db_url = osdb.set_url_db(db_url, db_name) # 2) prepare new object store database instance # use it to connect to the created database db = self.get_db(db_url, db_name) if db is None: return -1 if not db.exists(): logger.warning("database '{}' does not exist!".format(db_name)) return -1 schema_path = self.get_schema_path(db.dialect) if schema_path is None: return -1 if create_std: standard_file_path = os.path.join(schema_path, "standard-create.sql") if not os.path.isfile(standard_file_path): logger.error( "cannot find stardard OpenSIPS DB file: '{}'!".format( standard_file_path)) return -1 table_files = {'standard': standard_file_path} else: table_files = {} # check to see what tables we shall deploy if tables: pass elif cfg.exists("database_modules"): # we know exactly what modules we want to instsall tables_line = cfg.get("database_modules").strip().lower() if tables_line == "all": logger.debug("Creating all tables") tables = [ f.replace('-create.sql', '') \ for f in os.listdir(schema_path) \ if os.path.isfile(os.path.join(schema_path, f)) and \ f.endswith('-create.sql') ] else: logger.debug("Creating custom tables") tables = tables_line.split(" ") else: logger.debug("Creating standard tables") tables = STANDARD_DB_MODULES # check for corresponding SQL schemas files in system path logger.debug("checking tables: {}".format(" ".join(tables))) for table in tables: if table == "standard": # already checked for it continue table_file_path = os.path.join(schema_path, "{}-create.sql".format(table)) if not os.path.isfile(table_file_path): logger.warn("cannot find SQL file for module {}: {}".format( table, table_file_path)) else: table_files[table] = table_file_path username = osdb.get_url_user(db_url) admin_db.connect(db_name) # create tables from SQL schemas for module, table_file in table_files.items(): logger.info("Running {}...".format(os.path.basename(table_file))) try: db.create_module(table_file) if db.dialect == "postgres": self.pg_grant_table_access(table_file, username, admin_db) except osdbModuleAlreadyExistsError: logger.error("{} table(s) are already created!".format(module)) except osdbError as ex: logger.error("cannot import: {}".format(ex)) # terminate active database connection db.destroy() return 0
def do_create_role(self, params=None): """ create a given role (connection via URL) """ db_url = cfg.read_param( "template_url", "Please provide the URL to connect as template") if db_url is None: logger.error("no URL specified: aborting!") return -1 db_template = cfg.read_param( "database_template", "Please provide the database template name", DEFAULT_DB_TEMPLATE) if db_template is None: logger.error("no URL specified: aborting!") return -1 # create an object store database instance db = self.get_db(db_url, db_template) if db is None: return -1 if db.dialect == "postgres": logger.debug("params: '%s' (len: %s)", params, len(params)) if len(params) >= 1: role_name = ''.join(params[0]) else: role_name = None if role_name is None: role_name = cfg.read_param( "role_name", "Please provide the role name to create", DEFAULT_ROLE_NAME) logger.debug("role_name: '%s'", role_name) if len(params) >= 2: role_options = ''.join(params[1]) else: role_options = None if role_options is None: role_list = cfg.read_param( "role_options", "Please assing the list of role options to create", ' '.join(DEFAULT_ROLE_OPTIONS)) role_options = ''.join(role_list) logger.debug("role_options: '%s'", role_options) if len(params) >= 3: role_password = ''.join(params[2]) else: role_password = '******' logger.debug("role_password: '******'") if db.exists_role(role_name) is False: result = db.create_role(role_name, role_options, role_password) if result: db.destroy() else: logger.warning( "role '{}' already exists. Please use 'alter_role'".format( role_name)) return False return True
def print_yaml(self, result): if not yaml_available: logger.warning("yaml not available on your platform! " "Please install `python-yaml` package or similar!") else: print(yaml.dump(result, default_flow_style=False).strip())