def _process_car_inference_result(self, conn, msg_data):
'''
Description: process car_inference_result message
Input:
conn: a socket connection
msg_data: message data.
Returns: True or False
'''
request = pb2.CarInferenceResult()
response = pb2.CommonResponse()
msg_name = msg_name = pb2._COMMONRESPONSE.full_name
inference_dict = {}
if not self._parse_protobuf(request, msg_data):
self._response_error_unknown(conn)
return False
app_id = request.frame_index.app_id
channel_id = request.frame_index.channel_id
frame_id = request.frame_index.frame_id
object_id = request.object_id
if not self.app_manager.is_app_exist(app_id):
logging.error("app_id: %s not exist", app_id)
response.ret = pb2.kErrorAppLost
response.message = "app_id: %s not exist" % (app_id)
self.send_message(conn, response, msg_name)
return False
channel_dir = os.path.join(self.storage_dir, app_id, channel_id)
stack_list = os.listdir(channel_dir)
stack_list.sort()
current_stack = int(frame_id) // (MAX_SUB_DIRECTORY_NUM * FRAME_GAP)
stack_directory = "stack_{}/".format(current_stack)
object_dir = os.path.join(channel_dir, stack_directory, frame_id,
object_id)
if request.type == pb2.kCarColor:
inference_dict["color_confidence"] = request.confidence
inference_dict["color"] = request.value
elif request.type == pb2.kCarBrand:
inference_dict["brand_confidence"] = request.confidence
inference_dict["brand"] = request.value
elif request.type == pb2.kCarPlate:
inference_dict["plate_confidence"] = request.confidence
inference_dict["plate"] = request.value
else:
logging.error("unknown type %d", request.type)
self._response_error_unknown(conn)
return False
if not self._save_inference_result(object_dir, inference_dict):
self._response_error_unknown(conn)
return False
self.app_manager.set_heartbeat(conn.fileno())
response.ret = pb2.kErrorNone
response.message = "car inference process succeed"
self.send_message(conn, response, msg_name)
return True
def _process_register_app(self, conn, msg_data):
'''
Description: process register_app message
Input:
conn: a socket connection
msg_data: message data.
Returns: True or False
'''
request = pb2.RegisterApp()
response = pb2.CommonResponse()
msg_name = pb2._COMMONRESPONSE.full_name
if not self._parse_protobuf(request, msg_data):
self._response_error_unknown(conn)
return False
app_id = request.id
app_type = request.type
# check app id if exist
app_dir = os.path.join(self.storage_dir, app_id)
if os.path.isdir(app_dir):
logging.error("App %s is already exist.", app_id)
response.ret = pb2.kErrorAppRegisterExist
response.message = "App {} is already exist.".format(app_id)
self.send_message(conn, response, msg_name)
elif self.app_manager.get_app_num() >= self.max_app_num:
logging.error("App number reach the upper limit")
response.ret = pb2.kErrorAppRegisterLimit
response.message = "App number reach the upper limit"
self.send_message(conn, response, msg_name)
elif app_type != SERVER_TYPE:
logging.error("App type %s error", app_type)
response.ret = pb2.kErrorAppRegisterType
response.message = "App type {} error".format(app_type)
self.send_message(conn, response, msg_name)
elif self._is_app_id_invalid(app_id):
logging.error("App id %s is too long", app_id)
response.ret = pb2.kErrorOther
response.message = "App id: {} is too long".format(app_id)
self.send_message(conn, response, msg_name)
elif self._remain_space() < self.reserved_space:
logging.error("Insufficient storage space on Presenter Server.")
response.ret = pb2.kErrorAppRegisterNoStorage
response.message = "Insufficient storage space on Presenter Server"
self.send_message(conn, response, msg_name)
else:
self.app_manager.register_app(app_id, conn)
# app_dir = os.path.join(self.storage_dir, app_id)
# if not os.path.isdir(app_dir):
# os.makedirs(app_dir)
response.ret = pb2.kErrorNone
response.message = "Register app {} succeed".format(app_id)
self.send_message(conn, response, msg_name)
return True
return False
def _process_face_inference_result(self, conn, msg_data):
'''
Description: process face_inference_result message
Input:
conn: a socket connection
msg_data: message data.
Returns: True or False
'''
request = pb2.FaceInferenceResult()
response = pb2.CommonResponse()
msg_name = msg_name = pb2._COMMONRESPONSE.full_name
inference_dict = {}
if not self._parse_protobuf(request, msg_data):
self._response_error_unknown(conn)
return False
app_id = request.frame_index.app_id
channel_id = request.frame_index.channel_id
frame_id = request.frame_index.frame_id
object_id = request.object_id
if not self.app_manager.is_app_exist(app_id):
logging.error("app_id: %s not exist", app_id)
response.ret = pb2.kErrorAppLost
response.message = "app_id: %s not exist" % (app_id)
self.send_message(conn, response, msg_name)
return False
channel_dir = os.path.join(self.storage_dir, app_id, channel_id)
stack_list = os.listdir(channel_dir)
stack_list.sort()
current_stack = stack_list[-1]
object_dir = os.path.join(channel_dir, current_stack, frame_id,
object_id)
if request.type == pb2.kFaceAge:
inference_dict["age_confidence"] = request.confidence
inference_dict["age"] = request.value
elif request.type == pb2.kFaceGender:
inference_dict["gender_confidence"] = request.confidence
inference_dict["gender"] = request.value
else:
logging.error("unknown type %d", request.type)
self._response_error_unknown(conn)
return False
if not self._save_inference_result(object_dir, inference_dict):
self._response_error_unknown(conn)
return False
self.app_manager.set_heartbeat(conn.fileno())
response.ret = pb2.kErrorNone
response.message = "face inference process succeed"
self.send_message(conn, response, msg_name)
return True
def _response_error_unknown(self, conn):
'''
Description: response error_unknown message
Input:
conn: a socket connection
Returns: NA
'''
msg_name = msg_name = pb2._COMMONRESPONSE.full_name
response = pb2.CommonResponse()
response.ret = pb2.kErrorOther
response.message = "Error unknown on Presenter Server"
self.send_message(conn, response, msg_name)
def response_register_app():
message_head = CLIENT_SOCK.recv(5)
s = struct.Struct('Ib')
(message_len, messagename_len) = s.unpack(message_head)
message_len = socket.ntohl(message_len)
message_name = CLIENT_SOCK.recv(messagename_len)
message_body = CLIENT_SOCK.recv(message_len - 5 - messagename_len)
response = video_pb.CommonResponse()
response.ParseFromString(message_body)
if response.ret == video_pb.kErrorNone:
return True
return False
def _process_human_inference_result(self, conn, msg_data):
'''
Description: process human_inference_result message
Input:
conn: a socket connection
msg_data: message data.
Returns: True or False
'''
request = pb2.HumanInferenceResult()
response = pb2.CommonResponse()
msg_name = msg_name = pb2._COMMONRESPONSE.full_name
inference_dict = {}
if not self._parse_protobuf(request, msg_data):
self._response_error_unknown(conn)
return False
app_id = request.frame_index.app_id
channel_id = request.frame_index.channel_id
frame_id = request.frame_index.frame_id
object_id = request.object_id
if not self.app_manager.is_app_exist(app_id):
logging.error("app_id: %s not exist", app_id)
response.ret = pb2.kErrorAppLost
response.message = "app_id: %s not exist" % (app_id)
self.send_message(conn, response, msg_name)
return False
channel_dir = os.path.join(self.storage_dir, app_id, channel_id)
stack_list = os.listdir(channel_dir)
stack_list.sort()
current_stack = int(frame_id) // (MAX_SUB_DIRECTORY_NUM * FRAME_GAP)
stack_directory = "stack_{}/".format(current_stack)
object_dir = os.path.join(channel_dir, stack_directory, frame_id,
object_id)
inference_dict["property"] = {}
for item in request.human_property:
inference_dict["property"][item.key] = item.value
if not self._save_inference_result(object_dir, inference_dict):
self._response_error_unknown(conn)
return False
self.app_manager.set_heartbeat(conn.fileno())
response.ret = pb2.kErrorNone
response.message = "human inference process succeed"
self.send_message(conn, response, msg_name)
return True
def _process_image_set(self, conn, msg_data):
'''
Description: process image_set message
Input:
conn: a socket connection
msg_data: message data.
Returns: True or False
'''
request = pb2.ImageSet()
response = pb2.CommonResponse()
msg_name = msg_name = pb2._COMMONRESPONSE.full_name
if not self._parse_protobuf(request, msg_data):
self._response_error_unknown(conn)
return False
app_id = request.frame_index.app_id
channel_id = request.frame_index.channel_id
channel_name = request.frame_index.channel_name
frame_id = request.frame_index.frame_id
frame_image = request.frame_image
if not self.app_manager.is_app_exist(app_id):
logging.error("app_id: %s not exist", app_id)
response.ret = pb2.kErrorAppLost
response.message = "app_id: %s not exist" % (app_id)
self.send_message(conn, response, msg_name)
return False
frame_num = self.app_manager.get_frame_num(app_id, channel_id)
if frame_num % CHECK_INTERCAL == 0:
if self._remain_space() <= self.reserved_space:
logging.error("Insufficient storage space on Server.")
response.ret = pb2.kErrorStorageLimit
response.message = "Insufficient storage space on Server."
self.send_message(conn, response, msg_name)
return False
stack_index = frame_num // MAX_SUB_DIRECTORY_NUM
stack_directory = "stack_{}/".format(stack_index)
frame = stack_directory + frame_id
frame_dir = os.path.join(self.storage_dir, app_id, channel_id, frame)
if not self._save_image(frame_dir, frame_image):
self._response_error_unknown(conn)
logging.error("save_image: %s error.", frame_dir)
return False
app_dir = os.path.join(self.storage_dir, app_id)
self._save_channel_name(app_dir, channel_id, channel_name)
for i in request.object:
object_id = i.id
object_confidence = i.confidence
object_image = i.image
object_dir = os.path.join(frame_dir, object_id)
inference_dict = {"confidence": object_confidence}
if not self._save_image(object_dir, object_image) or \
not self._save_inference_result(object_dir, inference_dict):
self._response_error_unknown(conn)
logging.error("save image: %s error.", object_dir)
return False
self.app_manager.increase_frame_num(app_id, channel_id)
self.app_manager.set_heartbeat(conn.fileno())
response.ret = pb2.kErrorNone
response.message = "image set process succeed"
self.send_message(conn, response, msg_name)
return True
