def insert_summary_into_db(self, summary_data: dict):
try:
summary_model = self.get_dynamic_db_model(ComponentSummary,
self.job_id)
DB.create_tables([summary_model])
summary_obj = summary_model.get_or_none(
summary_model.f_job_id == self.job_id,
summary_model.f_component_name == self.component_name,
summary_model.f_role == self.role,
summary_model.f_party_id == self.party_id,
summary_model.f_task_id == self.task_id,
summary_model.f_task_version == self.task_version)
if summary_obj:
summary_obj.f_summary = serialize_b64(summary_data,
to_str=True)
summary_obj.f_update_time = current_timestamp()
summary_obj.save()
else:
self.get_dynamic_db_model(
ComponentSummary,
self.job_id).create(f_job_id=self.job_id,
f_component_name=self.component_name,
f_role=self.role,
f_party_id=self.party_id,
f_task_id=self.task_id,
f_task_version=self.task_version,
f_summary=serialize_b64(summary_data,
to_str=True),
f_create_time=current_timestamp())
except Exception as e:
schedule_logger(self.job_id).exception(
"An exception where querying summary job id: {} "
"component name: {} to database:\n{}".format(
self.job_id, self.component_name, e))
def resource_for_job(cls, job_id, role, party_id, operation_type):
operate_status = False
engine_name, cores, memory = cls.calculate_job_resource(job_id=job_id, role=role, party_id=party_id)
try:
with DB.atomic():
updates = {
Job.f_engine_type: EngineType.COMPUTING,
Job.f_engine_name: engine_name,
Job.f_cores: cores,
Job.f_memory: memory,
}
filters = [
Job.f_job_id == job_id,
Job.f_role == role,
Job.f_party_id == party_id,
]
if operation_type == ResourceOperation.APPLY:
updates[Job.f_remaining_cores] = cores
updates[Job.f_remaining_memory] = memory
updates[Job.f_resource_in_use] = True
updates[Job.f_apply_resource_time] = base_utils.current_timestamp()
filters.append(Job.f_resource_in_use == False)
elif operation_type == ResourceOperation.RETURN:
updates[Job.f_resource_in_use] = False
updates[Job.f_return_resource_time] = base_utils.current_timestamp()
filters.append(Job.f_resource_in_use == True)
operate = Job.update(updates).where(*filters)
record_status = operate.execute() > 0
if not record_status:
raise RuntimeError(f"record job {job_id} resource {operation_type} failed on {role} {party_id}")
filters, updates = cls.update_resource_sql(resource_model=EngineRegistry,
cores=cores,
memory=memory,
operation_type=operation_type,
)
filters.append(EngineRegistry.f_engine_type == EngineType.COMPUTING)
filters.append(EngineRegistry.f_engine_name == engine_name)
operate = EngineRegistry.update(updates).where(*filters)
apply_status = operate.execute() > 0
if not apply_status:
raise RuntimeError(
f"{operation_type} resource from engine {engine_name} for job {job_id} resource {operation_type} failed on {role} {party_id}")
operate_status = True
except Exception as e:
schedule_logger(job_id=job_id).warning(e)
schedule_logger(job_id=job_id).warning(
f"{operation_type} job {job_id} resource(cores {cores} memory {memory}) on {role} {party_id} failed")
operate_status = False
finally:
remaining_cores, remaining_memory = cls.get_remaining_resource(EngineRegistry,
[
EngineRegistry.f_engine_type == EngineType.COMPUTING,
EngineRegistry.f_engine_name == engine_name])
operate_msg = "successfully" if operate_status else "failed"
schedule_logger(job_id=job_id).info(
f"{operation_type} job {job_id} resource(cores {cores} memory {memory}) on {role} {party_id} {operate_msg}, remaining cores: {remaining_cores} remaining memory: {remaining_memory}")
return operate_status
class Tag(DataBaseModel):
f_id = BigAutoField(primary_key=True)
f_name = CharField(max_length=100, index=True, unique=True)
f_desc = TextField(null=True)
f_create_time = BigIntegerField(default=current_timestamp())
f_update_time = BigIntegerField(default=current_timestamp())
class Meta:
db_table = "t_tags"
def ready_signal(cls, job_id, set_or_reset: bool, ready_timeout_ttl=None):
filters = [Job.f_job_id == job_id]
if set_or_reset:
update_fields = {Job.f_ready_signal: True, Job.f_ready_time: current_timestamp()}
filters.append(Job.f_ready_signal == False)
else:
update_fields = {Job.f_ready_signal: False, Job.f_ready_time: None}
filters.append(Job.f_ready_signal == True)
if ready_timeout_ttl:
filters.append(current_timestamp() - Job.f_ready_time > ready_timeout_ttl)
update_status = Job.update(update_fields).where(*filters).execute() > 0
return update_status
class ModelOperationLog(DataBaseModel):
f_operation_type = CharField(max_length=20, null=False, index=True)
f_operation_status = CharField(max_length=20, null=True, index=True)
f_initiator_role = CharField(max_length=50, index=True, null=True)
f_initiator_party_id = CharField(max_length=10, index=True, null=True)
f_request_ip = CharField(max_length=20, null=True)
f_model_id = CharField(max_length=100, index=True)
f_model_version = CharField(max_length=100, index=True)
f_create_time = BigIntegerField(default=current_timestamp())
f_update_time = BigIntegerField(default=current_timestamp())
class Meta:
db_table = "t_model_operation_log"
def start_job(cls, job_id, initiator_role, initiator_party_id):
schedule_logger(job_id=job_id).info(
"try to start job {} on initiator {} {}".format(
job_id, initiator_role, initiator_party_id))
job_info = {}
job_info["job_id"] = job_id
job_info["role"] = initiator_role
job_info["party_id"] = initiator_party_id
job_info["status"] = JobStatus.RUNNING
job_info["party_status"] = JobStatus.RUNNING
job_info["start_time"] = current_timestamp()
job_info["tag"] = 'end_waiting'
jobs = JobSaver.query_job(job_id=job_id,
role=initiator_role,
party_id=initiator_party_id)
if jobs:
job = jobs[0]
FederatedScheduler.start_job(job=job)
schedule_logger(job_id=job_id).info(
"start job {} on initiator {} {}".format(
job_id, initiator_role, initiator_party_id))
else:
schedule_logger(job_id=job_id).error(
"can not found job {} on initiator {} {}".format(
job_id, initiator_role, initiator_party_id))
def create(self):
table_meta = StorageTableMetaModel()
table_meta.f_create_time = current_timestamp()
table_meta.f_schema = {}
table_meta.f_part_of_data = []
for k, v in self.to_dict().items():
attr_name = 'f_%s' % k
if hasattr(StorageTableMetaModel, attr_name):
setattr(
table_meta, attr_name,
v if not issubclass(type(v), AddressABC) else v.__dict__)
try:
rows = table_meta.save(force_insert=True)
if rows != 1:
raise Exception("create table meta failed")
except peewee.IntegrityError as e:
if e.args[0] == 1062:
# warning
pass
elif isinstance(e.args[0],
str) and "UNIQUE constraint failed" in e.args[0]:
pass
else:
raise e
except Exception as e:
raise e
def insert_metrics_into_db(self,
metric_namespace: str,
metric_name: str,
data_type: int,
kv,
job_level=False):
try:
tracking_metric = self.get_dynamic_db_model(
TrackingMetric, self.job_id)()
tracking_metric.f_job_id = self.job_id
tracking_metric.f_component_name = (
self.component_name
if not job_level else job_utils.job_virtual_component_name())
tracking_metric.f_task_id = self.task_id
tracking_metric.f_task_version = self.task_version
tracking_metric.f_role = self.role
tracking_metric.f_party_id = self.party_id
tracking_metric.f_metric_namespace = metric_namespace
tracking_metric.f_metric_name = metric_name
tracking_metric.f_type = data_type
default_db_source = tracking_metric.to_json()
tracking_metric_data_source = []
for k, v in kv:
db_source = default_db_source.copy()
db_source['f_key'] = serialize_b64(k)
db_source['f_value'] = serialize_b64(v)
db_source['f_create_time'] = current_timestamp()
tracking_metric_data_source.append(db_source)
self.bulk_insert_into_db(
self.get_dynamic_db_model(TrackingMetric, self.job_id),
tracking_metric_data_source)
except Exception as e:
schedule_logger(self.job_id).exception(
"An exception where inserted metric {} of metric namespace: {} to database:\n{}"
.format(metric_name, metric_namespace, e))
def update_entity_table(cls, entity_model, entity_info):
query_filters = []
primary_keys = entity_model.get_primary_keys_name()
for p_k in primary_keys:
query_filters.append(
operator.attrgetter(p_k)(entity_model) == entity_info[
p_k.lstrip("f").lstrip("_")])
objs = entity_model.select().where(*query_filters)
if objs:
obj = objs[0]
else:
raise Exception("can not found the {}".format(
entity_model.__class__.__name__))
update_filters = query_filters[:]
update_info = {}
update_info.update(entity_info)
for _ in cls.STATUS_FIELDS:
# not allow update status fields by this function
update_info.pop(_, None)
if update_info.get("tag") == "job_end" and hasattr(
entity_model, "f_tag"):
if obj.f_start_time:
update_info["end_time"] = current_timestamp()
update_info[
'elapsed'] = update_info['end_time'] - obj.f_start_time
if update_info.get("progress") and hasattr(
entity_model, "f_progress") and update_info["progress"] > 0:
update_filters.append(
operator.attrgetter("f_progress")
(entity_model) <= update_info["progress"])
return cls.execute_update(old_obj=obj,
model=entity_model,
update_info=update_info,
update_filters=update_filters)
def save_model_info(model_info):
model = MLModel()
model.f_create_time = current_timestamp()
for k, v in model_info.items():
attr_name = 'f_%s' % k
if hasattr(MLModel, attr_name):
setattr(model, attr_name, v)
elif hasattr(MLModel, k):
setattr(model, k, v)
try:
rows = model.save(force_insert=True)
if rows != 1:
raise Exception("Save to database failed")
except peewee.IntegrityError as e:
if e.args[0] != 1062:
raise Exception("Create {} failed:\n{}".format(MLModel, e))
sql_logger(job_id=model_info.get("job_id", "fate_flow")).warning(e)
return
except Exception as e:
raise Exception("Create {} failed:\n{}".format(MLModel, e))
RuntimeConfig.SERVICE_DB.register_model(
gen_party_model_id(role=model.f_role,
party_id=model.f_party_id,
model_id=model.f_model_id), model.f_model_version)
return model
def detect_expired_session(cls):
ttl = SESSION_VALID_PERIOD
detect_logger().info(
f'start detect expired session by ttl {ttl/1000} s')
try:
session_records = Session.query_sessions(
create_time=[None, current_timestamp() - ttl])
manager_session_id_list = []
for session_record in session_records:
manager_session_id = session_record.f_manager_session_id
if manager_session_id not in manager_session_id:
continue
manager_session_id_list.append(manager_session_id)
detect_logger().info(
f'start destroy session {manager_session_id}')
try:
sess = Session(session_id=manager_session_id,
options={"logger": detect_logger()})
sess.destroy_all_sessions()
except Exception as e:
detect_logger().error(
f'stop session {manager_session_id} error', e)
finally:
detect_logger().info(
f'stop session {manager_session_id} successfully')
except Exception as e:
detect_logger().error('detect expired session error', e)
finally:
detect_logger().info('finish detect expired session')
def save(self, *args, **kwargs):
if hasattr(self, "f_update_date"):
self.f_update_date = datetime.datetime.now()
if hasattr(self, "f_update_time"):
self.f_update_time = current_timestamp()
return super(DataBaseModel, self).save(*args, **kwargs)
def save(self, *args, **kwargs):
if self.f_create_time:
self.f_create_date = timestamp_to_date(self.f_create_time)
self.f_update_time = current_timestamp()
self.f_update_date = timestamp_to_date(self.f_update_time)
return super(BaseModel, self).save(*args, **kwargs)
def save_model_info(model_info):
model = MLModel()
model.f_create_time = current_timestamp()
for k, v in model_info.items():
attr_name = 'f_%s' % k
if hasattr(MLModel, attr_name):
setattr(model, attr_name, v)
elif hasattr(MLModel, k):
setattr(model, k, v)
try:
rows = model.save(force_insert=True)
if rows != 1:
raise Exception("Create {} failed".format(MLModel))
if RuntimeConfig.zk_client is not None:
ServiceUtils.register(
RuntimeConfig.zk_client,
gen_party_model_id(role=model.f_role,
party_id=model.f_party_id,
model_id=model.f_model_id),
model.f_model_version)
return model
except peewee.IntegrityError as e:
if e.args[0] == 1062:
sql_logger(job_id=model_info.get("job_id", "fate_flow")).warning(e)
else:
raise Exception("Create {} failed:\n{}".format(MLModel, e))
except Exception as e:
raise Exception("Create {} failed:\n{}".format(MLModel, e))
def register_engine(cls, engine_type, engine_name, engine_entrance,
engine_config):
nodes = engine_config.get("nodes", 1)
cores = engine_config.get(
"cores_per_node",
0) * nodes * JobDefaultConfig.total_cores_overweight_percent
memory = engine_config.get(
"memory_per_node",
0) * nodes * JobDefaultConfig.total_memory_overweight_percent
filters = [
EngineRegistry.f_engine_type == engine_type,
EngineRegistry.f_engine_name == engine_name
]
resources = EngineRegistry.select().where(*filters)
if resources:
resource = resources[0]
update_fields = {}
update_fields[EngineRegistry.f_engine_config] = engine_config
update_fields[EngineRegistry.f_cores] = cores
update_fields[EngineRegistry.f_memory] = memory
update_fields[
EngineRegistry.
f_remaining_cores] = EngineRegistry.f_remaining_cores + (
cores - resource.f_cores)
update_fields[
EngineRegistry.
f_remaining_memory] = EngineRegistry.f_remaining_memory + (
memory - resource.f_memory)
update_fields[EngineRegistry.f_nodes] = nodes
operate = EngineRegistry.update(update_fields).where(*filters)
update_status = operate.execute() > 0
if update_status:
stat_logger.info(
f"update {engine_type} engine {engine_name} {engine_entrance} registration information"
)
else:
stat_logger.info(
f"update {engine_type} engine {engine_name} {engine_entrance} registration information takes no effect"
)
else:
resource = EngineRegistry()
resource.f_create_time = base_utils.current_timestamp()
resource.f_engine_type = engine_type
resource.f_engine_name = engine_name
resource.f_engine_entrance = engine_entrance
resource.f_engine_config = engine_config
resource.f_cores = cores
resource.f_memory = memory
resource.f_remaining_cores = cores
resource.f_remaining_memory = memory
resource.f_nodes = nodes
try:
resource.save(force_insert=True)
except Exception as e:
stat_logger.warning(e)
stat_logger.info(
f"create {engine_type} engine {engine_name} {engine_entrance} registration information"
)
def run(self, **kwargs):
result = {}
code = 0
message = ""
start_time = current_timestamp()
self.run_pid = os.getpid()
try:
self.args = self.get_args(**kwargs)
RuntimeConfig.init_env()
RuntimeConfig.set_process_role(ProcessRole(os.getenv("PROCESS_ROLE")))
if RuntimeConfig.PROCESS_ROLE == ProcessRole.WORKER:
LoggerFactory.LEVEL = logging.getLevelName(os.getenv("FATE_LOG_LEVEL", "INFO"))
LoggerFactory.set_directory(directory=self.args.log_dir, parent_log_dir=self.args.parent_log_dir,
append_to_parent_log=True, force=True)
LOGGER.info(f"enter {self.__class__.__name__} worker in subprocess, pid: {self.run_pid}")
else:
LOGGER.info(f"enter {self.__class__.__name__} worker in driver process, pid: {self.run_pid}")
LOGGER.info(f"log level: {logging.getLevelName(LoggerFactory.LEVEL)}")
for env in {"VIRTUAL_ENV", "PYTHONPATH", "SPARK_HOME", "FATE_DEPLOY_BASE", "PROCESS_ROLE", "FATE_JOB_ID"}:
LOGGER.info(f"{env}: {os.getenv(env)}")
if self.args.job_server:
RuntimeConfig.init_config(JOB_SERVER_HOST=self.args.job_server.split(':')[0],
HTTP_PORT=self.args.job_server.split(':')[1])
if not RuntimeConfig.LOAD_COMPONENT_REGISTRY:
ComponentRegistry.load()
if not RuntimeConfig.LOAD_CONFIG_MANAGER:
ConfigManager.load()
result = self._run()
except Exception as e:
LOGGER.exception(e)
traceback.print_exc()
try:
self._handle_exception()
except Exception as e:
LOGGER.exception(e)
code = 1
message = exception_to_trace_string(e)
finally:
if self.args and self.args.result:
dump_json_conf(result, self.args.result)
end_time = current_timestamp()
LOGGER.info(f"worker {self.__class__.__name__}, process role: {RuntimeConfig.PROCESS_ROLE}, pid: {self.run_pid}, elapsed: {end_time - start_time} ms")
if RuntimeConfig.PROCESS_ROLE == ProcessRole.WORKER:
sys.exit(code)
else:
return code, message, result
def check_job_is_timeout(job: Job):
job_parameters = job.f_runtime_conf_on_party["job_parameters"]
timeout = job_parameters.get("timeout", JOB_DEFAULT_TIMEOUT)
now_time = current_timestamp()
running_time = (now_time - job.f_create_time)/1000
if running_time > timeout:
schedule_logger(job_id=job.f_job_id).info('job {} run time {}s timeout'.format(job.f_job_id, running_time))
return True
else:
return False
def check_job_is_timeout(job: Job):
job_parameters = job.f_runtime_conf_on_party["job_parameters"]
timeout = job_parameters.get("timeout", JobDefaultConfig.job_timeout)
now_time = current_timestamp()
running_time = (now_time - job.f_create_time) / 1000
if running_time > timeout:
schedule_logger(job.f_job_id).info(f'run time {running_time}s timeout')
return True
else:
return False
def create_task(cls, role, party_id, run_on_this_party, task_info):
task_info["role"] = role
task_info["party_id"] = party_id
task_info["status"] = TaskStatus.WAITING
task_info["party_status"] = TaskStatus.WAITING
task_info["create_time"] = base_utils.current_timestamp()
task_info["run_on_this_party"] = run_on_this_party
if "task_id" not in task_info:
task_info["task_id"] = job_utils.generate_task_id(job_id=task_info["job_id"], component_name=task_info["component_name"])
if "task_version" not in task_info:
task_info["task_version"] = 0
JobSaver.create_task(task_info=task_info)
def create_or_update(self):
defaults = {
"f_name": self.name,
"f_engine": self.engine,
"f_connector_info": self.connector_info,
"f_create_time": current_timestamp(),
}
connector, status = StorageConnectorModel.get_or_create(
f_name=self.name, defaults=defaults)
if status is False:
for key in defaults:
setattr(connector, key, defaults[key])
connector.save(force_insert=False)
def update(cls, __data=None, **update):
if __data:
if hasattr(cls, "f_update_time"):
__data[operator.attrgetter("f_update_time")(cls)] = current_timestamp()
fields = AUTO_DATE_TIMESTAMP_FIELD_PREFIX.copy()
# create can not be updated
fields.remove("create")
for f_n in fields:
if hasattr(cls, f"f_{f_n}_time") and hasattr(cls, f"f_{f_n}_date"):
k = operator.attrgetter(f"f_{f_n}_time")(cls)
if k in __data and __data[k]:
__data[operator.attrgetter(f"f_{f_n}_date")(cls)] = timestamp_to_date(__data[k])
return super().update(__data, **update)
def start_job(cls, job_id, role, party_id, extra_info=None):
schedule_logger(job_id=job_id).info(f"try to start job {job_id} on {role} {party_id}")
job_info = {
"job_id": job_id,
"role": role,
"party_id": party_id,
"status": JobStatus.RUNNING,
"start_time": current_timestamp()
}
if extra_info:
schedule_logger(job_id=job_id).info(f"extra info: {extra_info}")
job_info.update(extra_info)
cls.update_job_status(job_info=job_info)
cls.update_job(job_info=job_info)
schedule_logger(job_id=job_id).info(f"start job {job_id} on {role} {party_id} successfully")
def check_job_is_timeout(job):
job_dsl, job_runtime_conf, train_runtime_conf = get_job_configuration(
job_id=job.f_job_id,
role=job.f_initiator_role,
party_id=job.f_initiator_party_id)
job_parameters = job_runtime_conf.get('job_parameters', {})
timeout = job_parameters.get("timeout", JOB_DEFAULT_TIMEOUT)
now_time = current_timestamp()
running_time = (now_time - job.f_create_time) / 1000
if running_time > timeout:
schedule_logger(job_id=job.f_job_id).info(
'job {} run time {}s timeout'.format(job.f_job_id, running_time))
return True
else:
return False
def federated_command(cls, job_id, src_role, src_party_id, dest_role,
dest_party_id, endpoint, body, federated_mode,
federated_response):
st = base_utils.current_timestamp()
log_msg = f"sending {endpoint} federated command"
schedule_logger(job_id).info(start_log(msg=log_msg))
try:
response = federated_api(job_id=job_id,
method='POST',
endpoint=endpoint,
src_role=src_role,
src_party_id=src_party_id,
dest_party_id=dest_party_id,
json_body=body if body else {},
federated_mode=federated_mode)
except Exception as e:
schedule_logger(job_id=job_id).exception(e)
response = {
"retcode": RetCode.FEDERATED_ERROR,
"retmsg": "Federated schedule error, {}".format(e)
}
if response["retcode"] != RetCode.SUCCESS:
if response["retcode"] in [RetCode.NOT_EFFECTIVE, RetCode.RUNNING]:
schedule_logger(job_id).warning(
warning_log(msg=log_msg,
role=dest_role,
party_id=dest_party_id))
else:
schedule_logger(job_id).error(
failed_log(msg=log_msg,
role=dest_role,
party_id=dest_party_id,
detail=response["retmsg"]))
federated_response[dest_role][dest_party_id] = response
et = base_utils.current_timestamp()
schedule_logger(job_id).info(f"{log_msg} use {et - st} ms")
def __enter__(self):
with DB.connection_context():
session_record = SessionRecord()
session_record.f_session_id = self._session_id
session_record.f_engine_name = self._engine_name
session_record.f_engine_type = EngineType.STORAGE
# TODO: engine address
session_record.f_engine_address = {}
session_record.f_create_time = current_timestamp()
rows = session_record.save(force_insert=True)
if rows != 1:
raise Exception(
f"create session record {self._session_id} failed")
LOGGER.debug(f"save session {self._session_id} record")
self.create()
return self
def create_task(cls, role, party_id, run_on_this_party, task_info):
task_info["role"] = role
task_info["party_id"] = str(party_id)
task_info["status"] = TaskStatus.WAITING
task_info["party_status"] = TaskStatus.WAITING
task_info["create_time"] = base_utils.current_timestamp()
task_info["run_on_this_party"] = run_on_this_party
if task_info.get("task_id") is None:
task_info["task_id"] = job_utils.generate_task_id(
job_id=task_info["job_id"],
component_name=task_info["component_name"])
if task_info.get("task_version") is None:
task_info["task_version"] = 0
task = JobSaver.create_task(task_info=task_info)
if task and run_on_this_party:
job_utils.save_task_using_job_conf(task)
def create_job_family_entity(cls, entity_model, entity_info):
obj = entity_model()
obj.f_create_time = current_timestamp()
for k, v in entity_info.items():
attr_name = 'f_%s' % k
if hasattr(entity_model, attr_name):
setattr(obj, attr_name, v)
try:
rows = obj.save(force_insert=True)
if rows != 1:
raise Exception("Create {} failed".format(entity_model))
except peewee.IntegrityError as e:
if e.args[0] == 1062:
sql_logger(job_id=entity_info.get("job_id", "fate_flow")).warning(e)
else:
raise Exception("Create {} failed:\n{}".format(entity_model, e))
except Exception as e:
raise Exception("Create {} failed:\n{}".format(entity_model, e))
def save_worker_info(cls, task: Task, worker_name: WorkerName, worker_id,
**kwargs):
worker = WorkerInfo()
ignore_attr = auto_date_timestamp_db_field()
for attr, value in task.to_dict().items():
if hasattr(worker,
attr) and attr not in ignore_attr and value is not None:
setattr(worker, attr, value)
worker.f_create_time = current_timestamp()
worker.f_worker_name = worker_name.value
worker.f_worker_id = worker_id
for k, v in kwargs.items():
attr = f"f_{k}"
if hasattr(worker, attr) and v is not None:
setattr(worker, attr, v)
rows = worker.save(force_insert=True)
if rows != 1:
raise Exception("save worker info failed")
def store(self, model_id: str, model_version: str, store_address: dict, force_update: bool = False):
"""
Store the model from local cache to mysql
:param model_id:
:param model_version:
:param store_address:
:param force_update:
:return:
"""
try:
self.get_connection(config=store_address)
DB.create_tables([MachineLearningModel])
model = PipelinedModel(model_id=model_id, model_version=model_version)
LOGGER.info("start store model {} {}".format(model_id, model_version))
with DB.connection_context():
with open(model.packaging_model(), "rb") as fr:
slice_index = 0
while True:
content = fr.read(SLICE_MAX_SIZE)
if content:
model_in_table = MachineLearningModel()
model_in_table.f_create_time = current_timestamp()
model_in_table.f_model_id = model_id
model_in_table.f_model_version = model_version
model_in_table.f_content = serialize_b64(content, to_str=True)
model_in_table.f_size = sys.getsizeof(model_in_table.f_content)
model_in_table.f_slice_index = slice_index
if force_update:
model_in_table.save(only=[MachineLearningModel.f_content, MachineLearningModel.f_size,
MachineLearningModel.f_update_time, MachineLearningModel.f_slice_index])
LOGGER.info("update model {} {} slice index {} content".format(model_id, model_version, slice_index))
else:
model_in_table.save(force_insert=True)
slice_index += 1
LOGGER.info("insert model {} {} slice index {} content".format(model_id, model_version, slice_index))
else:
break
LOGGER.info("Store model {} {} to mysql successfully".format(model_id, model_version))
self.close_connection()
except Exception as e:
LOGGER.exception(e)
raise Exception("Store model {} {} to mysql failed".format(model_id, model_version))
def save_machine_learning_model_info(self):
try:
record = MLModel.get_or_none(
MLModel.f_model_version == self.job_id)
if not record:
job = Job.get_or_none(Job.f_job_id == self.job_id)
if job:
job_data = job.to_json()
MLModel.create(
f_role=self.role,
f_party_id=self.party_id,
f_roles=job_data.get("f_roles"),
f_model_id=self.model_id,
f_model_version=self.model_version,
f_job_id=job_data.get("f_job_id"),
f_create_time=current_timestamp(),
f_initiator_role=job_data.get('f_initiator_role'),
f_initiator_party_id=job_data.get(
'f_initiator_party_id'),
f_runtime_conf=job_data.get('f_runtime_conf'),
f_work_mode=job_data.get('f_work_mode'),
f_dsl=job_data.get('f_dsl'),
f_train_runtime_conf=job_data.get(
'f_train_runtime_conf'),
f_size=self.get_model_size(),
f_job_status=job_data.get('f_status'))
schedule_logger(self.job_id).info(
'save {} model info done. model id: {}, model version: {}.'
.format(self.job_id, self.model_id,
self.model_version))
else:
schedule_logger(self.job_id).info(
'save {} model info failed, no job found in db. '
'model id: {}, model version: {}.'.format(
self.job_id, self.model_id, self.model_version))
else:
schedule_logger(self.job_id).info(
'model {} info has already existed in database.'.format(
self.job_id))
except Exception as e:
schedule_logger(self.job_id).exception(e)