async def instance_create_endpoint(request, instance_id):
data = request.json
if data is None:
return response.HTTPResponse("Missing json payload.", status=400)
if 'user' not in data.keys():
return response.HTTPResponse("Missing 'user' json payload parameter.", status=400)
if 'lifetime' not in data.keys():
return response.HTTPResponse("Missing 'lifetime' json payload parameter.", status=400)
ssh_keys = await get_ssh_key_ids()
base_image = await get_base_images()
async with httpx.AsyncClient() as client:
r = await client.post(
"https://api.digitalocean.com/v2/droplets",
headers=DIGITALOCEAN_COMMON_HEADERS,
json={
"name": "neos-server-{}".format(instance_id),
"region": "sfo3",
"size": "s-1vcpu-1gb",
"image": base_image['id'],
"ipv6": True,
"monitoring": True,
"tags": ["neos", f"instance_id:{instance_id}", f"lifetime:{data['lifetime']}", f"user:{data['user']}"],
"ssh_keys": ssh_keys,
"user_data": generate_cloud_init()
}
)
if r.is_error:
logger.info("request={}".format(r.request.__dict__))
logger.error("response={}".format(r.json()))
return response.json({"status": "error", "message": r.reason_phrase}, status=500)
else:
return response.json({"status": "created", "instance_id": instance_id}, status=201)
async def handle_logos(request, cover=None, logo=None, path=None):
try:
log.debug(f'[{request.ip}] {request.method} {request.url}')
if logo:
orig_url = f'{IMAGENIO_URL}/channelLogo/{logo}'
elif path and cover:
orig_url = (f'{IMAGENIO_URL}/covers/programmeImages'
f'/portrait/290x429/{path}/{cover}')
else:
return response.json({'status': f'{request.url} not found'}, 404)
if request.method == 'HEAD':
return response.HTTPResponse(content_type='image/jpeg', status=200)
global SESSION_LOGOS
if not SESSION_LOGOS:
headers = {'User-Agent': 'MICA-IP-STB'}
SESSION_LOGOS = aiohttp.ClientSession(headers=headers)
async with SESSION_LOGOS.get(orig_url) as r:
if r.status == 200:
logo_data = await r.read()
headers = {}
headers.setdefault('Content-Disposition',
f'attachment; filename="{logo}"')
return response.HTTPResponse(body=logo_data,
content_type='image/jpeg',
headers=headers,
status=200)
else:
return response.json({'status': f'{orig_url} not found'}, 404)
except asyncio.exceptions.CancelledError:
pass
def get(request, record_id):
if str.isdigit(record_id) is False:
return response.HTTPResponse(status=400)
if int(record_id) not in timers_table:
return response.HTTPResponse(body="ID not found", status=404)
record_list = r.dump_fetch_history(record_id)
output_json = json.dumps(record_list, indent=3)
return text(output_json)
def post(self, request):
requested_interval = request.json.get('interval')
requested_url = request.json.get('url')
try:
if validators.url(requested_url) is not True:
return response.HTTPResponse(body="Malformatted URL",
status=400)
except TypeError:
return response.HTTPResponse(body="URL is not a string",
status=400)
try:
if requested_interval < 1:
return response.HTTPResponse(body="Interval smaller than 1",
status=400)
except TypeError:
return response.HTTPResponse(body="Interval cannot be a string",
status=400)
# remove trailing / from URL
requested_url = re.sub(r"/+$", "", requested_url)
# check if we have this url registered in redis
redis_id = r.get_id_from_url(requested_url)
if redis_id is None:
redis_id = r.add_url(requested_url, requested_interval)
worker_input = {'site': requested_url, 'interval':
requested_interval}
rpt = multitimer.RepeatingTimer(interval=requested_interval,
function=self.worker_func,
kwargs=worker_input,
count=-1, runonstart=False)
rpt.start()
timers_table[redis_id] = rpt
else:
redis_id = int(redis_id.decode("utf-8"))
r.update_interval(redis_id, requested_interval)
timers_table[redis_id].stop()
worker_input = {'site': requested_url, 'interval':
requested_interval}
rpt = multitimer.RepeatingTimer(interval=requested_interval,
function=self.worker_func,
kwargs=worker_input,
count=-1,
runonstart=False)
rpt.start()
timers_table[redis_id] = rpt
return text("{\"id\": %s}" % redis_id)
async def tiles_png(request, image_id, z, x, y, format):
"""
get tile image
:param request:
:param image_id: id of tiff image
:param x: coordinate-x
:param y: coordinate-y
:param format: view format
:return:
"""
slide = get_slide(image_id, get_path(image_id, request))
x = int(x)
y = int(y)
z = int(z)
bio = BytesIO()
tiles_image = ADeepZoomGenerator(slide).get_tile(z, (x, y))
tiles_image.save(bio, 'png')
image_bytes = bio.getvalue()
headers = {}
headers.setdefault(
'Content-Disposition',
'attachment; image_id="{}"'.format(os.path.basename(image_id)))
return response.HTTPResponse(status=200,
headers=headers,
body_bytes=image_bytes,
content_type='image/png')
async def cell_image_request(request, image_id, x, y, w, h, format):
"""
get cell image
:param request:
:param image_id: id of tiff image
:param x: coordinate-x
:param y: coordinate-y
:param w: image width
:param h: image height
:return:
"""
print('==============> in')
slide = get_slide(image_id, get_path(image_id, request))
tile_image = slide.read_region((x, y), 0, (w, h))
bio = BytesIO()
tile_image.save(bio, 'png')
image_bytes = bio.getvalue()
headers = {}
headers.setdefault(
'Content-Disposition',
'attachment; image_id="{}"'.format(os.path.basename(image_id)))
return response.HTTPResponse(status=200,
headers=headers,
body_bytes=image_bytes,
content_type='image/png')
async def delete_jogging_result(request, *args, **kwargs):
user_from_token = retrieve_user(request, args, kwargs)
if user_from_token is None:
raise InvalidUsage("invalid parameter (maybe expired?)")
try:
jogging_id = int(request.path.split("/")[2])
except ValueError as e:
raise InvalidUsage(e)
if jogging_id < 0:
raise InvalidUsage("invalid id")
jog = JoggingResult.load_by_jogging_id(jogging_id)
if jog is None:
raise InvalidUsage("invalid id")
user_id_from_token = retrieve_user(request, args, kwargs).user_id
if user_id_from_token != jog.user_id:
raise Forbidden("user can only access user jogs")
jog.delete()
return response.HTTPResponse(status=204)
async def route_wrapper(self, route, req, context, request_args, request_kw,
*decorator_args, **decorator_kw):
_ = decorator_kw.pop('with_context') # ignore this.
_options = decorator_kw
options = get_cors_options(context.app, _options)
if options.get('automatic_options', True) and req.method == 'OPTIONS':
resp = response.HTTPResponse()
else:
resp = route(req, *request_args, **request_kw)
while isawaitable(resp):
resp = await resp
# resp can be `None` or `[]` if using Websockets
if not resp:
return None
try:
request_context = context.request[id(req)]
except (AttributeError, LookupError):
if SANIC_19_9_0 <= SANIC_VERSION:
request_context = req.ctx
else:
request_context = None
set_cors_headers(req, resp, request_context, options)
if request_context is not None:
setattr(request_context, SANIC_CORS_EVALUATED, "1")
else:
context.log(logging.DEBUG, "Cannot access a sanic request "
"context. Has request started? Is request ended?")
return resp
def unapplied_cors_request_middleware(req, context):
if req.method == 'OPTIONS':
try:
path = req.path
except AttributeError:
path = req.url
resources = context.resources
log = context.log
debug = partial(log, logging.DEBUG)
for res_regex, res_options in resources:
if res_options.get('automatic_options', True) and \
try_match(path, res_regex):
debug("Request to '{:s}' matches CORS resource '{}'. "
"Using options: {}".format(
path, get_regexp_pattern(res_regex), res_options))
resp = response.HTTPResponse()
try:
request_context = context.request[id(req)]
except (AttributeError, LookupError):
if SANIC_19_9_0 <= SANIC_VERSION:
request_context = req.ctx
else:
request_context = None
context.log(logging.DEBUG,
"Cannot access a sanic request "
"context. Has request started? Is request ended?")
set_cors_headers(req, resp, request_context, res_options)
if request_context is not None:
setattr(request_context, SANIC_CORS_EVALUATED, "1")
return resp
else:
debug('No CORS rule matches')
async def iframe(self, request):
cached = request.headers.get('If-None-Match')
if cached:
resp = response.HTTPResponse(status=304)
resp.headers["Content-Type"] = ""
resp.headers.extend(cache_headers())
return resp
headers = (
("Content-Type", "text/html;charset=UTF-8"),
("ETag", self.iframe_html_hxd),
)
headers += cache_headers()
return response.HTTPResponse(None,
body_bytes=self.iframe_html,
headers=headers)
async def get_courier(request: Request,
courier_id: int) -> response.HTTPResponse:
courier_status = await app.db.courier_status(courier_id)
if not courier_status:
error_logger.warning("Courier id=%s not found", courier_id)
return response.HTTPResponse(status=404)
# TODO: move it to thread_pool_executor
completed_orders_ids = {
status.order_id
for status in courier_status.statuses
if status.completed_time is not None
}
json = courier_status.courier.external()
if not completed_orders_ids:
return response.json(json, indent=4)
completed_orders = [
order for order in courier_status.orders
if order.order_id in completed_orders_ids
]
completed_orders.sort(key=lambda order: order.completed_time)
return response.json(json, indent=4)
async def label_image(request, image_id, format):
"""
get tile image
:param request:
:param image_id: id of tiff image
:param format: view format
:return:
"""
slide = get_slide(image_id, get_path(image_id, request))
bio = BytesIO()
label_image = slide.label_image
# 如果标签存在则保存,否则返回一个空字节
if label_image:
label_image.save(bio, 'png')
image_bytes = bio.getvalue()
else:
image_bytes = b''
headers = {}
headers.setdefault(
'Content-Disposition',
'attachment; image_id="{}"'.format(os.path.basename(image_id)))
return response.HTTPResponse(status=200,
headers=headers,
body_bytes=image_bytes,
content_type='image/png')
async def pray(request):
if not res['token']:
return response.HTTPResponse(status=400)
prayer = db.prayer.insert_one({
"user_id": request.form['user_id'],
"when": datetime.utcnow(),
"text": request.form['text']
})
async def get(self, request, key, suffix):
item = self.callback(key)
if suffix == ".json":
headers = {}
content_type = "application/json"
data = item.json
return response.HTTPResponse(data,
content_type=content_type,
headers=headers)
async def get(self, request, suffix):
data = self.callback()
if suffix == ".json":
headers = {}
content_type = "application/json"
representation = json
return response.HTTPResponse(representation.dumps(data),
content_type=content_type,
headers=headers)
def delete(request, record_id):
if int(record_id) in timers_table:
timers_table[int(record_id)].stop()
del timers_table[int(record_id)]
redis_id = r.delete_id(record_id)
if redis_id is None:
return response.HTTPResponse(body="ID not found", status=404)
return text("{\"id\": %s}" % redis_id)
def file(bytes, mime_type, image_id):
"""http 文件response"""
headers = {}
headers.setdefault('Content-Disposition',
'attachment; image_id="{}"'.format(image_id))
return response.HTTPResponse(status=200,
headers=headers,
content_type=mime_type,
body_bytes=bytes)
def wrapper(cls, f, ctx, req, e):
opts = ctx.options
log = ctx.log
# get response from the original handler
if (req is not None and SANIC_19_12_0 <= SANIC_VERSION
and isinstance(e, MethodNotSupported)
and req.method == "OPTIONS"
and opts.get('automatic_options', True)):
# A very specific set of requirments to trigger this kind of
# automatic-options resp
resp = response.HTTPResponse()
else:
do_await = iscoroutinefunction(f)
resp = f(req, e)
# async Exceptions may be awaitable and should be returned
if isawaitable(resp) or do_await:
log(
logging.DEBUG,
"Found an async Exception handler response. "
"Cannot apply CORS to it. Passing it on.")
return resp
# SanicExceptions are equiv to Flask Aborts,
# always apply CORS to them.
if (req is not None and resp is not None) and \
(isinstance(e, exceptions.SanicException) or
opts.get('intercept_exceptions', True)):
try:
cls._apply_cors_to_exception(ctx, req, resp)
except AttributeError:
# not sure why certain exceptions doesn't have
# an accompanying request
pass
if req is None:
return resp
# These exceptions have normal CORS middleware applied automatically.
# So set a flag to skip our manual application of the middleware.
try:
request_context = ctx.request[id(req)]
except (LookupError, AttributeError):
# On Sanic 19.12.0, a NotFound error can be thrown _before_
# the request_context is set up. This is a fallback routine:
if SANIC_19_12_0 <= SANIC_VERSION and \
isinstance(e, (NotFound, MethodNotSupported)):
# On sanic 19.9.0+ request is a dict, so we can add our
# flag directly to it.
request_context = req.ctx
else:
log(
logging.DEBUG,
"Cannot find the request context. Is request started? "
"Is request already finished?")
request_context = None
if request_context is not None:
setattr(request_context, SANIC_CORS_SKIP_RESPONSE_MIDDLEWARE, "1")
return resp
async def bulk_process_notification(cls, request: request.Request,
topic: enum.Enum):
"""Process the received notification.
- Check if the related topic is supported.
- Pass the notification info to the dispatchers.
Parameters
----------
request: sanic.request.Request
The challenge request received from Twitch
topic: enum.Enum
Topic whose notification is being processed
Returns
-------
response.HTTPResponse
status code: 202 if the request has correctly been processed
status code: 400 otherwise
"""
if topic not in NOTIFICATION_TYPE_BY_TOPIC:
log.error(
f'Invalid topic "{topic.name}", the notification has been ignored'
)
return
try:
params = {
param: request.args.get(param)
for param in NOTIFICATION_TYPE_BY_TOPIC[topic].valid_params
}
data = request.json['data'][0] if request.json['data'] else {}
for instance in cls.__instances:
await instance.process_notification(data, topic, params)
return response.HTTPResponse(status=202)
except KeyError:
return response.HTTPResponse(status=400)
async def inner(request: request.Request, *args, **kwargs):
notification_id = request.headers.get('Twitch-Notification-ID')
if notification_id in recent_notification_ids:
log.warning(
f'Received duplicate notification with ID {notification_id}, discarding.'
)
return response.HTTPResponse(status=200)
recent_notification_ids.append(notification_id)
return await route(request, *args, **kwargs)
async def get(self, request, as_json):
data = self.data_callback()
if as_json:
headers = {}
if self.ds.cors:
headers["Access-Control-Allow-Origin"] = "*"
return response.HTTPResponse(
json.dumps(data), content_type="application/json", headers=headers
)
else:
return self.render(["show_json.html"], filename=self.filename, data=data)
def zip(musics, name='archive'):
headers = {}
headers['X-Archive-Files'] = 'zip'
headers['Content-Disposition'] = 'attachment; filename={}'.format(name + '.zip')
# see mod_zip documentation :p
lines = [' '.join(['-',
str(m['size']),
quote("/sendfile" + m['path'][len(m['folder']):]),
os.path.join(m['artist'], m['album'], os.path.basename(m['path']))])
for m in musics]
body = '\n'.join(lines)
debug(body)
return response.HTTPResponse(headers=headers, body=body)
def JSONResponse(
body,
status=200,
headers=None,
content_type="application/json",
**kwargs,
):
return response.HTTPResponse(
json.dumps(body, **kwargs, cls=Encoder),
headers=headers,
status=status,
content_type=content_type,
)
async def complete(request: Request) -> response.HTTPResponse:
try:
complete = CompleteModel(**request.json)
except ValidationError as e:
error_logger.warning(e.json(indent=4))
return response.HTTPResponse(status=400)
courier_status = await app.db.courier_status(complete.courier_id)
if courier_status is None:
error_logger.warning("Courier id=%s not found", complete.courier_id)
return response.HTTPResponse(status=400)
has_the_courier_order = any(order.order_id == complete.order_id
for order in courier_status.orders)
if not has_the_courier_order:
error_logger.warning("Courier id=%s has no order id=%s",
complete.courier_id, complete.order_id)
return response.HTTPResponse(status=400)
await app.db.complete_order(complete.order_id, complete.complete_time)
return response.json({"order_id": complete.order_id})
async def get(self, request, as_format):
databases = []
for key, info in sorted(self.ds.inspect().items()):
tables = [t for t in info["tables"].values() if not t["hidden"]]
hidden_tables = [t for t in info["tables"].values() if t["hidden"]]
database = {
"name":
key,
"hash":
info["hash"],
"path":
"{}-{}".format(key, info["hash"][:HASH_LENGTH]),
"tables_truncated":
sorted(tables, key=lambda t: t["count"], reverse=True)[:5],
"tables_count":
len(tables),
"tables_more":
len(tables) > 5,
"table_rows_sum":
sum(t["count"] for t in tables),
"hidden_table_rows_sum":
sum(t["count"] for t in hidden_tables),
"hidden_tables_count":
len(hidden_tables),
"views_count":
len(info["views"]),
}
databases.append(database)
if as_format:
headers = {}
if self.ds.cors:
headers["Access-Control-Allow-Origin"] = "*"
return response.HTTPResponse(
json.dumps({db["name"]: db
for db in databases},
cls=CustomJSONEncoder),
content_type="application/json",
headers=headers,
)
else:
return self.render(
["index.html"],
databases=databases,
metadata=self.ds.metadata,
datasette_version=__version__,
extra_css_urls=self.ds.extra_css_urls(),
extra_js_urls=self.ds.extra_js_urls(),
)
def accept_subscription(request: request.Request, topic: enum.Enum):
"""Handle Twitch challenge requests.
Accept Twitch subscriptions by responding the request with the provided challenge string.
Parameters
----------
request: sanic.request.Request
The challenge request received from Twitch
topic: enum.Enum
The topic being subscribed to
Returns
-------
response.HTTPResponse
status code: 200 if the request has correctly been processed
status code: 400 otherwise
"""
try:
mode = request.args['hub.mode'][0]
if mode == 'subscribe' or mode == 'unsubscribe':
return response.HTTPResponse(
body=request.args['hub.challenge'][0], status=200)
elif mode == 'denied':
reason = request.args.get('hub.reason', 'no reason')
log.warning(
f'{topic.name} webhook subscribe request denied ({request.args}) , reason: {reason}.'
)
return response.HTTPResponse(status=200)
except KeyError:
return response.HTTPResponse(status=400)
async def route_wrapper(self, route, req, context, request_args,
request_kw, *decorator_args, **decorator_kw):
_ = decorator_kw.pop('with_context') # ignore this.
_options = decorator_kw
options = get_cors_options(context.app, _options)
if options.get('automatic_options') and req.method == 'OPTIONS':
resp = response.HTTPResponse()
else:
resp = route(req, *request_args, **request_kw)
if resp is not None:
while isawaitable(resp):
resp = await resp
if resp is not None:
request_context = context.request[id(req)]
set_cors_headers(req, resp, context, options)
request_context[SANIC_CORS_EVALUATED] = "1"
return resp
async def update_user(request, *args, **kwargs):
if request.json is None:
raise InvalidUsage("invalid payload (empty payload not allowed)")
try:
requested_user_id = int(request.path.split("/")[2])
except ValueError as e:
raise InvalidUsage(e)
user_from_token = retrieve_user(request, args, kwargs)
if user_from_token is None:
raise InvalidUsage("invalid parameter (maybe expired?)")
if (
"admin" not in user_from_token.scopes
and "manager" not in user_from_token.scopes
):
if requested_user_id != user_from_token.user_id:
raise Forbidden(f"user can only update self")
user = User.get_by_user_id(requested_user_id)
if not user:
raise InvalidUsage("invalid parameter")
if (
"manager" in user_from_token.scopes
and "admin" not in user_from_token.scopes
and ("manager" in user.scopes or "admin" in user.scopes)
):
if requested_user_id != user_from_token.user_id:
raise Forbidden(f"manager can only update manager")
if "password" in request.json:
password = request.json["password"]
if not password_validator(password):
raise InvalidUsage("password does not match minimum requirements")
user.update_password(encrypt(password))
if "email" in request.json:
user.update_email(request.json["email"])
if "name" in request.json:
user.update_name(request.json["name"])
user.save(modifying_user_id=user_from_token.user_id)
return response.HTTPResponse(status=204)
async def download_main_file(request, user):
obj = Object(app.client.energy_db.objects)
res, err = await obj.select({'_id': ObjectId(request.json['object_id'])},
{request.json['object_key']: True})
if err:
raise ObjectException(err)
return response.HTTPResponse(
status=200,
headers={
"Content-Disposition":
'attachment; filename="{0}"'.format(
res[0][request.json['object_key']]['filename'])
},
content_type=res[0][request.json['object_key']]['type'],
body_bytes=res[0][request.json['object_key']]['content'],
)
async def mark_as_uploaded(request, asset_id):
if (request.json != {'Status': 'uploaded'}):
return response.json(
{
'message':
'Expected JSON with the contents: {"Status": "uploaded"}.'
},
status=400)
in_cache = await is_asset_in_cache(asset_id)
if not in_cache:
return response.json({'message': 'Asset ID not found.'}, status=404)
app.cache[asset_id] = 'UPLOADED'
await app.redis.execute('set', asset_id, 'UPLOADED')
logging.info('Cache state: {}.'.format(app.cache))
return response.HTTPResponse(status=200)
