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 _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 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 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())