def package_writer(self, package_id):
validator(validate_uuid, package_id)
if request.method == "PUT":
req_json = self.get_request_json_or_abort()
if 'id' in req_json:
if req_json['id'] != package_id:
abort(
400,
"Payload 'id' must match that in the URL: got {}, expected {}"
.format(req_json['id'], package_id))
req_json.pop('id')
package = parse_resp_timestamps(req_json)
validator(validate_package, package)
updated_package = package_collection.update_or_404(
package_id, package)
resp = (200, updated_package)
if request.method == "DELETE":
package_collection.remove_or_404(package_id)
resp = (204, '')
return resp
def __init__(self, rql_str):
try:
q = convert_to_mongo(rql_str)
except UnparseError:
abort(501)
except ParserError as e:
abort(400, e.message)
super(RQLQuery, self).__init__(q)
def resource_list(self, api_version, resource_type):
if api_version not in NODE_APIVERSIONS:
abort(404)
if resource_type == "self":
return self.registry.list_self(api_version=api_version)
elif resource_type not in RESOURCE_TYPES:
abort(404)
return self.registry.list_resource(resource_type.rstrip("s"), api_version=api_version).values()
def group_get(self, group_id):
validator(validate_uuid, group_id)
if request.method == "GET":
group = group_collection.get_or_404(group_id)
if group.get(API_VERSION_KEY, 0) < self.api_version:
abort(404)
resp = (200, group)
return resp
def oauth(self):
"""Redirect to Auth Server's authorization endpoint"""
redirect_uri = url_for('_authorization',
_external=True,
_scheme=PROTOCOL)
if self.auth_registry.client_name:
self.auth_client = getattr(self.auth_registry,
self.auth_registry.client_name)
return self.auth_client.authorize_redirect(redirect_uri)
else:
abort(400, "Client not registered with Auth Server")
def _insert_package(version, req_json):
resp = req_json.copy()
req_json[API_VERSION_KEY] = version
try:
resource_id = db_mongo.insert_package(req_json)
except ChildNotFound as e:
abort(400, e.message)
resp["id"] = resource_id
resp = marshal.marshal(
resp) # TODO: could be safer to wrap make_response to marshal
response = make_response(jsonify(resp), 201)
response.autocorrect_location_header = False
response.headers['Location'] = '{}/{}/'.format(request.path,
resource_id)
return response
def group_writer(self, group_id):
validator(validate_uuid, group_id)
if request.method == "PUT":
req_json = self.get_request_json_or_abort()
if 'id' in req_json:
if req_json['id'] != group_id:
abort(
400,
"Payload 'id' must match that in the URL: got {}, expected {}"
.format(req_json['id'], group_id))
req_json.pop('id')
validator(validate_group, req_json)
updated_group = group_collection.update_or_404(group_id, req_json)
resp = (200, updated_group)
if request.method == "DELETE":
db_mongo.remove_group_or_404(group_id)
resp = (204, '')
return resp
def resource_id(self, api_version, resource_type, resource_id):
if api_version not in NODE_APIVERSIONS:
abort(404)
if resource_type not in RESOURCE_TYPES:
abort(404)
resources = self.registry.list_resource(resource_type.rstrip("s"), api_version=api_version)
if resource_id in resources:
return resources[resource_id]
else:
abort(404)
def validator(validation_func, obj):
try:
validation_func(obj)
except ValidationError as e:
abort(400, e.message)
return obj
def get_request_json_or_abort():
ret = request.get_json()
if ret is None:
abort(400, "Only accepts context-type: application/json")
return ret
def _or_404(self, func, *args, **kwargs):
item = func(*args, **kwargs)
return marshall(item) if item else abort(404)
def _error(self):
abort(400, "some error")
def versionroot(self, api_version):
if api_version not in NODE_APIVERSIONS:
abort(404)
return [
"self/", "sources/", "flows/", "devices/", "senders/", "receivers/"
]
def receiver_id_subscription(self, api_version, receiver_id):
if api_version not in NODE_APIVERSIONS:
abort(404)
receiver_service = self.registry.find_service("receiver", receiver_id)
if receiver_service is None:
abort(404)
receiver_service_href = self.registry.get_service_href(
receiver_service)
if receiver_service_href is None:
# Service doesn't specify an href
return {}
if str(receiver_service_href).isdigit():
# Service doesn't exist
abort(404)
receiver_subs_href = "receivers/" + receiver_id + "/target"
href = urljoin(receiver_service_href, receiver_subs_href) + "/"
# TODO Handle all request types
# TODO Move into proxy class?
headers = dict(request.headers)
headers['Accept'] = 'application/json'
del headers['Host']
print(
"Sending {} request to '{}' with headers={} and data='{}'".format(
request.method, href, headers, request.data))
try:
resp = requests.request(request.method,
href,
params=request.args,
data=request.data,
headers=headers,
allow_redirects=True,
timeout=30)
except Exception:
abort(500)
if not resp:
abort(503)
print(resp)
if resp.status_code // 100 != 2:
abort(resp.status_code)
data = {}
if len(resp.text) > 0:
data = resp.json()
else:
return (204, '')
if resp.status_code == 200:
return (data)
else:
return (resp.status_code, data)
