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_db_connect(self): engine = osdb.get_db_engine() db_url = cfg.read_param(["database_user_url", "database_url"], "Please provide us the URL of the database") if db_url is None: print() logger.error("no URL specified: aborting!") return None db_url = osdb.set_url_driver(db_url, engine) db_name = cfg.read_param(["database_user_name", "database_name"], "Please provide the database to add user to", DEFAULT_DB_NAME) try: db = osdb(db_url, db_name) except osdbError: logger.error("failed to connect to database %s", db_name) return None if not db.connect(): return None return db
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 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_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 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 do_create_module(self, module_name): """ create database table for given module """ db_url = cfg.read_param( "database_url", "Please provide the URL to connect to the database") if db_url is None: print() logger.error("no URL specified: aborting!") return -1 db_name = cfg.read_param("database_name", "Please provide the database name", DEFAULT_DB_NAME) if db_name is None: logger.error("no URL specified: aborting!") return -1 # create an object store database instance db = self.get_db(db_url, db_name) if db is None: return -1 # connect to the database db.connect(db_name) # create table from schema-file for given module name module = ' '.join(module_name) logger.debug("module_name: '%s'", module) #re.sub('\ |\[|\'|\]', '', module) #module_name.strip('[']') db_schema = db_url.split(":")[0] schema_path = self.get_schema_path(db_schema) if schema_path is None: return -1 module_schema_file = os.path.join(schema_path, "{}-create.sql".format(module)) try: db.create_module(module_schema_file) logger.info( "database tables for module '%s' has been successfully created.", module_name) except osdbError as ex: logger.error("cannot import: {}".format(ex)) # terminate active database connection db.destroy() return True
def user_db_connect(self): db_url = cfg.read_param(["database_user_url", "database_url"], "Please provide us the URL of the database") if db_url is None: print() logger.error("no URL specified: aborting!") return None db_name = cfg.read_param(["database_user_name", "database_name"], "Please provide the database to add user to", DEFAULT_DB_NAME) db = osdb(db_url, db_name) db.connect() return db
def do_add(self, params): """ add a given table to the database (connection via URL) """ if len(params) < 1: logger.error("Please specify a module to add (e.g. dialog)") return -1 module = params[0] if len(params) < 2: db_name = cfg.read_param("database_name", "Please provide the database to add the module to") else: db_name = params[1] db_url = self.get_db_url(db_name) if not db_url: logger.error("no DB URL specified: aborting!") return -1 admin_url = self.get_admin_db_url(db_name) if not admin_url: return -1 admin_db = self.get_db(admin_url, db_name) if not admin_db: return -1 ret = self.create_tables(db_name, db_url, admin_db, tables=[module], create_std=False) admin_db.destroy() return ret
def get_schema_path(self, db_schema): db_path = cfg.read_param( "database_path", "Please provide the path to the OpenSIPS DB scripts") if db_path is None: print() logger.error( "don't know how to find the path to the OpenSIPS DB scripts") return None if not os.path.exists(db_path): logger.error( "path '{}' to OpenSIPS DB scripts does not exist!".format( db_path)) return None if not os.path.isdir(db_path): logger.error( "path '{}' to OpenSIPS DB scripts is not a directory!".format( db_path)) return None schema_path = os.path.join(db_path, db_schema) if not os.path.isdir(schema_path): logger.error( "invalid OpenSIPS DB scripts dir: '{}'!".format(schema_path)) return None return schema_path
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_create(self, params=None): """ create database with role-assigment and tables """ if len(params) >= 1: db_name = params[0] else: db_name = cfg.read_param("database_name", "Please provide the database to create") logger.debug("db_name: '%s'", db_name) admin_url = self.get_admin_db_url(db_name) if not admin_url: return -1 admin_db = self.get_db(admin_url, db_name) if not admin_db: return -1 if self.create_db(db_name, admin_url, admin_db) < 0: return -1 db_url = self.get_db_url(db_name) if not db_url: return -1 if self.ensure_user(db_url, db_name, admin_db) < 0: return -1 if self.create_tables(db_name, db_url, admin_db) < 0: return -1 admin_db.destroy() return 0
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_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 ask_db_url(self): db_url = cfg.read_param("template_url", "Please provide the URL of the SQL database") if db_url is None: print() logger.error("no URL specified: aborting!") return -1 return db_url
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_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 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_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 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 get_schema_path(self, db_schema): """ helper function: get the path defining the root path holding sql schema template """ if '+' in db_schema: db_schema = db_schema[0:db_schema.index('+')] if self.db_path is not None: return os.path.join(self.db_path, db_schema) if os.path.isfile( os.path.join('/usr/share/opensips', db_schema, 'standard-create.sql')): self.db_path = '/usr/share/opensips' return os.path.join(self.db_path, db_schema) db_path = cfg.read_param( "database_path", "Please provide the path to the OpenSIPS DB scripts") if db_path is None: print() logger.error( "don't know how to find the path to the OpenSIPS DB scripts") return None if db_path.endswith('/'): db_path = db_path[:-1] if os.path.basename(db_path) == db_schema: db_path = os.path.dirname(db_path) if not os.path.exists(db_path): logger.error( "path '{}' to OpenSIPS DB scripts does not exist!".format( db_path)) return None if not os.path.isdir(db_path): logger.error( "path '{}' to OpenSIPS DB scripts is not a directory!".format( db_path)) return None schema_path = os.path.join(db_path, db_schema) if not os.path.isdir(schema_path): logger.error( "invalid OpenSIPS DB scripts dir: '{}'!".format(schema_path)) return None self.db_path = db_path return schema_path
def get_schema_path(self, backend): """ helper function: get the path defining the root path holding sql schema template """ if '+' in backend: backend = backend[0:backend.index('+')] if self.db_path is not None: return os.path.join(self.db_path, backend) if os.path.isfile( os.path.join('/usr/share/opensips', backend, 'standard-create.sql')): self.db_path = '/usr/share/opensips' return os.path.join(self.db_path, backend) db_path = cfg.read_param( "database_schema_path", "Could not locate DB schema files for {}! Custom path".format( backend)) if db_path is None: print() logger.error("failed to locate {} DB schema files".format(backend)) return None if db_path.endswith('/'): db_path = db_path[:-1] if os.path.basename(db_path) == backend: db_path = os.path.dirname(db_path) if not os.path.exists(db_path): logger.error( "path '{}' to OpenSIPS DB scripts does not exist!".format( db_path)) return None if not os.path.isdir(db_path): logger.error( "path '{}' to OpenSIPS DB scripts is not a directory!".format( db_path)) return None schema_path = os.path.join(db_path, backend) if not os.path.isdir(schema_path): logger.error( "invalid OpenSIPS DB scripts dir: '{}'!".format(schema_path)) return None self.db_path = db_path return schema_path
def user_db_connect(self): engine = osdb.get_db_engine() db_url = cfg.read_param(["database_user_url", "database_url"], "Please provide us the URL of the database") if db_url is None: print() logger.error("no URL specified: aborting!") return None, None db_url = osdb.set_url_driver(db_url, engine) db_name = cfg.read_param(["database_user_name", "database_name"], "Please provide the database to add user to", DEFAULT_DB_NAME) try: db = osdb(db_url, db_name) except osdbError: logger.error("failed to connect to database %s", db_name) return None, None if not db.connect(): return None, None res = db.find('version', 'table_version', {'table_name': USER_TABLE}) if not res: osips_ver = '3.2+' else: # RFC 8760 support was introduced in OpenSIPS 3.2 (table ver 8+) tb_ver = res.first()[0] if tb_ver >= 8: osips_ver = '3.2+' else: osips_ver = '3.1' return db, osips_ver
def do_create(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 create", DEFAULT_DB_NAME) db = self.getdb(db_url, db_name) if db is None: return -1 self._do_create(db) db.destroy() return 0
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_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_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 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_migrate(self, params): if len(params) < 2: print("Usage: database migrate <old-database> <new-database>") return 0 old_db = params[0] new_db = params[1] db_url = cfg.read_param("database_url", "Please provide the URL of the database") if db_url is None: print() logger.error("no URL specified, aborting!") return -1 db = self.getdb(db_url, old_db) if db is None: return -1 if not db.exists(old_db): logger.error("the source database ({}) does not exist!".format(old_db)) return -2 print("Creating database {}...".format(new_db)) self._do_create(db, new_db) db_schema = db.db_url.split(":")[0] migrate_scripts = self.get_migrate_scripts_path(db_schema) if migrate_scripts is None: return -1 logger.debug("Got path: {}".format(migrate_scripts)) print("Migrating all matching OpenSIPS tables...") db.migrate(migrate_scripts, old_db, new_db) print("Successfully copied all OpenSIPS table data into the '{}' database!".format( new_db)) db.destroy() return 0
def do_create(self, params=None): """ create database with role-assigment and tables """ if len(params) >= 1: db_name = ''.join(params[0]) else: db_name = cfg.read_param("database_name", "Please provide the database to create", DEFAULT_DB_NAME) logger.debug("db_name: '%s'", db_name) db_url = self.ask_db_url() if db_url is None: return -1 if self._do_create_db([db_name], db_url) < 0: return -1 if self.create_tables(db_name, db_url=db_url) < 0: return -1 return 0