async def retrieve_entry(request: web.Request):
try:
response = []
if 'rule_id' in request.rel_url.query:
rule_id = request.rel_url.query.get('rule_id')
Validate.validate_object_id(rule_id)
response = await RateLimiter.get_entry_by_rule_id(
rule_id, DB.get_redis(request))
elif 'host' in request.rel_url.query:
host = request.rel_url.query.get('host')
response = await RateLimiter.get_entry_by_host(
host, DB.get_redis(request))
elif 'id' in request.rel_url.query:
_id = request.rel_url.query.get('id')
Validate.validate_object_id(_id)
response = await RateLimiter.get_entry_by_id(
_id, DB.get_redis(request))
else:
response = await RateLimiter.get_all_entries(DB.get_redis(request))
return web.json_response({
'data': response,
'status_code': 200
},
status=200)
except Exception as err:
return Error.handle(err)
async def get_handler(request: web.Request):
try:
admins = None
if len(request.rel_url.query.keys()) == 0:
admins = await Admin.get_all(DB.get(request, table))
else:
admins = []
if 'id' in request.rel_url.query:
admin_id = request.rel_url.query.get('id')
Validate.validate_object_id(admin_id)
admin = await Admin.get_by_id(admin_id, DB.get(request, table))
if admin is not None:
admins.append(admin)
elif 'email' in request.rel_url.query:
admin_email = request.rel_url.query.get('email')
admins = await Admin.get_by_email(admin_email,
DB.get(request, table))
elif 'username' in request.rel_url.query:
admin_username = request.rel_url.query.get('username')
admins = await Admin.get_by_username(admin_username,
DB.get(request, table))
return web.json_response({
'data':
DB.format_documents(Bson.to_json(admins)),
'status_code':
200
})
except Exception as err:
return Error.handle(err)
async def retrieve_rule(request: web.Request):
try:
# we want to identify the parameter which is used to identify the
# records
response = []
if 'status_code' in request.rel_url.query:
status_code = request.rel_url.query.get('status_code')
response = await RateLimiter.get_rule_by_status_code(
status_code, DB.get_redis(request))
elif 'service_id' in request.rel_url.query:
service_id = request.rel_url.query.get('service_id')
response = await RateLimiter.get_rule_by_service_id(
service_id, DB.get_redis(request))
elif 'id' in request.rel_url.query:
_id = request.rel_url.query.get('id')
Validate.validate_object_id(_id)
rule = await RateLimiter.get_rule_by_id(_id, DB.get_redis(request))
if rule:
response.append(rule)
else:
# fallback to get all if no param passed
response = await RateLimiter.get_all_rules(DB.get_redis(request))
return web.json_response({
'data': response,
'status_code': 200
},
status=200)
except Exception as err:
return Error.handle(err)
async def get_handler(request: web.Request):
try:
circuit_breakers = None
if len(request.rel_url.query.keys()) == 0:
circuit_breakers = await CircuitBreaker.get_all(DB.get(request, table))
else:
circuit_breakers = []
if 'id' in request.rel_url.query:
Validate.validate_object_id(request.rel_url.query.get('id'))
circuit_breaker = await CircuitBreaker.get_by_id(request.rel_url.query.get('id'), DB.get(request, table))
if circuit_breaker is not None:
circuit_breakers.append(circuit_breaker)
elif 'service_id' in request.rel_url.query:
Validate.validate_object_id(
request.rel_url.query.get('service_id'))
circuit_breakers = await CircuitBreaker.get_by_service_id(request.rel_url.query.get('service_id'), DB.get(request, table))
elif 'status_code' in request.rel_url.query:
circuit_breakers = await CircuitBreaker.get_by_status_code(int(request.rel_url.query.get('status_code')), DB.get(request, table))
elif 'method' in request.rel_url.query:
circuit_breakers = await CircuitBreaker.get_by_method(request.rel_url.query.get('method'), DB.get(request, table))
elif 'threshold' in request.rel_url.query:
circuit_breakers = await CircuitBreaker.get_by_threshold(float(request.rel_url.query.get('threshold')), DB.get(request, table))
return web.json_response({
'data': DB.format_documents(Bson.to_json(circuit_breakers)),
'status_code': 200
})
except Exception as err:
return Error.handle(err)
async def get_handler(request: web.Request):
try:
services = []
if len(request.rel_url.query.keys()) == 0:
services = await Event.get_all(DB.get(request, table))
else:
if 'id' in request.rel_url.query:
Validate.validate_object_id(request.rel_url.query.get('id'))
service = await Event.get_by_id(
request.rel_url.query.get('id'), DB.get(request, table))
if service is not None:
services.append(service)
elif 'circuit_breaker_id' in request.rel_url.query:
Validate.validate_object_id(
request.rel_url.query.get('circuit_breaker_id'))
services = await Event.get_by_circuit_breaker_id(
request.rel_url.query.get('circuit_breaker_id'),
DB.get(request, table))
elif 'target' in request.rel_url.query:
services = await Event.get_by_target(
request.rel_url.query.get('target'),
DB.get(request, table))
return web.json_response({
'data':
DB.format_documents(Bson.to_json(services)),
'status_code':
200
})
except Exception as err:
return Error.handle(err)
async def proxy(request: web.Request, handler: web.RequestHandler):
try:
req_start_time = time()
if pydash.starts_with(request.path_qs, '/raven'):
return await handler(request)
service = Regex.best_match(await Regex.get_matched_paths(request.path, DB.get(request, service_controller.table)))
await handle_service(service, request.remote)
rate_limiter_rules = await RateLimiter.get_rule_by_service_id(str(service['_id']), DB.get_redis(request))
rate_limiter_rule = rate_limiter_rules[0] if rate_limiter_rules else None
await handle_rate_limiter(request, str(service['_id']), rate_limiter_rule)
breakers = await CircuitBreaker.get_by_service_id(str(service['_id']), DB.get(request, circuit_breaker_controller.table))
breaker = breakers[0] if breakers else None
request_validators = await RequestValidator.get_by_service_id(str(service['_id']), DB.get(request, request_validator_controller.table))
request_validator = request_validators[0] if request_validators else None
endpoint_cachers = not pydash.is_empty(service) and await EndpointCacher.get_by_service_id(str(service['_id']), DB.get_redis(request)) or None
endpoint_cacher = endpoint_cachers[0] if endpoint_cachers else None
await handle_request_validator(request_validator, json.loads(await request.text()), request.method)
req, req_cache_hit = await handle_request(request, service, endpoint_cacher)
checks = []
if not pydash.is_empty(
breaker) and breaker['status'] == CircuitBreakerStatus.ON.name:
if req['status'] in breaker['status_codes']:
checks.append(handle_circuit_breaker(
breaker, service, request, req))
else:
await CircuitBreaker.incr_count(str(breaker['_id']), DB.get_redis(request))
queue_async_func.s({
'func': 'Service.advance_target',
'args': [str(service['_id']), f'mongo:{service_controller.table}'],
'kwargs': {}
}).apply_async()
req_finish_time = time()
req_elapsed_time = req_finish_time - req_start_time
checks.append(handle_insights(request, req, str(
service['_id']), req_elapsed_time, req_cache_hit))
await Async.all(checks)
return web.Response(
body=Bytes.decode_bytes(
req['body_bytes']),
status=req['status'],
content_type=req['content_type'],
headers=CIMultiDict(
pydash.omit(
req['headers'],
'Content-Type',
'Transfer-Encoding',
'Content-Encoding')))
except Exception as err:
return Error.handle(err)
async def login_handler(request: web.Request):
try:
ctx = json.loads(await request.text())
verified = await Admin.verify_password(ctx['username'],
ctx['password'],
DB.get(request, table))
if not verified:
raise Exception({'message': 'Unathorized', 'status_code': 401})
admin = await Admin.get_by_username(ctx['username'],
DB.get(request, table))
sanitized_admin = pydash.omit(admin, 'password')
return web.json_response(
{'data': DB.format_document(Bson.to_json(sanitized_admin))})
except Exception as err:
return Error.handle(err)
async def handle_request(request: web.Request, service: object, endpoint_cacher: object):
req_ctx = {
'method': request.method,
'url': service['targets'][service['cur_target_index']],
'params': dict(request.rel_url.query),
'data': await request.text(),
'cookies': dict(request.cookies),
'headers': pydash.omit(dict(request.headers), 'Host'),
}
req = None
req_cache = None
req_ctx_hash = None
if not pydash.is_empty(endpoint_cacher):
req_ctx_hash = Hasher.hash_sha_256(json.dumps(req_ctx))
req_cache = await EndpointCacher.get_cache(req_ctx_hash, DB.get_redis(request))
if pydash.is_empty(req_cache):
req = await Api.call(**req_ctx)
if pydash.is_empty(req_ctx_hash):
req_ctx_hash = Hasher.hash_sha_256(json.dumps(req_ctx))
not pydash.is_empty(endpoint_cacher) and queue_async_func.s({
'func': 'EndpointCacher.set_cache',
'args': [req_ctx_hash, req, int(endpoint_cacher['timeout']), 'redis'],
'kwargs': {}
}).apply_async()
else:
req = json.loads(req_cache)
cache_hit = True if not pydash.is_empty(req_cache) else False
return req, cache_hit
async def handle_rate_limiter(request: web.Request, service_id: str, rule: object):
if not pydash.is_empty(rule):
entries = await RateLimiter.get_entry_by_rule_id(rule['_id'], DB.get_redis(request))
if not pydash.is_empty(entries):
entry = entries[0]
if int(entry['count']) >= int(rule['max_requests']):
raise Exception({
'message': rule['message'] or 'Too Many Requests',
'status_code': int(rule['status_code']) or 429
})
queue_async_func.s({
'func': 'RateLimiter.increment_entry_count',
'args': [entry['_id'], 'redis'],
'kwargs': {}
}).apply_async()
else:
entry = {
'rule_id': rule['_id'],
'host': request.remote,
'count': 1,
'timeout': int(rule['timeout'])
}
queue_async_func.s({
'func': 'RateLimiter.create_entry',
'args': [entry, 'redis'],
'kwargs': {}
}).apply_async()
async def post_handler(request: web.Request):
try:
ctx = json.loads(await request.text())
Validate.validate_schema(ctx, admin_validator)
await Admin.create(ctx, DB.get(request, table))
return web.json_response({
'message': 'Admin created',
})
except Exception as err:
return Error.handle(err)
async def create_rule(request: web.Request):
try:
ctx = json.loads(await request.text())
Validate.validate_schema(ctx, rate_limit_rule_validator)
await RateLimiter.create_rule(ctx, DB.get_redis(request))
return web.json_response({
'message': 'Created rate limiter rule',
'status_code': 200
})
except Exception as err:
return Error.handle(err)
async def post_handler(request: web.Request):
try:
ctx = json.loads(await request.text())
Validate.validate_schema(ctx, circuit_breaker_validator)
await CircuitBreaker.create(circuit_breaker_validator.normalized(ctx), DB.get(request, table), DB.get(request, controller.table))
return web.json_response({
'message': 'Circuit breaker created',
'status_code': 200
})
except Exception as err:
return Error.handle(err)
async def delete_rule(request: web.Request):
try:
# id to delete is from query params
_id = request.rel_url.query.get('id')
Validate.validate_object_id(_id)
await RateLimiter.delete_rule(_id, DB.get_redis(request))
return web.json_response({
'message': 'rate limiter rule deleted',
'status_code': 200
})
except Exception as err:
return Error.handle(err)
async def patch_handler(request: web.Request):
try:
ctx = json.loads(await request.text())
circuit_breaker_id = request.rel_url.query['id']
Validate.validate_schema(ctx, circuit_breaker_validator)
Validate.validate_object_id(circuit_breaker_id)
await CircuitBreaker.update(circuit_breaker_id, pydash.omit(ctx, 'id'), DB.get(request, table))
return web.json_response({
'message': 'Circuit breaker updated',
})
except Exception as err:
return Error.handle(err)
async def update_rule(request: web.Request):
try:
ctx = json.loads(await request.text())
_id = request.rel_url.query.get('id')
Validate.validate_schema(ctx, rate_limit_rule_validator)
Validate.validate_object_id(_id)
await RateLimiter.update_rule(_id, ctx, DB.get_redis(request))
return web.json_response({
'message': 'rate limiter rule updated',
'status_code': 200
})
except Exception as err:
return Error.handle(err)
