Notif forwarded from hypervisor to controller

gns3server/controller/__init__.py

@@ -45,7 +45,7 @@ class Controller:
         :param kwargs: See the documentation of Hypervisor
         """
         if hypervisor_id not in self._hypervisors:
-            hypervisor = Hypervisor(hypervisor_id=hypervisor_id, **kwargs)
+            hypervisor = Hypervisor(hypervisor_id=hypervisor_id, controller=self, **kwargs)
             self._hypervisors[hypervisor_id] = hypervisor
         return self._hypervisors[hypervisor_id]
 
@@ -109,3 +109,18 @@ class Controller:
         if not hasattr(Controller, '_instance') or Controller._instance is None:
             Controller._instance = Controller()
         return Controller._instance
+
+    def emit(self, action, event, **kwargs):
+        """
+        Send a notification to clients scoped by projects
+        """
+
+        if "project_id" in kwargs:
+            try:
+                project_id = kwargs.pop("project_id")
+                self._projects[project_id].emit(action, event, **kwargs)
+            except KeyError:
+                pass
+        else:
+            for project in self._projects.values():
+                project.emit(action, event, **kwargs)

gns3server/controller/hypervisor.py

@@ -38,7 +38,8 @@ class Hypervisor:
     A GNS3 hypervisor.
     """
 
-    def __init__(self, hypervisor_id, protocol="http", host="localhost", port=8000, user=None, password=None):
+    def __init__(self, hypervisor_id, controller=None, protocol="http", host="localhost", port=8000, user=None, password=None):
+        assert controller is not None
         log.info("Create hypervisor %s", hypervisor_id)
         self._id = hypervisor_id
         self._protocol = protocol
@@ -48,15 +49,19 @@ class Hypervisor:
         self._password = None
         self._setAuth(user, password)
         self._connected = False
-        # The remote hypervisor version
-        # TODO: For the moment it's fake we return the controller version
-        self._version = __version__
+        self._controller = controller
+        self._session = aiohttp.ClientSession()
 
         # If the hypervisor is local but the hypervisor id is local
         # it's a configuration issue
         if hypervisor_id == "local" and Config.instance().get_section_config("Server")["local"] is False:
             raise HypervisorError("The local hypervisor is started without --local")
 
+        asyncio.async(self._connect())
+
+    def __del__(self):
+        self._session.close()
+
     def _setAuth(self, user, password):
         """
         Set authentication parameters
@@ -110,6 +115,15 @@ class Hypervisor:
 
     @asyncio.coroutine
     def httpQuery(self, method, path, data=None):
+        if not self._connected:
+            yield from self._connect()
+        return (yield from self._runHttpQuery(method, path, data=data))
+
+    @asyncio.coroutine
+    def _connect(self):
+        """
+        Check if remote server is accessible
+        """
         if not self._connected:
             response = yield from self._runHttpQuery("GET", "/version")
             if "version" not in response.json:
@@ -117,45 +131,64 @@ class Hypervisor:
             if parse_version(__version__)[:2] != parse_version(response.json["version"])[:2]:
                 raise aiohttp.web.HTTPConflict(text="The server {} versions are not compatible {} != {}".format(self._id, __version__, response.json["version"]))
 
-        self._connected = True
-        return (yield from self._runHttpQuery(method, path, data=data))
+            self._notifications = asyncio.async(self._connectNotification())
+
+            self._connected = True
+
+    @asyncio.coroutine
+    def _connectNotification(self):
+        """
+        Connect to the notification stream
+        """
+        ws = yield from self._session.ws_connect(self._getUrl("/notifications/ws"), auth=self._auth)
+        while True:
+            response = yield from ws.receive()
+            if response.tp == aiohttp.MsgType.closed or response.tp == aiohttp.MsgType.error:
+                self._connected = False
+                break
+            msg = json.loads(response.data)
+            action = msg.pop("action")
+            event = msg.pop("event")
+            self._controller.emit(action, event, hypervisor_id=self.id, **msg)
+
+    def _getUrl(self, path):
+        return "{}://{}:{}/v2/hypervisor{}".format(self._protocol, self._host, self._port, path)
 
     @asyncio.coroutine
     def _runHttpQuery(self, method, path, data=None):
         with aiohttp.Timeout(10):
-            with aiohttp.ClientSession() as session:
-                url = "{}://{}:{}/v2/hypervisor{}".format(self._protocol, self._host, self._port, path)
-                headers = {'content-type': 'application/json'}
-                if data:
-                    if hasattr(data, '__json__'):
-                        data = data.__json__()
-                    data = json.dumps(data)
-                response = yield from session.request(method, url, headers=headers, data=data, auth=self._auth)
-                body = yield from response.read()
-                if body:
-                    body = body.decode()
+            url = self._getUrl(path)
+            headers = {'content-type': 'application/json'}
+            if data:
+                if hasattr(data, '__json__'):
+                    data = data.__json__()
+                data = json.dumps(data)
+            response = yield from self._session.request(method, url, headers=headers, data=data, auth=self._auth)
+            body = yield from response.read()
+            if body:
+                body = body.decode()
 
-                if response.status >= 300:
-                    if response.status == 400:
-                        raise aiohttp.web.HTTPBadRequest(text="Bad request {} {}".format(url, body))
-                    elif response.status == 401:
-                        raise aiohttp.web.HTTPUnauthorized(text="Invalid authentication for hypervisor {}".format(self.id))
-                    elif response.status == 403:
-                        raise aiohttp.web.HTTPForbidden(text="Forbidden {} {}".format(url, body))
-                    elif response.status == 404:
-                        raise aiohttp.web.HTTPNotFound(text="{} not found on hypervisor".format(url))
-                    elif response.status == 409:
-                        raise aiohttp.web.HTTPConflict(text="Conflict {} {}".format(url, body))
-                    else:
-                        raise NotImplemented("{} status code is not supported".format(e.status))
-                if body and len(body):
-                    try:
-                        response.json = json.loads(body)
-                    except json.JSONDecodeError:
-                        raise aiohttp.web.HTTPConflict(text="The server {} is not a GNS3 server".format(self._id))
-                if response.json is None:
-                    response.json = {}
-                return response
+            if response.status >= 300:
+                if response.status == 400:
+                    raise aiohttp.web.HTTPBadRequest(text="Bad request {} {}".format(url, body))
+                elif response.status == 401:
+                    raise aiohttp.web.HTTPUnauthorized(text="Invalid authentication for hypervisor {}".format(self.id))
+                elif response.status == 403:
+                    raise aiohttp.web.HTTPForbidden(text="Forbidden {} {}".format(url, body))
+                elif response.status == 404:
+                    raise aiohttp.web.HTTPNotFound(text="{} not found on hypervisor".format(url))
+                elif response.status == 409:
+                    raise aiohttp.web.HTTPConflict(text="Conflict {} {}".format(url, body))
+                else:
+                    raise NotImplementedError("{} status code is not supported".format(response.status))
+            if body and len(body):
+                try:
+                    response.json = json.loads(body)
+                except json.JSONDecodeError:
+                    raise aiohttp.web.HTTPConflict(text="The server {} is not a GNS3 server".format(self._id))
+            if response.json is None:
+                response.json = {}
+            return response
 
     @asyncio.coroutine
     def post(self, path, data={}):

gns3server/controller/link.py

@@ -42,14 +42,14 @@ class Link:
         """
         Create the link
         """
-        raise NotImplemented
+        raise NotImplementedError
 
     @asyncio.coroutine
     def delete(self):
         """
         Delete the link
         """
-        raise NotImplemented
+        raise NotImplementedError
 
     @property
     def id(self):

gns3server/hypervisor/base_vm.py

@@ -218,6 +218,7 @@ class BaseVM:
         log.info("{module}: {name} [{id}] created".format(module=self.manager.module_name,
                                                           name=self.name,
                                                           id=self.id))
+        self._project.emit("vm.created", self)
 
     @asyncio.coroutine
     def delete(self):
@@ -225,6 +226,7 @@ class BaseVM:
         Delete the VM (including all its files).
         """
 
+        self._project.emit("vm.deleted", self)
         directory = self.project.vm_working_directory(self)
         if os.path.exists(directory):
             try: