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())
