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
