gns3-server/gns3server/controller/compute.py

677 lines
26 KiB
Python
Raw Normal View History

#!/usr/bin/env python
#
# Copyright (C) 2016 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/>.
2016-08-25 17:14:29 +00:00
import ipaddress
import aiohttp
import asyncio
import async_timeout
import socket
import json
import uuid
import sys
2016-06-07 17:38:01 +00:00
import io
from operator import itemgetter
2016-05-14 00:48:10 +00:00
from ..utils import parse_version
from ..utils.asyncio import locking
2020-10-02 06:37:50 +00:00
from ..controller.controller_error import (
ControllerError,
ControllerNotFoundError,
ControllerForbiddenError,
ControllerTimeoutError,
ControllerUnauthorizedError)
from ..version import __version__, __version_info__
2016-03-04 15:55:59 +00:00
import logging
log = logging.getLogger(__name__)
2016-04-15 15:57:06 +00:00
class ComputeError(ControllerError):
pass
2020-10-02 06:37:50 +00:00
# FIXME: broken
class ComputeConflict(ComputeError):
2016-06-07 17:38:01 +00:00
"""
Raise when the compute send a 409 that we can handle
:param response: The response of the compute
"""
2016-06-07 17:38:01 +00:00
def __init__(self, response):
2020-10-02 06:37:50 +00:00
super().__init__(response["message"])
2016-06-07 17:38:01 +00:00
self.response = response
2016-04-15 15:57:06 +00:00
class Compute:
"""
2016-04-15 15:57:06 +00:00
A GNS3 compute.
"""
def __init__(self, compute_id, controller=None, protocol="http", host="localhost", port=3080, user=None,
password=None, name=None, console_host=None):
self._http_session = None
assert controller is not None
2016-04-15 15:57:06 +00:00
log.info("Create compute %s", compute_id)
if compute_id is None:
self._id = str(uuid.uuid4())
else:
self._id = compute_id
self.protocol = protocol
self._console_host = console_host
self.host = host
self.port = port
self._user = None
self._password = None
self._connected = False
self._notifications = None
2016-08-29 15:36:24 +00:00
self._closed = False # Close mean we are destroying the compute node
self._controller = controller
2016-05-11 21:19:00 +00:00
self._set_auth(user, password)
2020-10-02 06:37:50 +00:00
self._cpu_usage_percent = 0
self._memory_usage_percent = 0
self._disk_usage_percent = 0
self._last_error = None
self._capabilities = {
2020-10-02 06:37:50 +00:00
"version": "",
"platform": "",
"cpus": 0,
"memory": 0,
"disk_size": 0,
"node_types": []
}
self.name = name
2016-08-25 17:14:29 +00:00
# Cache of interfaces on remote host
self._interfaces_cache = None
self._connection_failure = 0
def _session(self):
if self._http_session is None or self._http_session.closed is True:
connector = aiohttp.TCPConnector(force_close=True)
self._http_session = aiohttp.ClientSession(connector=connector)
return self._http_session
2016-05-11 21:19:00 +00:00
def _set_auth(self, user, password):
"""
Set authentication parameters
"""
if user is None or len(user.strip()) == 0:
self._user = None
self._password = None
self._auth = None
else:
self._user = user.strip()
2016-05-26 11:32:52 +00:00
if password:
self._password = password.strip()
try:
self._auth = aiohttp.BasicAuth(self._user, self._password, "utf-8")
except ValueError as e:
log.error(str(e))
2016-05-26 11:32:52 +00:00
else:
self._password = None
self._auth = aiohttp.BasicAuth(self._user, "")
def set_last_error(self, msg):
"""
Set the last error message for this compute.
:param msg: message
"""
self._last_error = msg
async def interfaces(self):
2016-08-25 17:14:29 +00:00
"""
Get the list of network on compute
"""
if not self._interfaces_cache:
response = await self.get("/network/interfaces")
2016-08-25 17:14:29 +00:00
self._interfaces_cache = response.json
return self._interfaces_cache
async def update(self, **kwargs):
for kw in kwargs:
2016-10-27 14:54:05 +00:00
if kw not in ("user", "password"):
setattr(self, kw, kwargs[kw])
# It's important to set user and password at the same time
if "user" in kwargs or "password" in kwargs:
self._set_auth(kwargs.get("user", self._user), kwargs.get("password", self._password))
if self._http_session and not self._http_session.closed:
await self._http_session.close()
self._connected = False
self._controller.notification.controller_emit("compute.updated", self.__json__())
self._controller.save()
async def close(self):
self._connected = False
if self._http_session and not self._http_session.closed:
await self._http_session.close()
try:
if self._notifications:
await self._notifications
except asyncio.CancelledError:
pass
2016-08-29 15:36:24 +00:00
self._closed = True
@property
def name(self):
"""
:returns: Compute name
"""
return self._name
@name.setter
def name(self, name):
if name is not None:
self._name = name
else:
if self._user:
user = self._user
# Due to random user generated by 1.4 it's common to have a very long user
if len(user) > 14:
user = user[:11] + "..."
self._name = "{}://{}@{}:{}".format(self._protocol, user, self._host, self._port)
else:
self._name = "{}://{}:{}".format(self._protocol, self._host, self._port)
2016-05-11 14:31:16 +00:00
@property
def connected(self):
"""
:returns: True if compute node is connected
"""
return self._connected
@property
def id(self):
"""
2016-04-15 15:57:06 +00:00
:returns: Compute identifier (string)
"""
return self._id
@property
def host(self):
"""
2016-04-15 15:57:06 +00:00
:returns: Compute host (string)
"""
return self._host
2016-08-25 17:14:29 +00:00
@property
def host_ip(self):
"""
Return the IP associated to the host
"""
try:
return socket.gethostbyname(self._host)
except socket.gaierror:
return '0.0.0.0'
2016-08-25 17:14:29 +00:00
@host.setter
def host(self, host):
self._host = host
if self._console_host is None:
self._console_host = host
@property
def console_host(self):
return self._console_host
2016-04-19 13:35:50 +00:00
@property
def port(self):
"""
:returns: Compute port (integer)
"""
return self._port
@port.setter
def port(self, port):
self._port = port
2016-04-19 13:35:50 +00:00
@property
def protocol(self):
"""
:returns: Compute protocol (string)
"""
return self._protocol
@protocol.setter
def protocol(self, protocol):
self._protocol = protocol
@property
def user(self):
return self._user
@user.setter
def user(self, value):
2016-05-11 21:19:00 +00:00
self._set_auth(value, self._password)
@property
def password(self):
return self._password
@password.setter
def password(self, value):
2016-05-11 21:19:00 +00:00
self._set_auth(self._user, value)
@property
def cpu_usage_percent(self):
return self._cpu_usage_percent
@property
def memory_usage_percent(self):
return self._memory_usage_percent
@property
def disk_usage_percent(self):
return self._disk_usage_percent
2016-06-15 13:12:38 +00:00
def __json__(self, topology_dump=False):
"""
:param topology_dump: Filter to keep only properties require for saving on disk
"""
if topology_dump:
return {
"compute_id": self._id,
"name": self._name,
"protocol": self._protocol,
"host": self._host,
"port": self._port
2016-06-15 13:12:38 +00:00
}
return {
2016-04-15 15:57:06 +00:00
"compute_id": self._id,
"name": self._name,
"protocol": self._protocol,
"host": self._host,
"port": self._port,
"user": self._user,
"connected": self._connected,
"cpu_usage_percent": self._cpu_usage_percent,
"memory_usage_percent": self._memory_usage_percent,
"disk_usage_percent": self._disk_usage_percent,
"capabilities": self._capabilities,
"last_error": self._last_error
}
async def download_file(self, project, path):
2016-07-21 18:17:36 +00:00
"""
Read file of a project and download it
:param project: A project object
:param path: The path of the file in the project
:returns: A file stream
"""
url = self._getUrl("/projects/{}/files/{}".format(project.id, path))
response = await self._session().request("GET", url, auth=self._auth)
2016-07-21 18:17:36 +00:00
if response.status == 404:
2020-10-02 06:37:50 +00:00
raise ControllerNotFoundError("{} not found on compute".format(path))
2016-09-19 14:51:15 +00:00
return response
2016-07-21 18:17:36 +00:00
async def download_image(self, image_type, image):
"""
Read file of a project and download it
:param image_type: Image type
:param image: The path of the image
:returns: A file stream
"""
url = self._getUrl("/{}/images/{}".format(image_type, image))
response = await self._session().request("GET", url, auth=self._auth)
if response.status == 404:
2020-10-02 06:37:50 +00:00
raise ControllerNotFoundError("{} not found on compute".format(image))
return response
async def http_query(self, method, path, data=None, dont_connect=False, **kwargs):
"""
:param dont_connect: If true do not reconnect if not connected
"""
if not self._connected and not dont_connect:
if self._id == "vm" and not self._controller.gns3vm.running:
await self._controller.gns3vm.start()
await self.connect()
if not self._connected and not dont_connect:
raise ComputeError("Cannot connect to compute '{}' with request {} {}".format(self._name, method, path))
response = await self._run_http_query(method, path, data=data, **kwargs)
2016-04-14 10:22:10 +00:00
return response
async def _try_reconnect(self):
"""
We catch error during reconnect
"""
try:
await self.connect()
2020-10-02 06:37:50 +00:00
except ControllerError:
pass
@locking
async def connect(self):
"""
Check if remote server is accessible
"""
if not self._connected and not self._closed and self.host:
try:
log.info("Connecting to compute '{}'".format(self._id))
response = await self._run_http_query("GET", "/capabilities")
except ComputeError as e:
log.warning("Cannot connect to compute '{}': {}".format(self._id, e))
# Try to reconnect after 5 seconds if server unavailable only if not during tests (otherwise we create a ressource usage bomb)
if not hasattr(sys, "_called_from_test") or not sys._called_from_test:
if self.id != "local" and self.id != "vm" and not self._controller.compute_has_open_project(self):
log.warning("Not reconnecting to compute '{}' because there is no project opened on it".format(self._id))
return
self._connection_failure += 1
# After 5 failure we close the project using the compute to avoid sync issues
if self._connection_failure == 10:
log.error("Could not connect to compute '{}' after multiple attempts: {}".format(self._id, e))
await self._controller.close_compute_projects(self)
asyncio.get_event_loop().call_later(5, lambda: asyncio.ensure_future(self._try_reconnect()))
return
except aiohttp.web.HTTPNotFound:
2020-10-02 06:37:50 +00:00
raise ControllerNotFoundError("The server {} is not a GNS3 server or it's a 1.X server".format(self._id))
except aiohttp.web.HTTPUnauthorized:
2020-10-02 06:37:50 +00:00
raise ControllerUnauthorizedError("Invalid auth for server {}".format(self._id))
except aiohttp.web.HTTPServiceUnavailable:
2020-10-02 06:37:50 +00:00
raise ControllerNotFoundError("The server {} is unavailable".format(self._id))
except ValueError:
2020-10-02 06:37:50 +00:00
raise ComputeError("Invalid server url for server {}".format(self._id))
2016-04-20 14:24:30 +00:00
if "version" not in response.json:
msg = "The server {} is not a GNS3 server".format(self._id)
log.error(msg)
await self._http_session.close()
2020-10-02 06:37:50 +00:00
raise ControllerNotFoundError(msg)
self._capabilities = response.json
if response.json["version"].split("-")[0] != __version__.split("-")[0]:
2018-09-28 13:04:38 +00:00
if self._name.startswith("GNS3 VM"):
msg = "GNS3 version {} is not the same as the GNS3 VM version {}. Please upgrade the GNS3 VM.".format(__version__,
response.json["version"])
else:
msg = "GNS3 controller version {} is not the same as compute {} version {}".format(__version__,
self._name,
response.json["version"])
if __version_info__[3] == 0:
# Stable release
log.error(msg)
await self._http_session.close()
self._last_error = msg
2020-10-02 06:37:50 +00:00
raise ControllerError(msg)
elif parse_version(__version__)[:2] != parse_version(response.json["version"])[:2]:
# We don't allow different major version to interact even with dev build
log.error(msg)
await self._http_session.close()
self._last_error = msg
2020-10-02 06:37:50 +00:00
raise ControllerError(msg)
else:
msg = "{}\nUsing different versions may result in unexpected problems. Please use at your own risk.".format(msg)
self._controller.notification.controller_emit("log.warning", {"message": msg})
self._notifications = asyncio.gather(self._connect_notification())
self._connected = True
self._connection_failure = 0
self._last_error = None
self._controller.notification.controller_emit("compute.updated", self.__json__())
async def _connect_notification(self):
"""
Connect to the notification stream
"""
ws_url = self._getUrl("/notifications/ws")
try:
async with self._session().ws_connect(ws_url, auth=self._auth, heartbeat=10) as ws:
log.info("Connected to compute '{}' WebSocket '{}'".format(self._id, ws_url))
async for response in ws:
if response.type == aiohttp.WSMsgType.TEXT:
msg = json.loads(response.data)
action = msg.pop("action")
event = msg.pop("event")
project_id = msg.pop("project_id", None)
if action == "ping":
self._cpu_usage_percent = event["cpu_usage_percent"]
self._memory_usage_percent = event["memory_usage_percent"]
self._disk_usage_percent = event["disk_usage_percent"]
#FIXME: slow down number of compute events
self._controller.notification.controller_emit("compute.updated", self.__json__())
else:
await self._controller.notification.dispatch(action, event, project_id=project_id, compute_id=self.id)
else:
if response.type == aiohttp.WSMsgType.CLOSE:
await ws.close()
elif response.type == aiohttp.WSMsgType.ERROR:
log.error("Error received on compute '{}' WebSocket '{}': {}".format(self._id, ws_url, ws.exception()))
elif response.type == aiohttp.WSMsgType.CLOSED:
pass
break
except aiohttp.ClientError as e:
log.error("Client response error received on compute '{}' WebSocket '{}': {}".format(self._id, ws_url,e))
finally:
self._connected = False
log.info("Connection closed to compute '{}' WebSocket '{}'".format(self._id, ws_url))
# Try to reconnect after 1 second if server unavailable only if not during tests (otherwise we create a ressources usage bomb)
if not hasattr(sys, "_called_from_test") or not sys._called_from_test:
asyncio.get_event_loop().call_later(1, lambda: asyncio.ensure_future(self.connect()))
2016-08-29 15:36:24 +00:00
self._cpu_usage_percent = None
self._memory_usage_percent = None
self._disk_usage_percent = None
self._controller.notification.controller_emit("compute.updated", self.__json__())
def _getUrl(self, path):
2016-10-17 12:10:25 +00:00
host = self._host
# IPV6
if host:
# IPV6
if ":" in host:
# Reduce IPV6 to his simple form
host = str(ipaddress.IPv6Address(host))
if host == "::":
host = "::1"
host = "[{}]".format(host)
elif host == "0.0.0.0":
host = "127.0.0.1"
2016-10-17 12:10:25 +00:00
return "{}://{}:{}/v2/compute{}".format(self._protocol, host, self._port, path)
def get_url(self, path):
""" Returns URL for specific path at Compute"""
return self._getUrl(path)
async def _run_http_query(self, method, path, data=None, timeout=20, raw=False):
with async_timeout.timeout(timeout):
url = self._getUrl(path)
headers = {}
headers['content-type'] = 'application/json'
2017-05-16 17:28:47 +00:00
chunked = None
2016-04-14 10:22:10 +00:00
if data == {}:
data = None
elif data is not None:
if hasattr(data, '__json__'):
data = json.dumps(data.__json__())
elif isinstance(data, aiohttp.streams.EmptyStreamReader):
data = None
# Stream the request
elif isinstance(data, aiohttp.streams.StreamReader) or isinstance(data, bytes):
chunked = True
headers['content-type'] = 'application/octet-stream'
# If the data is an open file we will iterate on it
elif isinstance(data, io.BufferedIOBase):
chunked = True
headers['content-type'] = 'application/octet-stream'
else:
2017-05-16 17:28:47 +00:00
data = json.dumps(data).encode("utf-8")
try:
log.debug("Attempting request to compute: {method} {url} {headers}".format(method=method, url=url, headers=headers))
response = await self._session().request(method, url, headers=headers, data=data, auth=self._auth, chunked=chunked, timeout=timeout)
except asyncio.TimeoutError:
raise ComputeError("Timeout error for {} call to {} after {}s".format(method, url, timeout))
2020-10-02 06:37:50 +00:00
except (aiohttp.ClientError, aiohttp.ServerDisconnectedError, aiohttp.ClientResponseError, ValueError, KeyError, socket.gaierror) as e:
2017-10-26 14:29:01 +00:00
# aiohttp 2.3.1 raises socket.gaierror when cannot find host
raise ComputeError(str(e))
body = await response.read()
2016-07-27 16:31:02 +00:00
if body and not raw:
body = body.decode()
if response.status >= 300:
# Try to decode the GNS3 error
2016-07-27 16:31:02 +00:00
if body and not raw:
try:
msg = json.loads(body)["message"]
except (KeyError, ValueError):
msg = body
else:
msg = ""
2020-10-02 06:37:50 +00:00
if response.status == 401:
raise ControllerUnauthorizedError("Invalid authentication for compute {}".format(self.id))
elif response.status == 403:
2020-10-02 06:37:50 +00:00
raise ControllerForbiddenError(msg)
elif response.status == 404:
2020-10-02 06:37:50 +00:00
raise ControllerNotFoundError("{} {} not found".format(method, path))
elif response.status == 408 or response.status == 504:
2020-10-02 06:37:50 +00:00
raise ControllerTimeoutError("{} {} request timeout".format(method, path))
elif response.status == 409:
try:
raise ComputeConflict(json.loads(body))
# If the 409 doesn't come from a GNS3 server
2016-05-11 21:19:00 +00:00
except ValueError:
2020-10-02 06:37:50 +00:00
raise ControllerError(msg)
elif response.status == 500:
raise aiohttp.web.HTTPInternalServerError(text="Internal server error {}".format(url))
elif response.status == 503:
raise aiohttp.web.HTTPServiceUnavailable(text="Service unavailable {} {}".format(url, body))
else:
raise NotImplementedError("{} status code is not supported for {} '{}'".format(response.status, method, url))
if body and len(body):
2016-07-27 16:31:02 +00:00
if raw:
response.body = body
else:
try:
response.json = json.loads(body)
except ValueError:
2020-10-02 06:37:50 +00:00
raise ControllerError("The server {} is not a GNS3 server".format(self._id))
else:
response.json = {}
2016-07-27 16:31:02 +00:00
response.body = b""
return response
async def get(self, path, **kwargs):
return await self.http_query("GET", path, **kwargs)
2016-04-14 10:22:10 +00:00
async def post(self, path, data={}, **kwargs):
response = await self.http_query("POST", path, data, **kwargs)
2016-04-14 10:22:10 +00:00
return response
2016-03-14 19:54:05 +00:00
async def put(self, path, data={}, **kwargs):
response = await self.http_query("PUT", path, data, **kwargs)
2016-04-18 15:36:38 +00:00
return response
async def delete(self, path, **kwargs):
2020-10-02 06:37:50 +00:00
return await self.http_query("DELETE", path, **kwargs)
async def forward(self, method, type, path, data=None):
"""
Forward a call to the emulator on compute
"""
try:
action = "/{}/{}".format(type, path)
res = await self.http_query(method, action, data=data, timeout=None)
2017-05-16 17:28:47 +00:00
except aiohttp.ServerDisconnectedError:
raise ControllerError(f"Connection lost to {self._id} during {method} {action}")
return res.json
async def images(self, type):
"""
Return the list of images available for this type on the compute node.
"""
res = await self.http_query("GET", "/{}/images".format(type), timeout=None)
images = res.json
try:
if type in ["qemu", "dynamips", "iou"]:
#for local_image in list_images(type):
# if local_image['filename'] not in [i['filename'] for i in images]:
# images.append(local_image)
2017-05-09 10:25:15 +00:00
images = sorted(images, key=itemgetter('filename'))
else:
images = sorted(images, key=itemgetter('image'))
except OSError as e:
raise ComputeError("Cannot list images: {}".format(str(e)))
return images
2016-07-21 18:17:36 +00:00
async def list_files(self, project):
2016-07-21 18:17:36 +00:00
"""
List files in the project on computes
"""
path = "/projects/{}/files".format(project.id)
res = await self.http_query("GET", path, timeout=None)
2016-07-21 18:17:36 +00:00
return res.json
2016-08-25 17:14:29 +00:00
async def get_ip_on_same_subnet(self, other_compute):
2016-08-25 17:14:29 +00:00
"""
2018-03-15 07:17:39 +00:00
Try to find the best ip for communication from one compute
2016-08-25 17:14:29 +00:00
to another
:returns: Tuple (ip_for_this_compute, ip_for_other_compute)
"""
if other_compute == self:
return self.host_ip, self.host_ip
2016-08-25 17:14:29 +00:00
# Perhaps the user has correct network gateway, we trust him
if self.host_ip not in ('0.0.0.0', '127.0.0.1') and other_compute.host_ip not in ('0.0.0.0', '127.0.0.1'):
return self.host_ip, other_compute.host_ip
this_compute_interfaces = await self.interfaces()
other_compute_interfaces = await other_compute.interfaces()
2016-08-25 17:14:29 +00:00
# Sort interface to put the compute host in first position
# we guess that if user specified this host it could have a reason (VMware Nat / Host only interface)
this_compute_interfaces = sorted(this_compute_interfaces, key=lambda i: i["ip_address"] != self.host_ip)
other_compute_interfaces = sorted(other_compute_interfaces, key=lambda i: i["ip_address"] != other_compute.host_ip)
for this_interface in this_compute_interfaces:
# Skip if no ip or no netmask (vbox when stopped set a null netmask)
if len(this_interface["ip_address"]) == 0 or this_interface["netmask"] is None:
2016-08-25 17:14:29 +00:00
continue
# Ignore 169.254 network because it's for Windows special purpose
if this_interface["ip_address"].startswith("169.254."):
continue
2016-08-25 17:14:29 +00:00
this_network = ipaddress.ip_network("{}/{}".format(this_interface["ip_address"], this_interface["netmask"]), strict=False)
for other_interface in other_compute_interfaces:
2016-11-11 15:08:52 +00:00
if len(other_interface["ip_address"]) == 0 or other_interface["netmask"] is None:
2016-08-25 17:14:29 +00:00
continue
# Avoid stuff like 127.0.0.1
if other_interface["ip_address"] == this_interface["ip_address"]:
continue
other_network = ipaddress.ip_network("{}/{}".format(other_interface["ip_address"], other_interface["netmask"]), strict=False)
if this_network.overlaps(other_network):
return this_interface["ip_address"], other_interface["ip_address"]
2016-08-25 17:14:29 +00:00
raise ValueError("No common subnet for compute {} and {}".format(self.name, other_compute.name))