mirror of
https://github.com/GNS3/gns3-server
synced 2024-11-28 19:28:07 +00:00
410 lines
12 KiB
Python
410 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
#
|
|
# Copyright (C) 2014 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/>.
|
|
|
|
"""
|
|
Client to VirtualBox wrapper.
|
|
"""
|
|
|
|
import os
|
|
import time
|
|
import subprocess
|
|
import tempfile
|
|
import socket
|
|
import re
|
|
|
|
from ..attic import wait_socket_is_ready
|
|
from .virtualbox_error import VirtualBoxError
|
|
|
|
import logging
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class VboxWrapperClient(object):
|
|
"""
|
|
VirtualBox Wrapper client.
|
|
|
|
:param path: path to VirtualBox wrapper executable
|
|
:param working_dir: working directory
|
|
:param port: port
|
|
:param host: host/address
|
|
"""
|
|
|
|
# Used to parse the VirtualBox wrapper response codes
|
|
error_re = re.compile(r"""^2[0-9]{2}-""")
|
|
success_re = re.compile(r"""^1[0-9]{2}\s{1}""")
|
|
|
|
def __init__(self, path, working_dir, host, port=11525, timeout=30.0):
|
|
|
|
self._path = path
|
|
self._command = []
|
|
self._process = None
|
|
self._working_dir = working_dir
|
|
self._stdout_file = ""
|
|
self._started = False
|
|
self._host = host
|
|
self._port = port
|
|
self._timeout = timeout
|
|
self._socket = None
|
|
|
|
@property
|
|
def started(self):
|
|
"""
|
|
Returns either VirtualBox wrapper has been started or not.
|
|
|
|
:returns: boolean
|
|
"""
|
|
|
|
return self._started
|
|
|
|
@property
|
|
def path(self):
|
|
"""
|
|
Returns the path to the VirtualBox wrapper executable.
|
|
|
|
:returns: path to VirtualBox wrapper
|
|
"""
|
|
|
|
return self._path
|
|
|
|
@path.setter
|
|
def path(self, path):
|
|
"""
|
|
Sets the path to the VirtualBox wrapper executable.
|
|
|
|
:param path: path to VirtualBox wrapper
|
|
"""
|
|
|
|
self._path = path
|
|
|
|
@property
|
|
def port(self):
|
|
"""
|
|
Returns the port used to start the VirtualBox wrapper.
|
|
|
|
:returns: port number (integer)
|
|
"""
|
|
|
|
return self._port
|
|
|
|
@port.setter
|
|
def port(self, port):
|
|
"""
|
|
Sets the port used to start the VirtualBox wrapper.
|
|
|
|
:param port: port number (integer)
|
|
"""
|
|
|
|
self._port = port
|
|
|
|
@property
|
|
def host(self):
|
|
"""
|
|
Returns the host (binding) used to start the VirtualBox wrapper.
|
|
|
|
:returns: host/address (string)
|
|
"""
|
|
|
|
return self._host
|
|
|
|
@host.setter
|
|
def host(self, host):
|
|
"""
|
|
Sets the host (binding) used to start the VirtualBox wrapper.
|
|
|
|
:param host: host/address (string)
|
|
"""
|
|
|
|
self._host = host
|
|
|
|
def start(self):
|
|
"""
|
|
Starts the VirtualBox wrapper process.
|
|
"""
|
|
|
|
self._command = self._build_command()
|
|
try:
|
|
log.info("starting VirtualBox wrapper: {}".format(self._command))
|
|
with tempfile.NamedTemporaryFile(delete=False) as fd:
|
|
self._stdout_file = fd.name
|
|
log.info("VirtualBox wrapper process logging to {}".format(fd.name))
|
|
self._process = subprocess.Popen(self._command,
|
|
stdout=fd,
|
|
stderr=subprocess.STDOUT,
|
|
cwd=self._working_dir)
|
|
log.info("VirtualBox wrapper started PID={}".format(self._process.pid))
|
|
self.wait_for_vboxwrapper(self._host, self._port)
|
|
self.connect()
|
|
self._started = True
|
|
except OSError as e:
|
|
log.error("could not start VirtualBox wrapper: {}".format(e))
|
|
raise VirtualBoxError("could not start VirtualBox wrapper: {}".format(e))
|
|
|
|
def wait_for_vboxwrapper(self, host, port):
|
|
"""
|
|
Waits for vboxwrapper to be started (accepting a socket connection)
|
|
|
|
:param host: host/address to connect to the vboxwrapper
|
|
:param port: port to connect to the vboxwrapper
|
|
"""
|
|
|
|
begin = time.time()
|
|
# wait for the socket for a maximum of 10 seconds.
|
|
connection_success, last_exception = wait_socket_is_ready(host, port, wait=10.0)
|
|
|
|
if not connection_success:
|
|
raise VirtualBoxError("Couldn't connect to vboxwrapper on {}:{} :{}".format(host, port,
|
|
last_exception))
|
|
else:
|
|
log.info("vboxwrapper server ready after {:.4f} seconds".format(time.time() - begin))
|
|
|
|
def stop(self):
|
|
"""
|
|
Stops the VirtualBox wrapper process.
|
|
"""
|
|
|
|
if self.connected():
|
|
try:
|
|
self.send("vboxwrapper stop")
|
|
except VirtualBoxError:
|
|
pass
|
|
if self._socket:
|
|
self._socket.shutdown(socket.SHUT_RDWR)
|
|
self._socket.close()
|
|
self._socket = None
|
|
|
|
if self.is_running():
|
|
log.info("stopping VirtualBox wrapper PID={}".format(self._process.pid))
|
|
try:
|
|
# give some time for the VirtualBox wrapper to properly stop.
|
|
time.sleep(0.01)
|
|
self._process.terminate()
|
|
self._process.wait(1)
|
|
except subprocess.TimeoutExpired:
|
|
self._process.kill()
|
|
if self._process.poll() is None:
|
|
log.warn("VirtualBox wrapper process {} is still running".format(self._process.pid))
|
|
|
|
if self._stdout_file and os.access(self._stdout_file, os.W_OK):
|
|
try:
|
|
os.remove(self._stdout_file)
|
|
except OSError as e:
|
|
log.warning("could not delete temporary VirtualBox wrapper log file: {}".format(e))
|
|
self._started = False
|
|
|
|
def read_stdout(self):
|
|
"""
|
|
Reads the standard output of the VirtualBox wrapper process.
|
|
Only use when the process has been stopped or has crashed.
|
|
"""
|
|
|
|
output = ""
|
|
if self._stdout_file and os.access(self._stdout_file, os.R_OK):
|
|
try:
|
|
with open(self._stdout_file, errors="replace") as file:
|
|
output = file.read()
|
|
except OSError as e:
|
|
log.warn("could not read {}: {}".format(self._stdout_file, e))
|
|
return output
|
|
|
|
def is_running(self):
|
|
"""
|
|
Checks if the process is running
|
|
|
|
:returns: True or False
|
|
"""
|
|
|
|
if self._process and self._process.poll() is None:
|
|
return True
|
|
return False
|
|
|
|
def _build_command(self):
|
|
"""
|
|
Command to start the VirtualBox wrapper process.
|
|
(to be passed to subprocess.Popen())
|
|
"""
|
|
|
|
command = [self._path]
|
|
if self._host != "0.0.0.0" and self._host != "::":
|
|
command.extend(["-l", self._host, "-p", str(self._port)])
|
|
else:
|
|
command.extend(["-p", str(self._port)])
|
|
return command
|
|
|
|
def connect(self):
|
|
"""
|
|
Connects to the VirtualBox wrapper.
|
|
"""
|
|
|
|
# connect to a local address by default
|
|
# if listening to all addresses (IPv4 or IPv6)
|
|
if self._host == "0.0.0.0":
|
|
host = "127.0.0.1"
|
|
elif self._host == "::":
|
|
host = "::1"
|
|
else:
|
|
host = self._host
|
|
|
|
try:
|
|
self._socket = socket.create_connection((host, self._port), self._timeout)
|
|
except OSError as e:
|
|
raise VirtualBoxError("Could not connect to the VirtualBox wrapper: {}".format(e))
|
|
|
|
def connected(self):
|
|
"""
|
|
Returns either the client is connected to vboxwrapper or not.
|
|
|
|
:return: boolean
|
|
"""
|
|
|
|
if self._socket:
|
|
return True
|
|
return False
|
|
|
|
def reset(self):
|
|
"""
|
|
Resets the VirtualBox wrapper (used to get an empty configuration).
|
|
"""
|
|
|
|
pass
|
|
|
|
@property
|
|
def working_dir(self):
|
|
"""
|
|
Returns current working directory
|
|
|
|
:returns: path to the working directory
|
|
"""
|
|
|
|
return self._working_dir
|
|
|
|
@working_dir.setter
|
|
def working_dir(self, working_dir):
|
|
"""
|
|
Sets the working directory for the VirtualBox wrapper.
|
|
|
|
:param working_dir: path to the working directory
|
|
"""
|
|
|
|
# encase working_dir in quotes to protect spaces in the path
|
|
#self.send("hypervisor working_dir {}".format('"' + working_dir + '"'))
|
|
self._working_dir = working_dir
|
|
log.debug("working directory set to {}".format(self._working_dir))
|
|
|
|
@property
|
|
def socket(self):
|
|
"""
|
|
Returns the current socket used to communicate with the VirtualBox wrapper.
|
|
|
|
:returns: socket instance
|
|
"""
|
|
|
|
assert self._socket
|
|
return self._socket
|
|
|
|
def get_vm_list(self):
|
|
"""
|
|
Returns the list of all VirtualBox VMs.
|
|
|
|
:returns: list of VM names
|
|
"""
|
|
|
|
return self.send('vbox vm_list')
|
|
|
|
def send(self, command):
|
|
"""
|
|
Sends commands to the VirtualBox wrapper.
|
|
|
|
:param command: a VirtualBox wrapper command
|
|
|
|
:returns: results as a list
|
|
"""
|
|
|
|
# VirtualBox wrapper responses are of the form:
|
|
# 1xx yyyyyy\r\n
|
|
# 1xx yyyyyy\r\n
|
|
# ...
|
|
# 100-yyyy\r\n
|
|
# or
|
|
# 2xx-yyyy\r\n
|
|
#
|
|
# Where 1xx is a code from 100-199 for a success or 200-299 for an error
|
|
# The result might be multiple lines and might be less than the buffer size
|
|
# but still have more data. The only thing we know for sure is the last line
|
|
# will begin with '100-' or a '2xx-' and end with '\r\n'
|
|
|
|
if not self._socket:
|
|
raise VirtualBoxError("Not connected")
|
|
|
|
try:
|
|
command = command.strip() + '\n'
|
|
log.debug("sending {}".format(command))
|
|
self.socket.sendall(command.encode('utf-8'))
|
|
except OSError as e:
|
|
self._socket = None
|
|
raise VirtualBoxError("Lost communication with {host}:{port} :{error}"
|
|
.format(host=self._host, port=self._port, error=e))
|
|
|
|
# Now retrieve the result
|
|
data = []
|
|
buf = ''
|
|
while True:
|
|
try:
|
|
chunk = self.socket.recv(1024)
|
|
buf += chunk.decode("utf-8")
|
|
except OSError as e:
|
|
self._socket = None
|
|
raise VirtualBoxError("Communication timed out with {host}:{port} :{error}"
|
|
.format(host=self._host, port=self._port, error=e))
|
|
|
|
|
|
# If the buffer doesn't end in '\n' then we can't be done
|
|
try:
|
|
if buf[-1] != '\n':
|
|
continue
|
|
except IndexError:
|
|
self._socket = None
|
|
raise VirtualBoxError("Could not communicate with {host}:{port}"
|
|
.format(host=self._host, port=self._port))
|
|
|
|
data += buf.split('\r\n')
|
|
if data[-1] == '':
|
|
data.pop()
|
|
buf = ''
|
|
|
|
if len(data) == 0:
|
|
raise VirtualBoxError("no data returned from {host}:{port}"
|
|
.format(host=self._host, port=self._port))
|
|
|
|
# Does it contain an error code?
|
|
if self.error_re.search(data[-1]):
|
|
raise VirtualBoxError(data[-1][4:])
|
|
|
|
# Or does the last line begin with '100-'? Then we are done!
|
|
if data[-1][:4] == '100-':
|
|
data[-1] = data[-1][4:]
|
|
if data[-1] == 'OK':
|
|
data.pop()
|
|
break
|
|
|
|
# Remove success responses codes
|
|
for index in range(len(data)):
|
|
if self.success_re.search(data[index]):
|
|
data[index] = data[index][4:]
|
|
|
|
log.debug("returned result {}".format(data))
|
|
return data
|