def test_main_repo_mongo_file(self, mock_date, mock_host, mock_data,
mock_distro):
"""Function: test_main_repo_mongo_file
Description: Test writing to Mongo database and to a file for repo
option.
Arguments:
"""
mock_date.datetime.strftime.return_value = self.time_str
mock_data.return_value = self.repo_data
mock_host.return_value = self.hostname
mock_distro.return_value = self.distro
cmdline = gen_libs.get_inst(sys)
self.argv_list.append("-R")
cmdline.argv = self.argv_list
package_admin.main()
mongo = mongo_libs.crt_coll_inst(self.mongo_cfg, self.dbn, self.tbl)
mongo.connect()
if mongo.coll_find1()["Server"] == self.hostname:
status = filecmp.cmp(self.out_file, self.repo_non_json_file)
else:
status = False
mongo_libs.disconnect([mongo])
self.assertTrue(status)
def test_process_yum_mongo_file(self, mock_date):
"""Function: test_process_yum_mongo_file
Description: Test writing to Mongo database and to a file.
Arguments:
"""
mock_date.datetime.strftime.return_value = self.time_str
package_admin.process_yum(self.args_array, self.yum, self.dict_key,
self.func_name, class_cfg=self.mongo_cfg)
mongo = mongo_libs.crt_coll_inst(self.mongo_cfg, self.dbn, self.tbl)
mongo.connect()
if mongo.coll_find1()["Server"] == self.yum.hostname:
status = filecmp.cmp(self.out_file, self.non_json_file)
else:
status = False
mongo_libs.disconnect([mongo])
self.assertTrue(status)
def test_list_repo_mongo(self, mock_date):
"""Function: test_list_repo_mongo
Description: Test writing to Mongo database.
Arguments:
"""
mock_date.datetime.strftime.return_value = self.time_str
package_admin.list_repo(self.args_array3,
self.yum,
class_cfg=self.mongo_cfg)
mongo = mongo_libs.crt_coll_inst(self.mongo_cfg, self.dbn, self.tbl)
mongo.connect()
status = \
True if mongo.coll_find1()["Server"] == self.yum.hostname \
else False
mongo_libs.disconnect([mongo])
self.assertTrue(status)
def test_main_repo_mongo(self, mock_date, mock_host, mock_data):
"""Function: test_main_repo_mongo
Description: Test writing to Mongo database for repo option.
Arguments:
"""
mock_date.datetime.strftime.return_value = self.time_str
mock_data.return_value = self.repo_data
mock_host.return_value = self.hostname
cmdline = gen_libs.get_inst(sys)
self.argv_list3.append("-R")
cmdline.argv = self.argv_list3
package_admin.main()
mongo = mongo_libs.crt_coll_inst(self.mongo_cfg, self.dbn, self.tbl)
mongo.connect()
status = \
True if mongo.coll_find1()["Server"] == self.hostname else False
mongo_libs.disconnect([mongo])
self.assertTrue(status)
def test_run_program_repo_mongo_file(self, mock_date, mock_host, mock_data,
mock_distro):
"""Function: test_run_program_repo_mongo_file
Description: Test writing to Mongo database and to a file for update
option.
Arguments:
"""
mock_date.datetime.strftime.return_value = self.time_str
mock_data.return_value = self.repo_data
mock_host.return_value = self.hostname
mock_distro.return_value = self.distro
self.args_array["-R"] = True
package_admin.run_program(self.args_array, self.func_dict)
mongo = mongo_libs.crt_coll_inst(self.mongo_cfg, self.dbn, self.tbl)
mongo.connect()
if mongo.coll_find1()["Server"] == self.hostname:
status = filecmp.cmp(self.out_file, self.repo_non_json_file)
else:
status = False
mongo_libs.disconnect([mongo])
self.assertTrue(status)
def test_run_program_repo_mongo(self, mock_date, mock_host, mock_data):
"""Function: test_run_program_repo_mongo
Description: Test writing to Mongo database for install option.
Arguments:
"""
mock_date.datetime.strftime.return_value = self.time_str
mock_data.return_value = self.repo_data
mock_host.return_value = self.hostname
self.args_array3["-R"] = True
package_admin.run_program(self.args_array3, self.func_dict)
mongo = mongo_libs.crt_coll_inst(self.mongo_cfg, self.dbn, self.tbl)
mongo.connect()
status = \
True if mongo.coll_find1()["Server"] == self.hostname else False
mongo_libs.disconnect([mongo])
self.assertTrue(status)
def run_compact(mongo, db_name, tbl_list=None, **kwargs):
"""Function: run_compact
Description: Changes database instance to new database and executes
compact command within the class instance against a list of tables.
Arguments:
(input) mongo -> Database instance.
(input) db_name -> Database name.
(input) tbl_list -> List of tables.
"""
if tbl_list is None:
tbl_list = []
else:
tbl_list = list(tbl_list)
mongo.chg_db(dbs=db_name)
print("Compacting for %s" % (mongo.db_name))
if not tbl_list:
tbl_list = mongo.get_tbl_list(False)
for item in tbl_list:
print("\tCompacting: {0:50}".format(item + "..."), end="")
coll = mongo_libs.crt_coll_inst(mongo, db_name, item)
state = coll.connect()
if state[0]:
if coll.coll_options().get("capped", False):
print("\tCollection capped: not compacted")
else:
if mongo.db_cmd("compact", obj=item)["ok"] == 1:
print("\tDone")
else:
print("\tCommand Failed")
mongo_libs.disconnect([coll])
else:
print("\tError encountered: %s" % (state[1]))
def run_program(args_array, func_dict, **kwargs):
"""Function: run_program
Description: Creates class instance(s) and controls flow of the program.
Arguments:
(input) args_array -> Dict of command line options and values.
(input) func_dict -> Dictionary list of functions and options.
(input) **kwargs:
opt_arg -> Dictionary of additional options to add.
arg_req_dict -> contains link between config and required option.
"""
args_array = dict(args_array)
func_dict = dict(func_dict)
arg_req_dict = dict(kwargs.get("arg_req_dict", {}))
mail = None
server = mongo_libs.create_instance(args_array["-c"], args_array["-d"],
mongo_class.Server)
status = server.connect()
if status[0]:
req_arg = get_req_options(server, arg_req_dict)
if args_array.get("-e", False):
dtg = datetime.datetime.strftime(datetime.datetime.now(),
"%Y%m%d_%H%M%S")
subj = args_array.get("-s",
[server.name, ": mongo_db_dump: ", dtg])
mail = gen_class.setup_mail(args_array.get("-e"), subj=subj)
# Intersect args_array and func_dict to decide which functions to call.
for item in set(args_array.keys()) & set(func_dict.keys()):
err_flag, err_msg = func_dict[item](server, args_array, mail=mail,
req_arg=req_arg, **kwargs)
if err_flag:
print(err_msg)
break
mongo_libs.disconnect([server])
else:
print("Connection failure: %s" % (status[1]))
def run_program(args_array, func_dict, **kwargs):
"""Function: run_program
Description: Creates class instance(s) and controls flow of the program.
Arguments:
(input) args_array -> Dict of command line options and values.
(input) func_dict -> Dictionary list of functions and options.
"""
args_array = dict(args_array)
func_dict = dict(func_dict)
server = mongo_libs.create_instance(args_array["-c"], args_array["-d"],
mongo_class.Server)
state = server.connect()
if state[0]:
outfile = args_array.get("-o", None)
db_tbl = args_array.get("-i", None)
repcfg = None
mail = None
if args_array.get("-m", None):
repcfg = gen_libs.load_module(args_array["-m"], args_array["-d"])
if args_array.get("-e", None):
mail = gen_class.setup_mail(args_array.get("-e"),
subj=args_array.get("-s", None))
# Call function(s) - intersection of command line and function dict.
for item in set(args_array.keys()) & set(func_dict.keys()):
err_flag, err_msg = func_dict[item](
server, args_array, ofile=outfile, db_tbl=db_tbl,
class_cfg=repcfg, mail=mail, **kwargs)
if err_flag:
print("Error: %s" % (err_msg))
break
mongo_libs.disconnect([server])
else:
print("Connection failure: %s" % (state[1]))
def fetch_priority(repset, args_array, **kwargs):
"""Function: fetch_priority
Description: Fetch and print members in the replication set.
Arguments:
(input) repset -> Replication set instance.
(input) args_array -> Array of command line options and values.
(output) status -> Tuple on connection status.
status[0] - True|False - Connection successful.
status[1] - Error message if connection failed.
"""
args_array = dict(args_array)
coll = mongo_class.Coll(repset.name,
repset.user,
repset.japd,
host=repset.host,
port=repset.port,
db="local",
coll="system.replset",
auth=repset.auth,
conf_file=repset.conf_file,
auth_db=repset.auth_db,
use_arg=repset.use_arg,
use_uri=repset.use_uri,
auth_mech=repset.auth_mech)
status = coll.connect()
if status[0]:
print("\nMembers => priority of replica set: %s" % (repset.repset))
for item in coll.coll_find1()["members"]:
print("\t{0} => {1}".format(item["host"], item["priority"]))
mongo_libs.disconnect([coll])
else:
status = (status[0],
"fetch_priority: Connection failure: %s" % (status[1]))
return status
def tearDown(self):
"""Function: tearDown
Description: Clean up of integration testing.
Arguments:
"""
mongo = mongo_class.DB(
self.mongo_cfg.name, self.mongo_cfg.user, self.mongo_cfg.japd,
self.mongo_cfg.host, self.mongo_cfg.port, db=self.dbn,
auth=self.mongo_cfg.auth, conf_file=self.mongo_cfg.conf_file)
mongo.db_connect(self.dbn)
mongo.db_cmd("dropDatabase")
mongo_libs.disconnect([mongo])
if os.path.isfile(self.out_file):
os.remove(self.out_file)
def mongo_check(mongo_cfg, hostname, dbn, tbl):
"""Function: mongo_check
Description: Validates the contents of the mongo database.
Arguments:
(input) mongo_cfg -> Mongo server configuration.
(input) hostname -> Host name of the server running the check.
(input) dbn -> Name of the database in Mongo.
(input) tbl -> Name of the table in Mongo.
"""
coll = mongo_libs.crt_coll_inst(mongo_cfg, dbn, tbl)
coll.connect()
status = True if coll.coll_find1()["Server"] == hostname else False
mongo_libs.disconnect([coll])
return status
def mongo_cleanup(mongo_cfg, dbn):
"""Function: mongo_cleanup
Description: Cleans up the contents of the mongo database.
Arguments:
(input) mongo_cfg -> Mongo server configuration.
(input) dbn -> Name of the database in Mongo.
"""
mongo = mongo_class.DB(mongo_cfg.name,
mongo_cfg.user,
mongo_cfg.japd,
host=mongo_cfg.host,
port=mongo_cfg.port,
db=dbn,
auth=mongo_cfg.auth,
conf_file=mongo_cfg.conf_file)
mongo.db_connect(dbn)
mongo.db_cmd("dropDatabase")
mongo_libs.disconnect([mongo])
def run_program(args_array, func_dict, **kwargs):
"""Function: run_program
Description: Creates class instance(s) and controls flow of the program.
Arguments:
(input) args_array -> Dict of command line options and values.
(input) func_dict -> Dictionary list of functions and options.
(input) **kwargs:
req_arg -> List of options to add to cmd line.
opt_arg -> Dictionary of additional options to add.
"""
global AUTH_DB
args_array = dict(args_array)
func_dict = dict(func_dict)
outfile = args_array.get("-o", False)
db_tbl = args_array.get("-i", False)
cfg = None
server = gen_libs.load_module(args_array["-c"], args_array["-d"])
req_arg = list(kwargs.get("req_arg", []))
opt_arg = dict(kwargs.get("opt_arg", {}))
if AUTH_DB in req_arg:
req_arg.remove(AUTH_DB)
req_arg.append(AUTH_DB + server.auth_db)
if args_array.get("-m", False):
cfg = gen_libs.load_module(args_array["-m"], args_array["-d"])
if server.repset and server.repset_hosts:
# Only pass authorization mechanism if present.
auth_mech = {
"auth_mech": server.auth_mech
} if hasattr(server, "auth_mech") else {}
mongo = mongo_class.RepSet(server.name,
server.user,
server.japd,
host=server.host,
port=server.port,
auth=server.auth,
repset=server.repset,
repset_hosts=server.repset_hosts,
auth_db=server.auth_db,
use_arg=server.use_arg,
use_uri=server.use_uri,
**auth_mech)
else:
mongo = mongo_libs.create_instance(args_array["-c"], args_array["-d"],
mongo_class.Server)
status = mongo.connect()
if status[0]:
# Call function(s) - intersection of command line and function dict.
for item in set(args_array.keys()) & set(func_dict.keys()):
func_dict[item](mongo,
args_array,
ofile=outfile,
db_tbl=db_tbl,
class_cfg=cfg,
req_arg=req_arg,
opt_arg=opt_arg)
mongo_libs.disconnect([mongo])
else:
if not args_array.get("-w", False):
print("run_program: Connection failure: %s" % (status[1]))
def run_program(args_array, func_dict, **kwargs):
"""Function: run_program
Description: Creates class instance(s) and controls flow of the program.
Arguments:
(input) args_array -> Dict of command line options and values.
(input) func_dict -> Dictionary list of functions and options.
"""
args_array = dict(args_array)
func_dict = dict(func_dict)
server = gen_libs.load_module(args_array["-c"], args_array["-d"])
# Only pass authorization mechanism if present.
auth_mech = {
"auth_mech": server.auth_mech
} if hasattr(server, "auth_mech") else {}
coll = mongo_class.Coll(server.name,
server.user,
server.japd,
host=server.host,
port=server.port,
db="local",
coll="system.replset",
auth=server.auth,
conf_file=server.conf_file,
auth_db=server.auth_db,
use_arg=server.use_arg,
use_uri=server.use_uri,
**auth_mech)
status = coll.connect()
if status[0]:
# Is replication setup.
if coll.coll_cnt() != 0:
# Get replica set name if not in config.
if server.repset:
rep_set = server.repset
else:
rep_set = coll.coll_find1().get("_id")
repinst = mongo_class.RepSet(server.name,
server.user,
server.japd,
host=server.host,
port=server.port,
auth=server.auth,
repset=rep_set,
repset_hosts=server.repset_hosts,
auth_db=server.auth_db,
use_arg=server.use_arg,
use_uri=server.use_uri,
**auth_mech)
status2 = repinst.connect()
if status2[0]:
_call_func(args_array, func_dict, repinst)
mongo_libs.disconnect([repinst])
else:
print("run_program.RepSet: Connection failure: %s" %
(status2[1]))
else:
gen_libs.prt_msg("Error", "No replication found.", 0)
mongo_libs.disconnect([coll])
else:
print("run_program.Coll: Connection failure: %s" % (status[1]))
def process_request(server, func_name, db_name=None, tbl_name=None, **kwargs):
"""Function: process_request
Description: Prepares for the type of check based on the arguments passed
to the function and then calls the "func_name" function.
Arguments:
(input) server -> Database server instance.
(input) func_name -> Name of a function.
(input) db_name -> List of database names.
(input) tbl_name -> List of table names.
(input) **kwargs:
full -> Full validation table check option.
(output) err_flag -> True|False - If an error has occurred.
(output) err_msg -> Error message.
"""
err_flag = False
err_msg = None
if db_name is None:
db_name = []
else:
db_name = list(db_name)
if tbl_name is None:
tbl_name = []
else:
tbl_name = list(tbl_name)
db_list = server.fetch_dbs()
mongo = mongo_class.DB(
server.name, server.user, server.japd, host=server.host,
port=server.port, db="test", auth=server.auth,
conf_file=server.conf_file, auth_db=server.auth_db,
use_arg=server.use_arg, use_uri=server.use_uri)
state = mongo.connect()
if not state[0]:
err_flag = True
err_msg = "Connection to Mongo DB: %s" % state[1]
else:
# Process all databases.
if not db_name:
for item in db_list:
func_name(mongo, item, **kwargs)
# Process all tables in a database.
elif not tbl_name:
# Generator builds list of databases to process.
for dbn in (dbn for dbn in db_name if dbn in db_list):
func_name(mongo, dbn, **kwargs)
# Process passed databases and tables.
else:
# Generator builds list of databases to process.
for dbn in (dbn for dbn in db_name if dbn in db_list):
mongo.chg_db(dbs=dbn)
tbl_list = mongo.get_tbl_list()
fnd_tbls = list((tbl for tbl in tbl_name if tbl in tbl_list))
if fnd_tbls:
func_name(mongo, dbn, fnd_tbls, **kwargs)
else:
print("Found no tables to process in: %s" % (dbn))
mongo_libs.disconnect([mongo])
return err_flag, err_msg
