gns3-server/gns3server/web/route.py
2015-02-24 21:02:37 -07:00

185 lines
6.7 KiB
Python
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

# -*- coding: utf-8 -*-
#
# Copyright (C) 2015 GNS3 Technologies Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import sys
import json
import jsonschema
import asyncio
import aiohttp
import logging
import traceback
log = logging.getLogger(__name__)
from ..modules.vm_error import VMError
from .response import Response
from ..crash_report import CrashReport
@asyncio.coroutine
def parse_request(request, input_schema):
"""Parse body of request and raise HTTP errors in case of problems"""
content_length = request.content_length
if content_length is not None and content_length > 0:
body = yield from request.read()
try:
request.json = json.loads(body.decode('utf-8'))
except ValueError as e:
raise aiohttp.web.HTTPBadRequest(text="Invalid JSON {}".format(e))
else:
request.json = {}
try:
jsonschema.validate(request.json, input_schema)
except jsonschema.ValidationError as e:
log.error("Invalid input query. JSON schema error: {}".format(e.message))
raise aiohttp.web.HTTPBadRequest(text="Invalid JSON: {} in schema: {}".format(
e.message,
json.dumps(e.schema)))
return request
class Route(object):
""" Decorator adding:
* json schema verification
* routing inside handlers
* documentation information about endpoints
"""
_routes = []
_documentation = {}
_vm_locks = {}
@classmethod
def get(cls, path, *args, **kw):
return cls._route('GET', path, *args, **kw)
@classmethod
def post(cls, path, *args, **kw):
return cls._route('POST', path, *args, **kw)
@classmethod
def put(cls, path, *args, **kw):
return cls._route('PUT', path, *args, **kw)
@classmethod
def delete(cls, path, *args, **kw):
return cls._route('DELETE', path, *args, **kw)
@classmethod
def _route(cls, method, path, *args, **kw):
# This block is executed only the first time
output_schema = kw.get("output", {})
input_schema = kw.get("input", {})
api_version = kw.get("api_version", 1)
# If it's a JSON api endpoint just register the endpoint an do nothing
if api_version is None:
cls._path = path
else:
cls._path = "/v{version}{path}".format(path=path, version=api_version)
def register(func):
route = cls._path
handler = func.__module__.replace("_handler", "").replace("gns3server.handlers.api.", "")
cls._documentation.setdefault(handler, {})
cls._documentation[handler].setdefault(route, {"api_version": api_version,
"methods": []})
cls._documentation[handler][route]["methods"].append({
"method": method,
"status_codes": kw.get("status_codes", {200: "OK"}),
"parameters": kw.get("parameters", {}),
"output_schema": output_schema,
"input_schema": input_schema,
"description": kw.get("description", ""),
})
func = asyncio.coroutine(func)
@asyncio.coroutine
def control_schema(request):
# This block is executed at each method call
# Non API call
if api_version is None:
response = Response(route=route, output_schema=output_schema)
yield from func(request, response)
return response
# API call
try:
request = yield from parse_request(request, input_schema)
response = Response(route=route, output_schema=output_schema)
yield from func(request, response)
except aiohttp.web.HTTPException as e:
response = Response(route=route)
response.set_status(e.status)
response.json({"message": e.text, "status": e.status})
except VMError as e:
log.error("VM error detected: {type}".format(type=type(e)), exc_info=1)
response = Response(route=route)
response.set_status(409)
response.json({"message": str(e), "status": 409})
except Exception as e:
log.error("Uncaught exception detected: {type}".format(type=type(e)), exc_info=1)
response = Response(route=route)
response.set_status(500)
CrashReport.instance().capture_exception(request)
exc_type, exc_value, exc_tb = sys.exc_info()
lines = traceback.format_exception(exc_type, exc_value, exc_tb)
if api_version is not None:
tb = "".join(lines)
response.json({"message": tb, "status": 500})
else:
tb = "\n".join(lines)
response.html("<h1>Internal error</h1><pre>{}</pre>".format(tb))
return response
@asyncio.coroutine
def vm_concurrency(request):
"""
To avoid strange effect we prevent concurrency
between the same instance of the vm
"""
if "vm_id" in request.match_info or "device_id" in request.match_info:
vm_id = request.match_info.get("vm_id")
if vm_id is None:
vm_id = request.match_info["device_id"]
cls._vm_locks.setdefault(vm_id, asyncio.Lock())
with (yield from cls._vm_locks[vm_id]):
response = yield from control_schema(request)
else:
response = yield from control_schema(request)
return response
cls._routes.append((method, cls._path, vm_concurrency))
return vm_concurrency
return register
@classmethod
def get_routes(cls):
return cls._routes
@classmethod
def get_documentation(cls):
return cls._documentation