def check_module_servers(server_features,
exit_=False,
show_send_recv_dat_=False,
logger=Logger.get_stdout_logger()):
fail_list = []
for server_feat in server_features:
if isinstance(server_features, list):
ip = server_feat.ip
port = server_feat.port
# name = server_feat.name
acronym = server_feat.acronym
elif isinstance(server_features, dict):
ip = server_features[server_feat].ip
port = server_features[server_feat].port
# name = server_features[server_feat].name
acronym = server_features[server_feat].acronym
else:
ip, port, name, acronym = None, None, None, None
if not check_mod_server(ip,
port,
acronym,
show_send_recv_dat_=show_send_recv_dat_,
logger=logger):
fail_list.append([ip, port])
if len(fail_list) > 0:
if exit_:
sys.exit(1)
return len(fail_list) == 0, fail_list
def get_images_from_video(vid_fname,
out_path,
frame_interval,
logger=Logger.get_stdout_logger()):
utils.file_exists(vid_fname, exit_=True)
utils.folder_exists(out_path, exit_=False, create_=True, print_=True)
logger.info(" # Extract image from video, {}".format(vid_fname))
vid = mpy.VideoFileClip(vid_fname)
base_fname = os.path.splitext(os.path.basename(vid_fname))[0]
i_digit = int(np.log10(vid.duration / frame_interval)) + 1
n_digit = int(np.log10(vid.duration)) + 3
for i, s in enumerate(itools.numeric_range(0, vid.duration,
frame_interval)):
frame = vid.get_frame(s)
time_info = "__" + \
"{:0{width}d}".format(i, width=i_digit) + \
"__" + \
"{:0{width}.1f}sec".format(s, width=n_digit)
out_fname = os.path.join(out_path,
base_fname + time_info + IMAGE_FILE_EXT)
utils.imwrite(frame, out_fname)
logger.info(" # save image, {}".format(out_fname))
def check_mod_server(ip,
port,
mod_name="NoName",
show_send_recv_dat_=True,
logger=Logger.get_stdout_logger()):
if check_port(ip, port):
check_rst = False
try:
recv = JsonSocket.json_send_and_recv(
ip,
port, {"cmd": "check"},
show_send_recv_dat_=show_send_recv_dat_)
if recv:
res = recv[0]
if res is not None and "state" in res and res[
"state"] == "healthy":
check_rst = True
except Exception as e:
Logger.write_exception_log(
logger, e,
"check_mod_server({}, {}, {})".format(ip, port, mod_name))
if check_rst:
logger.info(" # {}://{}:{:d} is in healthy state.".format(
mod_name, ip, port))
else:
logger.info(" # {}://{}:{:d} is NOT in healthy state.".format(
mod_name, ip, port))
return check_rst
else:
logger.info(" @ {}://{}:{:d} DOES NOT exist.".format(
mod_name, ip, port))
return False
def get_server_socket(ip,
port,
logger=Logger.get_stdout_logger(),
proc_name='',
listen_num=5):
logger.info(" # Getting server socket...")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = (ip, port)
# logger.info(server_address)
# check = check_port(ip, port, logger=logger)
# logger.info(check)
# if check:
if check_port(ip, port): # , logger=logger):
logger.info(" # Port, {:d}, was already taken. "
"The process using {:d} will be killed first.".format(
port, port))
kill_process(port, name=proc_name)
logger.info(" # Starting up \"{}\" SERVER on {}:{:d}...".format(
proc_name, ip, port))
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(server_address)
sock.listen(listen_num)
return sock
def save_txt_file(contents,
fname,
out_path=None,
desc='',
logger=Logger.get_stdout_logger()):
txt_fname = os.path.join(out_path, fname) if out_path else fname
logger.info(" # save {} file, {}.".format(desc, txt_fname))
with open(txt_fname, "w") as f:
f.write(contents)
def save_video_file_from_images(img_arr,
vid_fname,
duration=2,
fps=30,
logger=Logger.get_stdout_logger()):
clips = [mpy.ImageClip(m).set_duration(duration) for m in img_arr]
concat_clip = mpy.concatenate_videoclips(clips, method='compose')
concat_clip.write_videofile(vid_fname, fps=fps)
logger.info(" # save video file from {:d} images, {}.".format(
len(img_arr), vid_fname))
return True
def __init__(self,
ip,
port,
logger=Logger.get_stdout_logger(),
listen_num=5):
self.logger = logger
self.ip = ip
self.port = port
self.listen_sock = self._get_listen_socket(listen_num)
self._stop_event = multiprocessing.Event()
self._lock = multiprocessing.Lock()
self._cond_lock = multiprocessing.Condition(self._lock)
def save_video_from_image_array(img_arr,
base_fname,
out_path=None,
vid_duration=2,
logger=Logger.get_stdout_logger()):
if vid_duration <= 0 or not img_arr:
return
out_fname = os.path.join(out_path, base_fname) if out_path else base_fname
out_fname += VIDEO_FILE_EXT
logger.info(" # save video from {:d} images, {}.".format(
len(img_arr), out_fname))
create_video_from_images(img_arr, out_fname, duration=vid_duration)
def __init__(self,
ip,
port,
logger=Logger.get_stdout_logger(),
listen_num=1):
super().__init__(ip, port, logger, listen_num)
def save_dict_to_json_file(dict_dat,
json_fname,
logger=Logger.get_stdout_logger()):
with open(json_fname, "w") as f:
json.dump(dict_dat, f)
logger.info(" # Save dict to json file, {}".format(json_fname))
