def update_session(user_id, session_id, patch_doc, project_id=None):
if CONF.enable_v1_api:
valid_patch = utilsv1.SessionDoc.create_patch(patch_doc)
else:
valid_patch = utilsv2.SessionDoc.create_patch(patch_doc)
sessiont = get_session(project_id=project_id,
user_id=user_id,
session_id=session_id)
if not sessiont:
raise freezer_api_exc.DocumentNotFound(
message='Session not register with ID'
' {0}'.format(session_id))
values = {}
for key in valid_patch.keys():
if key == 'jobs':
jobintable = sessiont.get('jobs', None)
jobinpatch = valid_patch.get('jobs', None)
if jobintable:
jobintable.update(jobinpatch)
jobinpatch.update(jobintable)
values['job'] = json_utils.json_encode(valid_patch.get(key, None))
elif key == 'schedule':
values[key] = json_utils.json_encode(valid_patch.get(key, None))
else:
values[key] = valid_patch.get(key, None)
update_tuple(tablename=models.Session,
user_id=user_id,
tuple_id=session_id,
tuple_values=values,
project_id=project_id)
return 0
def update(self, session_id, session_update_doc):
# remove _version from the document
session_update_doc.pop('_version', 0)
update_doc = {"doc": session_update_doc}
try:
res = self.es.update(index=self.index,
doc_type=self.doc_type,
id=session_id,
body=update_doc)
version = res['_version']
self.es.indices.refresh(index=self.index)
except elasticsearch.TransportError as e:
if e.status_code == 409:
raise freezer_api_exc.DocumentExists(message=e.error)
raise freezer_api_exc.DocumentNotFound(
message=_i18n._('Unable to update session '
'%(id)s %(e)s') % {
'id': session_id,
'e': e
})
except Exception:
raise freezer_api_exc.StorageEngineError(
message=_i18n._('Unable to update session with id %s') %
session_id)
return version
def on_delete(self, req, resp, session_id):
# DELETE /v1/sessions/{session_id} Deletes the specified session
user_id = req.get_header('X-User-ID')
obj = self.db.get_session(user_id=user_id, session_id=session_id)
if not obj:
raise freezer_api_exc.DocumentNotFound(
message='No session found with ID:{0}'.format(session_id))
else:
self.db.delete_session(user_id=user_id, session_id=session_id)
resp.body = {'session_id': session_id}
resp.status = falcon.HTTP_204
def on_delete(self, req, resp, backup_id):
# DELETE /v1/backups/{backup_id} Deletes the specified backup
user_id = req.get_header('X-User-ID')
obj = self.db.get_backup(user_id=user_id, backup_id=backup_id)
if not obj:
raise freezer_api_exc.DocumentNotFound(
message='No Backup found with ID:{0}'.format(backup_id))
else:
self.db.delete_backup(user_id=user_id, backup_id=backup_id)
resp.body = {'backup_id': backup_id}
resp.status = falcon.HTTP_204
def on_delete(self, req, resp, job_id):
# DELETE /v1/jobs/{job_id} Deletes the specified job
user_id = req.get_header('X-User-ID')
obj = self.db.get_job(user_id=user_id, job_id=job_id)
if not obj:
raise freezer_api_exc.DocumentNotFound(
message='No Job found with ID:{0}'.format(job_id))
else:
self.db.delete_job(user_id=user_id, job_id=job_id)
resp.body = {'job_id': job_id}
resp.status = falcon.HTTP_204
def get(self, user_id, doc_id):
try:
res = self.es.get(index=self.index,
doc_type=self.doc_type,
id=doc_id)
doc = res['_source']
except elasticsearch.TransportError:
raise freezer_api_exc.DocumentNotFound(
message=_i18n._('No document found with ID %s') % doc_id)
except Exception as e:
raise freezer_api_exc.StorageEngineError(
message=_i18n._('Get operation failed: %s') % e)
if doc['user_id'] != user_id:
raise freezer_api_exc.AccessForbidden(
_i18n._("Document access forbidden"))
if '_version' in res:
doc['_version'] = res['_version']
return doc
def update(self, job_id, job_update_doc):
# remove _version from the document
job_update_doc.pop('_version', 0)
update_doc = {"doc": job_update_doc}
try:
res = self.es.update(index=self.index, doc_type=self.doc_type,
id=job_id, body=update_doc)
version = res['_version']
self.es.indices.refresh(index=self.index)
except elasticsearch.TransportError as e:
if e.status_code == 409:
raise freezer_api_exc.DocumentExists(message=e.error)
raise freezer_api_exc.DocumentNotFound(
message='Unable to find job to update with id'
' {0} {1}'.format(job_id, e))
except Exception:
raise freezer_api_exc.StorageEngineError(
message='Unable to update job with id {0}'.format(job_id))
return version
def update_tuple(tablename, user_id, tuple_id, tuple_values, project_id=None):
session = get_db_session()
with session.begin():
try:
query = model_query(session, tablename, project_id=project_id)
query = query.filter_by(user_id=user_id).filter_by(id=tuple_id)
result = query.update(tuple_values)
except Exception as e:
raise freezer_api_exc.StorageEngineError(
message='Mysql operation failed {0}'.format(e))
if not result:
raise freezer_api_exc.DocumentNotFound(
message='Tuple not registered with ID'
' {0} in Table{1} '.format(tuple_id, tablename))
else:
LOG.info('Tuple updated, tuple_id: {0}'.format(tuple_id))
return tuple_id
def get(self, project_id, doc_id, user_id=None):
try:
res = self.es.get(index=self.index,
doc_type=self.doc_type,
id=doc_id)
doc = res['_source']
except elasticsearch.TransportError:
raise freezer_api_exc.DocumentNotFound(
message='No document found with ID:{0}'.format(doc_id))
except Exception as e:
raise freezer_api_exc.StorageEngineError(
message='Get operation failed: {}'.format(e))
if doc['project_id'] != project_id:
raise freezer_api_exc.AccessForbidden("You are not allowed to"
" access")
if user_id:
if doc['user_id'] != user_id:
raise freezer_api_exc.AccessForbidden(
"Document access forbidden")
if '_version' in res:
doc['_version'] = res['_version']
return doc
def test_get_action_returns_none_when_action_not_found(self):
self.mock_db.get_action.side_effect = exceptions.DocumentNotFound(
'regular test failure')
result = self.resource.get_action('project-id', 'user-id', 'action-id')
self.assertIsNone(result)
def test_DocumentNotFound(self):
e = exceptions.DocumentNotFound(message='testing')
self.assertRaises(falcon.HTTPError, e.handle, self.ex, self.mock_req,
self.mock_req, None)
