Merge pull request #1036 from GNS3/aiohttp_2.0

Aiohttp 2.0

gns3server/compute/docker/__init__.py

@@ -56,7 +56,7 @@ class Docker(BaseManager):
                 self._connected = True
                 connector = self.connector()
                 version = yield from self.query("GET", "version")
-            except (aiohttp.errors.ClientOSError, FileNotFoundError):
+            except (aiohttp.ClientOSError, FileNotFoundError):
                 self._connected = False
                 raise DockerError("Can't connect to docker daemon")
             if parse_version(version["ApiVersion"]) < parse_version(DOCKER_MINIMUM_API_VERSION):
@@ -68,7 +68,7 @@ class Docker(BaseManager):
                 raise DockerError("Docker is supported only on Linux")
             try:
                 self._connector = aiohttp.connector.UnixConnector(self._server_url, conn_timeout=2, limit=None)
-            except (aiohttp.errors.ClientOSError, FileNotFoundError):
+            except (aiohttp.ClientOSError, FileNotFoundError):
                 raise DockerError("Can't connect to docker daemon")
         return self._connector
 
@@ -77,7 +77,7 @@ class Docker(BaseManager):
         yield from super().unload()
         if self._connected:
             if self._connector and not self._connector.closed:
-                yield from self._connector.close()
+                self._connector.close()
 
     @asyncio.coroutine
     def query(self, method, path, data={}, params={}):
@@ -191,7 +191,7 @@ class Docker(BaseManager):
         while True:
             try:
                 chunk = yield from response.content.read(1024)
-            except aiohttp.errors.ServerDisconnectedError:
+            except aiohttp.ServerDisconnectedError:
                 break
             if not chunk:
                 break

gns3server/compute/docker/docker_vm.py

@@ -500,7 +500,7 @@ class DockerVM(BaseNode):
 
         while True:
             msg = yield from ws.receive()
-            if msg.tp == aiohttp.MsgType.text:
+            if msg.tp == aiohttp.WSMsgType.text:
                 out.feed_data(msg.data.encode())
             else:
                 out.feed_eof()

gns3server/controller/compute.py

@@ -421,15 +421,15 @@ class Compute:
         """
         try:
             self._ws = yield from self._session().ws_connect(self._getUrl("/notifications/ws"), auth=self._auth)
-        except (aiohttp.errors.WSServerHandshakeError, aiohttp.errors.ClientResponseError):
+        except (aiohttp.WSServerHandshakeError, aiohttp.ClientResponseError):
             self._ws = None
         while self._ws is not None:
             try:
                 response = yield from self._ws.receive()
-            except aiohttp.errors.WSServerHandshakeError:
+            except aiohttp.WSServerHandshakeError:
                 self._ws = None
                 break
-            if response.tp == aiohttp.MsgType.closed or response.tp == aiohttp.MsgType.error or response.data is None:
+            if response.tp == aiohttp.WSMsgType.closed or response.tp == aiohttp.WSMsgType.error or response.data is None:
                 self._connected = False
                 break
             msg = json.loads(response.data)
@@ -474,7 +474,7 @@ class Compute:
             url = self._getUrl(path)
             headers = {}
             headers['content-type'] = 'application/json'
-            chunked = False
+            chunked = None
             if data == {}:
                 data = None
             elif data is not None:
@@ -500,12 +500,12 @@ class Compute:
 
                     data = send_data(data)
                 else:
-                    data = json.dumps(data)
+                    data = json.dumps(data).encode("utf-8")
         try:
             response = yield from self._session().request(method, url, headers=headers, data=data, auth=self._auth, chunked=chunked, timeout=timeout)
         except asyncio.TimeoutError as e:
             raise ComputeError("Timeout error when connecting to {}".format(url))
-        except (aiohttp.errors.ClientOSError, aiohttp.errors.ClientRequestError, aiohttp.errors.ServerDisconnectedError, aiohttp.ClientResponseError, ValueError) as e:
+        except (aiohttp.ClientError, aiohttp.ServerDisconnectedError, ValueError) as e:
             raise ComputeError(str(e))
         body = yield from response.read()
         if body and not raw:
@@ -581,7 +581,7 @@ class Compute:
         """
         try:
             res = yield from self.http_query(method, "/{}/{}".format(type, path), data=data, timeout=None)
-        except aiohttp.errors.DisconnectedError:
+        except aiohttp.ServerDisconnectedError:
             raise aiohttp.web.HTTPGatewayTimeout()
         return res.json
 

gns3server/controller/gns3vm/virtualbox_gns3_vm.py

@@ -228,7 +228,7 @@ class VirtualBoxGNS3VM(BaseGNS3VM):
             try:
                 resp = None
                 resp = yield from session.get('http://127.0.0.1:{}/v2/compute/network/interfaces'.format(api_port))
-            except (OSError, aiohttp.errors.ClientHttpProcessingError, TimeoutError, asyncio.TimeoutError):
+            except (OSError, aiohttp.ClientError, TimeoutError, asyncio.TimeoutError):
                 pass
 
             if resp:

gns3server/controller/node.py

@@ -457,7 +457,7 @@ class Node:
         try:
             yield from self.post("/stop", timeout=240, dont_connect=True)
         # We don't care if a node is down at this step
-        except (ComputeError, aiohttp.errors.ClientHttpProcessingError, aiohttp.web.HTTPError):
+        except (ComputeError, aiohttp.ClientError, aiohttp.web.HTTPError):
             pass
         except asyncio.TimeoutError:
             raise aiohttp.web.HTTPRequestTimeout(text="Timeout when stopping {}".format(self._name))

gns3server/crash_report.py

@@ -45,7 +45,10 @@ if __version_info__[3] != 0:
     # Display a traceback in case of segfault crash. Usefull when frozen
     # Not enabled by default for security reason
     log.info("Enable catching segfault")
-    faulthandler.enable()
+    try:
+        faulthandler.enable()
+    except Exception:
+        pass  # Could fail when loaded into tests
 
 
 class CrashReport:

gns3server/handlers/api/compute/notification_handler.py

@@ -16,8 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import asyncio
-import aiohttp.errors
-
+import aiohttp
 from aiohttp.web import WebSocketResponse
 from gns3server.web.route import Route
 from gns3server.compute.notification_manager import NotificationManager
@@ -30,7 +29,7 @@ def process_websocket(ws):
     """
     try:
         yield from ws.receive()
-    except aiohttp.errors.WSServerHandshakeError:
+    except aiohttp.WSServerHandshakeError:
         pass
 
 

gns3server/handlers/api/compute/project_handler.py

@@ -157,7 +157,6 @@ class ProjectHandler:
         response.set_status(200)
         response.enable_chunked_encoding()
         # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-        response.content_length = None
 
         response.start(request)
         queue = project.get_listen_queue()
@@ -240,11 +239,10 @@ class ProjectHandler:
         response.set_status(200)
         response.enable_chunked_encoding()
         # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-        response.content_length = None
 
         try:
             with open(path, "rb") as f:
-                response.start(request)
+                yield from response.prepare(request)
                 while True:
                     data = f.read(4096)
                     if not data:
@@ -274,7 +272,7 @@ class ProjectHandler:
         path = request.match_info["path"]
         path = os.path.normpath(path)
 
-        # Raise an error if user try to escape
+        # Raise an error if user try to escape
         if path[0] == ".":
             raise aiohttp.web.HTTPForbidden
         path = os.path.join(project.path, path)
@@ -283,11 +281,10 @@ class ProjectHandler:
         response.set_status(200)
         response.enable_chunked_encoding()
         # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-        response.content_length = None
 
         try:
             with open(path, "rb") as f:
-                response.start(request)
+                yield from response.prepare(request)
                 while True:
                     data = f.read(4096)
                     if not data:
@@ -358,8 +355,7 @@ class ProjectHandler:
         response.headers['CONTENT-DISPOSITION'] = 'attachment; filename="{}.gns3project"'.format(project.name)
         response.enable_chunked_encoding()
         # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-        response.content_length = None
-        response.start(request)
+        yield from response.prepare(request)
 
         include_images = bool(int(request.json.get("include_images", "0")))
         for data in project.export(include_images=include_images):

gns3server/handlers/api/controller/link_handler.py

@@ -179,8 +179,7 @@ class LinkHandler:
                 response.set_status(200)
                 response.enable_chunked_encoding()
                 # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-                response.content_length = None
-                response.start(request)
+                yield from response.prepare(request)
 
                 while True:
                     chunk = f.read(4096)

gns3server/handlers/api/controller/node_handler.py

@@ -351,8 +351,7 @@ class NodeHandler:
         response.set_status(200)
         response.content_type = "application/octet-stream"
         response.enable_chunked_encoding()
-        response.content_length = None
-        response.start(request)
+        yield from response.prepare(request)
 
         response.write(res.body)
         yield from response.write_eof()

gns3server/handlers/api/controller/project_handler.py

@@ -17,7 +17,6 @@
 
 import os
 import aiohttp
-import aiohttp.errors
 import asyncio
 import tempfile
 
@@ -47,7 +46,7 @@ def process_websocket(ws):
     """
     try:
         yield from ws.receive()
-    except aiohttp.errors.WSServerHandshakeError:
+    except aiohttp.WSServerHandshakeError:
         pass
 
 
@@ -212,9 +211,8 @@ class ProjectHandler:
         response.set_status(200)
         response.enable_chunked_encoding()
         # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-        response.content_length = None
 
-        response.start(request)
+        yield from response.prepare(request)
         with controller.notification.queue(project) as queue:
             while True:
                 try:
@@ -295,8 +293,7 @@ class ProjectHandler:
                 response.headers['CONTENT-DISPOSITION'] = 'attachment; filename="{}.gns3project"'.format(project.name)
                 response.enable_chunked_encoding()
                 # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-                response.content_length = None
-                response.start(request)
+                yield from response.prepare(request)
 
                 for data in datas:
                     response.write(data)
@@ -408,11 +405,10 @@ class ProjectHandler:
         response.set_status(200)
         response.enable_chunked_encoding()
         # Very important: do not send a content length otherwise QT closes the connection (curl can consume the feed)
-        response.content_length = None
 
         try:
             with open(path, "rb") as f:
-                response.start(request)
+                yield from response.prepare(request)
                 while True:
                     data = f.read(4096)
                     if not data:

gns3server/web/response.py

@@ -120,10 +120,10 @@ class Response(aiohttp.web.Response):
 
         st = os.stat(path)
         self.last_modified = st.st_mtime
-        self.content_length = st.st_size
+        self.headers[aiohttp.hdrs.CONTENT_LENGTH] = str(st.st_size)
 
         with open(path, 'rb') as fobj:
-            self.start(self._request)
+            yield from self.prepare(self._request)
             chunk_size = 4096
             chunk = fobj.read(chunk_size)
             while chunk:

gns3server/web/route.py

@@ -220,16 +220,11 @@ class Route(object):
                     response = Response(request=request, route=route)
                     response.set_status(408)
                     response.json({"message": "Request canceled", "status": 408})
-                except aiohttp.ClientDisconnectedError:
-                    log.warn("Client disconnected")
+                except aiohttp.ClientError:
+                    log.warn("Client error")
                     response = Response(request=request, route=route)
                     response.set_status(408)
-                    response.json({"message": "Client disconnected", "status": 408})
-                except ConnectionResetError:
-                    log.error("Client connection reset")
-                    response = Response(request=request, route=route)
-                    response.set_status(408)
-                    response.json({"message": "Connection reset", "status": 408})
+                    response.json({"message": "Client error", "status": 408})
                 except Exception as e:
                     log.error("Uncaught exception detected: {type}".format(type=type(e)), exc_info=1)
                     response = Response(request=request, route=route)