def _get_job(experiment, job_sequence):
try:
job = ExperimentJob.objects.get(experiment=experiment, sequence=job_sequence)
except (ExperimentJob.DoesNotExist, ValidationError):
logger.info('Job with experiment:`{}` sequence:`{}` does not exist'.format(
experiment.unique_name, job_sequence))
raise exceptions.NotFound('Experiment was not found')
if not job.is_running:
logger.info('Job with experiment:`{}` sequence:`{}` is not currently running'.format(
experiment.unique_name, job_sequence))
raise exceptions.NotFound('Job was not running')
return job
def _get_job(experiment, job_id):
try:
job = ExperimentJob.objects.get(experiment=experiment, id=job_id)
except (ExperimentJob.DoesNotExist, ValidationError):
_logger.info('Job with experiment:`%s` id:`%s` does not exist',
experiment.unique_name, job_id)
raise exceptions.NotFound('Experiment was not found')
if not job.is_running:
_logger.info(
'Job with experiment:`%s` id:`%s` is not currently running',
experiment.unique_name, job_id)
raise exceptions.NotFound('Job was not running')
return job
async def get(self, _, id: str):
with db_session:
try:
c = Community[id]
return response.json(c.to_dict())
except (ObjectNotFound, ValueError) as _:
pass # try it as a slug
try:
c = Community.get(slug=id)
if c is None:
raise exceptions.NotFound(
"Community {} not found".format(id))
return response.json(c.to_dict())
except ObjectNotFound:
raise exceptions.NotFound("Community {} not found".format(id))
def _handle_request(self, request, req_path):
"""Listen to get requests"""
css = self._web_compile(request.path)
if css is None:
raise exceptions.NotFound(f"{req_path} not found.", False)
return response.text(css, content_type="text/css ")
async def wrapper(request, *args, **kwargs):
user = await User.find_one(dict(name=kwargs["user"].lower()))
if not user:
raise exceptions.NotFound("User not found")
kwargs["user"] = user
return await handler(request, *args, **kwargs)
async def patch(self, request, id):
with db_session:
try:
c = Community[id]
if 'slug' in request.json:
c.slug = request.json['slug']
if 'name' in request.json:
c.name = request.json['name']
if 'description' in request.json:
c.description = request.json['description']
if 'icon' in request.json:
c.icon = request.json['icon']
if 'owner' in request.json:
c.owner = request.json['owner']
if 'tags' in request.json:
c.tags.clear()
for tag_name in request.json['tags']:
try:
tag = Tag[tag_name]
except ObjectNotFound:
tag = Tag(tag=tag_name)
c.tags.add(tag)
commit()
return response.json(c.to_dict())
except ObjectNotFound:
raise exceptions.NotFound("Community {} not found".format(id))
def _get_validated_experiment(project, experiment_sequence):
experiment = _get_experiment(project, experiment_sequence)
if not experiment.is_running:
_logger.info('Experiment project `%s` num `%s` is not currently running',
project.name, experiment.sequence)
raise exceptions.NotFound('Experiment was not running')
return experiment
async def wrapper(request, *args, **kwargs):
data = await Outbox.find_one(dict(user_id=kwargs["user"].name, _id=kwargs["entity"]))
if not data:
raise exceptions.NotFound("Object not found")
kwargs["entity"] = data
return await handler(request, *args, **kwargs)
def _get_running_experiment(project, experiment_id):
experiment = _get_experiment(project, experiment_id)
if not experiment.is_running:
_logger.info('Experiment project `%s` is not currently running',
experiment.unique_name)
raise exceptions.NotFound('Experiment was not running')
return experiment
async def remove_command(request):
command_name = request.json['name']
try:
await db.delete(command_name)
except KeyError:
raise exceptions.NotFound('Command not found')
return response.json({'success': True})
async def delete(self, _, id):
with db_session:
try:
c = Community[id]
c.delete()
commit()
except ObjectNotFound:
raise exceptions.NotFound("Community {} not found".format(id))
return response.text('', status=204)
async def delete_todo_item(request, todo_pk):
try:
# Try to fetch the item from collection to assert it exists.
assert collection[uuid.UUID(todo_pk)]
request.app.loop.call_later(
randint(50, 5000) / 1000, _update_data, uuid.UUID(todo_pk), None)
except KeyError:
raise exceptions.NotFound("Task was not found")
return response.text('', status=HTTPStatus.ACCEPTED)
async def get_image_route(request, img_id):
try:
indexed_image = await IndexedImage.load_from_index_async(
app.index_redis, img_id)
except KeyError as e:
if e.args[0].startswith("No image"):
raise exceptions.NotFound("No image " + str(img_id) + " in index")
else:
raise e
img_path = await load_indexed_image(app, indexed_image)
_, ext = osp.splitext(img_path)
return await response.file_stream(img_path, mime_type=image_types[ext[1:]])
async def handler(self, request, server, sid, tid):
if tid not in self.handlers or tid in self.disable_transports:
raise exceptions.NotFound("SockJS transport handler not found.")
create, transport = self.handlers[tid]
# session
manager = self.manager
if not manager.started:
manager.start()
if not sid or "." in sid or "." in server:
raise exceptions.NotFound("SockJS bad route")
try:
session = manager.get(sid, create, request=request)
except KeyError:
return response.HTTPResponse(None,
status=404,
headers=session_cookie(request))
t = transport(manager, session, request)
try:
return await t.process()
except asyncio.CancelledError:
raise
except exceptions.SanicException as exc:
msg = "Server Exception in Transport handler: %s" % str(exc)
log.exception(msg)
raise
except Exception:
msg = "Exception in transport: %s" % tid
log.exception(msg)
if manager.is_acquired(session):
await manager.release(session)
raise exceptions.ServerError(msg)
async def get_todo_item(request, todo_pk):
# Initialize the output schema.
output_schema = TaskView()
# Get the item.
try:
item = collection[uuid.UUID(todo_pk)]
except KeyError:
raise exceptions.NotFound("Task was not found")
return response.json(output_schema.dump({
**item,
'url':
get_absolute_url(request, 'get_todo_item', todo_pk=item['uuid']),
}),
status=HTTPStatus.OK,
escape_forward_slashes=False)
async def get_index_data(request, img_id):
try:
indexed_image = await IndexedImage.load_from_index_async(
app.index_redis, img_id)
except KeyError as e:
if e.args[0].startswith("No image"):
raise exceptions.NotFound("No image " + str(img_id) + " in index")
else:
raise e
data = {
"img_id": str(indexed_image.img_id),
"imhash": base64.b64encode(indexed_image.imhash),
"cache_path": "image/" + indexed_image.cache_filename,
}
data.update(attr.asdict(indexed_image.queued_img_data))
return response.json(data)
async def token_get(request):
user = await User.find_one(
dict(name=request.json["username"].lower().lstrip('@')))
if not user:
raise exceptions.NotFound("User not found")
if not check_password_hash(user.password, request.json["password"]):
return response.json({"error": "password incorrect"}, status=401)
token = getattr(user, "token")
if not token:
token = random_object_id()
#TODO make token expire
await User.update_one({'name': request.json["username"]},
{'$set': {
'token': token
}})
return response.json({'access_token': token})
async def set_todo_item_status(request, todo_pk):
# Initialize command schema.
command_schema = Command()
# Initialize output schema.
output_schema = TaskView()
try:
item = collection[uuid.UUID(todo_pk)]
except KeyError:
raise exceptions.NotFound("Task was not found")
command = command_schema.load(request.json).get('command')
# Populate `data` variable to ensure it exists, should
# the command handling conditional logic be skipped.
data = item
if command == 'complete' and not item['is_completed']:
data = {**item, 'is_completed': True, 'completed_at': datetime.now()}
elif command == 'revert' and item['is_completed']:
data = {
**item,
'is_completed': False,
'completed_at': None,
}
if item != data:
# Data was modified. Store it.
request.app.loop.call_later(
randint(50, 5000) / 1000, _update_data, data['uuid'], data)
return response.json(output_schema.dump({
**data,
'url':
get_absolute_url(request, 'get_todo_item', todo_pk=data['uuid']),
}),
status=HTTPStatus.ACCEPTED,
escape_forward_slashes=False)
else:
# Return empty response, since nothing was modified.
return response.text('', status=HTTPStatus.NO_CONTENT)
async def update_todo_item(request, todo_pk):
# Initialize the input schema.
input_schema = Task(exclude=('created_at', 'completed_at', 'uuid',
'is_completed'))
store_schema = Task()
# Initialize the output schema.
output_schema = TaskView()
try:
# Validate the data.
data = input_schema.load(request.json)
item = collection[uuid.UUID(todo_pk)]
data = store_schema.dump({
**item,
**data,
})
data = store_schema.load(data)
except KeyError:
raise exceptions.NotFound("Task was not found")
if data != item:
# Data was modified. Store it.
request.app.loop.call_later(
randint(50, 5000) / 1000, _update_data, item['uuid'], data)
return response.json(output_schema.dump({
**data,
'url':
get_absolute_url(request, 'get_todo_item', todo_pk=data['uuid']),
}),
status=HTTPStatus.ACCEPTED,
escape_forward_slashes=False)
else:
# Return empty response, since nothing was modified.
return response.text('', status=HTTPStatus.NO_CONTENT)
def _get_experiment(project, experiment_sequence):
try:
return Experiment.objects.get(project=project,
sequence=experiment_sequence)
except (Experiment.DoesNotExist, ValidationError):
raise exceptions.NotFound('Experiment was not found')
def _get_project(username, project_name):
try:
return Project.objects.get(name=project_name, user__username=username)
except Project.DoesNotExist:
raise exceptions.NotFound('Project was not found')
async def handle_path(request, path):
# make sure we aren't serving up paths from outside of the current directory
# eg prevents curl 'http://127.0.0.1:8000/%2e%2e/' serving up the parent directory
current_directory = os.path.realpath('.')
full_path = os.path.realpath(os.path.join(current_directory, path))
if os.path.commonprefix([full_path, current_directory
]) != current_directory:
raise exceptions.Forbidden(
"Can only serve files from within the current directory")
if os.path.exists(full_path) is False:
raise exceptions.NotFound("Path does not exist")
current_user = auth.current_user(request)
is_logged_in = (current_user is not None)
if os.path.isdir(full_path) is True:
# serve an html representation of the directory
html = list_directory(full_path, path, is_logged_in)
# prevent any sort of browser caching
headers = {
'Cache-Control': 'private, max-age=0, no-cache, no-store',
}
return response.html(html, headers=headers)
else:
chunk_size = 2 * (1024**2) # 2mb
file_size = os.path.getsize(full_path)
range_object = None
range_header = request.headers.get('Range')
if range_header is not None:
range_object = types.SimpleNamespace()
range_object.start = 0
range_object.total = file_size
range_object.end = range_object.total - 1
range_ = range_header.split('=')[1]
requested_start, requested_end = range_.split('-')
if requested_start is not '':
range_object.start = int(requested_start)
if requested_end is not '':
range_object.end = int(requested_end)
range_object.end = min(range_object.end,
range_object.start + chunk_size - 1)
range_object.size = range_object.end - range_object.start + 1
headers = {
'Accept-Ranges': 'Accept-Ranges: bytes',
'Monkey-Patch-Content-Length': file_size,
}
return await response.file_stream(
full_path,
headers=headers,
chunk_size=chunk_size,
_range=range_object,
)
async def update_hotel(request):
logger = logging.getLogger(__name__)
try:
body = request.json
except exceptions.InvalidUsage:
body = None
if not body or not isinstance(body, dict):
logger.warning(f"Invalid request body: {request.body}")
raise exceptions.InvalidUsage({
"status": 400,
"errmsg": "Invalid request body"
})
oid = body.get("_id")
if not oid:
logger.warning('_id is required!')
raise exceptions.InvalidUsage({
"status": 400,
"errmsg": "_id is required!"
})
db = databases("scripture")
doc = await db.statics.hotels.relux.rooms.find_one({"_id": ObjectId(oid)},
{"rooms_cn": 1})
if not doc:
logger.warning(f'oid:{oid} Corresponding Hotel not found')
raise exceptions.NotFound({
"status": 404,
"errmsg": "Hotel not found!"
})
ori_rooms_cn = doc.get("rooms_cn")
if not ori_rooms_cn:
logger.warning(f'oid:{oid} Corresponding Hotel rooms_cn not found')
raise exceptions.NotFound({
"status": 404,
"errmsg": "Hotel rooms_cn not found!"
})
rooms_cn = body.get("rooms_cn")
if not rooms_cn:
logger.warning(f'oid:{oid} Corresponding rooms_cn is required')
raise exceptions.InvalidUsage({
"status": 400,
"errmsg": "rooms_cn is required!"
})
futures = []
for room, ori_room in zip(rooms_cn, ori_rooms_cn):
room_id = room["id"]
if room_id != ori_room["id"]:
logger.error(f"The order of the rooms is out of order: "
f"room({room}), ori_doc({doc})")
continue
if room == ori_room:
continue
for plan, ori_plan in zip(room.get("plans", []),
ori_room.get("plans", [])):
if plan["id"] != ori_plan["id"]:
logger.error(f"The order of the plans is out of order: "
f"plan({plan}), ori doc({doc})")
continue
if plan == ori_plan:
continue
if plan["name"] != ori_plan["name"]:
plan["ori_name"] = ori_plan["name"]
if plan["feature"] != ori_plan["feature"]:
plan["ori_feature"] = ori_plan["feature"]
future = asyncio.ensure_future(
db.statics.hotels.relux.rooms.update_one(
{
"_id": ObjectId(oid),
"rooms_cn.id": room_id,
"rooms_cn.plans": ori_room["plans"]
}, {"$set": {
"rooms_cn.$.plans": room["plans"]
}}))
extra = {
"oid": oid,
"ori_plan": ori_room["plans"],
"new_plan": room["plans"]
}
future.add_done_callback(partial(callback, extra=extra))
futures.append(future)
if not futures:
logger.warning(
f'ori_room["plans"]:{ori_room["plans"]},room["plans"]:{room["plans"]},'
f' No difference or rooms order is wrong')
raise exceptions.InvalidUsage({
"status":
400,
"errmsg":
"No difference or rooms order is wrong"
})
logger.info(f'oid:{oid} update_relux_plan success')
return response.json({"status": 200, "data": {"count": len(futures)}})
async def publish(request, principal):
request.principal = principal
try:
return await publisher(request, root)
except ResolveError:
raise exceptions.NotFound('Resource not found.')
async def get_character_images_route(request, character):
page = 0
count = 100
character = character.lower()
if "page" in request.args:
try:
page = int(request.args["page"][0])
except ValueError:
raise exceptions.InvalidUsage("Page argument must be an integer")
if "count" in request.args:
try:
count = int(request.args["count"][0])
except ValueError:
raise exceptions.InvalidUsage("Count argument must be an integer")
start_index = page * count
if not (await app.index_redis.exists("index:characters:" + character) > 0):
raise exceptions.NotFound("No character " + character +
" found in index")
filter_sets = []
if "tag" in request.args:
filter_sets.extend("index:tags:merged:" + t
for t in request.args["tag"])
if "author" in request.args:
filter_sets.extend("index:authors:" + a
for a in request.args["author"])
if "site" in request.args:
filter_sets.extend("index:sites:" + s for s in request.args["site"])
if "rating" in request.args:
filter_sets.extend("index:rating:" + r for r in request.args["rating"])
if len(filter_sets) > 0:
filter_sets.insert(0, "index:characters:" + character)
h = hashlib.sha1()
for s in filter_sets:
h.update(s.encode("utf-8"))
dest_key = "tmp_query:" + h.hexdigest()
if not (await app.index_redis.exists(dest_key)):
await app.index_redis.zinterstore(dest_key,
*filter_sets,
aggregate="max")
await app.index_redis.expire(dest_key, 15 * 60)
total = await app.index_redis.zcard(dest_key)
ids = await app.index_redis.zrange(dest_key,
start_index,
start_index + count,
encoding="utf-8")
else:
total = await app.index_redis.zcard("index:characters:" + character)
ids = await app.index_redis.zrange(
"index:characters:" + character,
start_index,
start_index + count,
encoding="utf-8",
)
resp = []
for img_id in ids:
indexed_image = await IndexedImage.load_from_index_async(
app.index_redis, int(img_id))
index_data = {
"img_id": str(indexed_image.img_id),
"imhash": base64.b64encode(indexed_image.imhash),
"cache_path": "image/" + indexed_image.cache_filename,
}
index_data.update(attr.asdict(indexed_image.queued_img_data))
resp.append(index_data)
return response.json(resp, headers={"X-Total-Items": total})
