def load_resource_list(res_type, limit={}):
session = db_session.get_session()
res_list = []
try:
res_cache = ResCache.get_res_cache()
# TODO: process parameter limit
all_resources = session.query(ModelResource).filter(ModelResource.type==res_type)
for res_item in all_resources:
res = res_cache.get(res_item, load_from_db=False)
if res is None:
ref_res = [ref.ref_resources_id for ref in res_item.ref_resources]
res = res_cache.create(id=res_item.id,
type=res_item.type,
name=res_item.name,
state=res_item.state,
ref_resources=ref_res)
res_cache.store(res, save_to_db=False)
res_list.append(res)
return res_list
except:
raise ValueError('invalid resource type: %s' % res_type)
def set_state(self, state):
session = db_session.get_session()
with session.begin():
self.model.state = state
session.add(self.model)
self._on_state_change()
def set_state(self, state):
session = db_session.get_session()
with session.begin():
self.model.state = state
session.add(self.model)
self._on_state_change()
def _load(self):
session = db_session.get_session(autocommit=False)
self.session = session
tasks = session.query(ModelTask).filter(ModelTask.state != STATE_SUCCESS)
for task in tasks:
self.tasks[task.id] = Task(task)
def _load(self):
session = db_session.get_session(autocommit=False)
self.session = session
tasks = session.query(ModelTask).filter(
ModelTask.state != STATE_SUCCESS)
for task in tasks:
self.tasks[task.id] = Task(task)
def __init__(self, model=None):
self.model = model
self.session = db_session.get_session(autocommit=False)
if self.model is None:
self._create()
self.job_list_mutex = threading.Lock()
self.job_list = []
self.wait_event = threading.Event()
self.wait_event.clear()
def get(self, task_id):
self.tasks_mutex.acquire()
task = self.tasks.get(task_id, None)
self.tasks_mutex.release()
if task == None:
session = db_session.get_session()
task_model = session.query(ModelTask).filter(ModelTask.id == task_id)
task = Task(task_model)
return task
def __init__(self, model=None):
self.model = model
self.session = db_session.get_session(autocommit=False)
if self.model is None:
self._create()
self.job_list_mutex = threading.Lock()
self.job_list = []
self.wait_event = threading.Event()
self.wait_event.clear()
def get(self, task_id):
self.tasks_mutex.acquire()
task = self.tasks.get(task_id, None)
self.tasks_mutex.release()
if task == None:
session = db_session.get_session()
task_model = session.query(ModelTask).filter(
ModelTask.id == task_id)
task = Task(task_model)
return task
def _create(self):
if self.worker is None:
raise TaskCreateError("No worker!")
session = db_session.get_session()
self.model = ModelSubTask()
self.model.parent_id = self.parent_task.get_id()
self.model.state = STATE_INITIAL
self.model.name = self.worker.__workername__
self.model.args = self.args
session.add(self.model)
session.commit()
def _create(self):
if self.worker is None:
raise TaskCreateError("No worker!")
session = db_session.get_session()
self.model = ModelSubTask()
self.model.parent_id = self.parent_task.get_id()
self.model.state = STATE_INITIAL
self.model.name = self.worker.__workername__
self.model.args = self.args
session.add(self.model)
session.commit()
def map_from_model(self):
session = db_session.get_session()
self.model_server = session.query(ModelServer).filter(
ModelServer.res_id == self.id).one()
if self.model_server is None:
raise ResourceNotExist(
"Server: id=%d, name=%s name does not exist!" %
(self.id, self['name']))
self.attributes['uuid'] = self.model_server.uuid
self.attributes['role'] = self.model_server.role
self.attributes['location'] = self.model_server.location
self.attributes[
'num_of_processor'] = self.model_server.num_of_processor
self.attributes[
'cores_of_per_processor'] = self.model_server.cores_of_per_processor
# TODO: features of processor
self.attributes['memory_size'] = self.model_server.memory_size
def __init__(self, app_name, log_file=None, level="DEBUG", use_db=False):
self.app_name = app_name
self.use_db = use_db
if self.use_db:
self.session = db_session.get_session()
self.level = LOG_LEVEL[level] if level in LOG_LEVEL else logging.DEBUG
self.logger = logging.getLogger(app_name)
if log_file is None:
self.log_handler = logging.StreamHandler(sys.stdout)
else:
self.log_handler = logging.FileHandler(log_file)
self.logger.setLevel(self.level)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
self.log_handler.setFormatter(formatter)
self.logger.addHandler(self.log_handler)
def load_resource_by_id(res_id):
session = db_session.get_session()
try:
res_cache = ResCache.get_res_cache()
model_res = session.query(ModelResource).filter(ModelResource.id==res_id).one()
ref_res = [ref.ref_resources_id for ref in model_res.ref_resources]
res = res_cache.create(id=model_res.id,
type=model_res.type,
name=model_res.name,
state=model_res.state,
ref_resources=ref_res)
if hasattr(res, 'set_common'):
res.set_common(model_res)
if hasattr(res, 'map_from_model'):
res.map_from_model()
return res
except:
raise ValueError("Invalid resource id: %d" % res_id)
def store_to_db(self):
session = db_session.get_session(autocommit=False)
is_new_res = True if self.id is None else False
try:
comm_model = self.store_common()
session.add(comm_model)
session.flush()
if is_new_res:
self.id = self.model_comm.id
models = []
models.extend(self.map_to_model())
# TODO: store all data
session.add_all(models)
session.flush()
_add, _del = self.store_relations()
if len(_add):
session.add(_add)
if len(_del):
session.query(ModelResourceRelations).filter(
ModelResourceRelations.res_id==self.id,
ModelResourceRelations.ref_resources_id.in_(_del)
).delete(synchronize_session=False)
session.flush()
session.commit()
except Exception as e:
session.rollback()
if is_new_res:
self.id = None
raise ResStoreError('Can not store resource(type: %s), error: %s!' % (self.type, str(e)))
def init():
db_session.get_session()
Base.metadata.create_all(db_engine.get_engine())
