arno/gns3-server
1
0
Fork 0
mirror of https://github.com/GNS3/gns3-server synced 2024-11-24 09:18:08 +00:00
Code Issues Releases Wiki Activity

Base for dedicated appliance management API. Ref https://github.com/GNS3/gns3-server/issues/1427

Browse Source
This commit is contained in:
grossmj 2018-11-11 20:13:58 +08:00
parent 887b32c4bc
commit f0fe9d39fa
8 changed files with 359 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gns3server/compute/vmware/vmware_vm.py
View File

@ -188,10 +188,10 @@ class VMwareVM(BaseNode):
# create the linked clone based on the base snapshot
new_vmx_path = os.path.join(self.working_dir, self.name + ".vmx")
await self._control_vm("clone",
new_vmx_path,
"linked",
"-snapshot={}".format(base_snapshot_name),
"-cloneName={}".format(self.name))
new_vmx_path,
"linked",
"-snapshot={}".format(base_snapshot_name),
"-cloneName={}".format(self.name))
try:
vmsd_pairs = self.manager.parse_vmware_file(vmsd_path)

283
gns3server/controller/__init__.py
View File

@ -128,71 +128,59 @@ class Controller:
log.warning("Cannot load appliance template file '%s': %s", path, str(e))
continue
def add_appliance(self, settings):
"""
Adds a new appliance.
:param settings: appliance settings
:returns: Appliance object
"""
appliance_id = settings.get("appliance_id", "")
if appliance_id in self._appliances:
raise aiohttp.web.HTTPConflict(text="Appliance ID '{}' already exists".format(appliance_id))
else:
appliance_id = settings.setdefault("appliance_id", str(uuid.uuid4()))
try:
appliance = Appliance(appliance_id, settings)
appliance.__json__() # Check if loaded without error
except KeyError as e:
# appliance settings is not complete
raise aiohttp.web.HTTPConflict(text="Cannot create new appliance: key '{}' is missing for appliance ID '{}'".format(e, appliance_id))
self._appliances[appliance.id] = appliance
self.save()
return appliance
def get_appliance(self, appliance_id):
"""
Gets an appliance.
:param appliance_id: appliance identifier
:returns: Appliance object
"""
appliance = self._appliances.get(appliance_id)
if not appliance:
raise aiohttp.web.HTTPNotFound(text="Appliance ID {} doesn't exist".format(appliance_id))
return appliance
def delete_appliance(self, appliance_id):
"""
Deletes an appliance.
:param appliance_id: appliance identifier
"""
appliance = self._appliances.get(appliance_id)
if appliance.builtin:
raise aiohttp.web.HTTPConflict(text="Appliance ID {} cannot be deleted because it is builtin".format(appliance_id))
self._appliances.pop(appliance_id)
def load_appliances(self):
self._appliances = {}
vms = []
for vm in self._settings.get("Qemu", {}).get("vms", []):
vm["node_type"] = "qemu"
vms.append(vm)
for vm in self._settings.get("IOU", {}).get("devices", []):
vm["node_type"] = "iou"
vms.append(vm)
for vm in self._settings.get("Docker", {}).get("containers", []):
vm["node_type"] = "docker"
vms.append(vm)
for vm in self._settings.get("Builtin", {}).get("cloud_nodes", []):
vm["node_type"] = "cloud"
vms.append(vm)
for vm in self._settings.get("Builtin", {}).get("ethernet_switches", []):
vm["node_type"] = "ethernet_switch"
vms.append(vm)
for vm in self._settings.get("Builtin", {}).get("ethernet_hubs", []):
vm["node_type"] = "ethernet_hub"
vms.append(vm)
for vm in self._settings.get("Dynamips", {}).get("routers", []):
vm["node_type"] = "dynamips"
vms.append(vm)
for vm in self._settings.get("VMware", {}).get("vms", []):
vm["node_type"] = "vmware"
vms.append(vm)
for vm in self._settings.get("VirtualBox", {}).get("vms", []):
vm["node_type"] = "virtualbox"
vms.append(vm)
for vm in self._settings.get("VPCS", {}).get("nodes", []):
vm["node_type"] = "vpcs"
vms.append(vm)
for vm in self._settings.get("TraceNG", {}).get("nodes", []):
vm["node_type"] = "traceng"
vms.append(vm)
for vm in vms:
# remove deprecated properties
for prop in vm.copy():
if prop in ["enable_remote_console", "use_ubridge", "acpi_shutdown"]:
del vm[prop]
# remove deprecated default_symbol and hover_symbol
# and set symbol if not present
deprecated = ["default_symbol", "hover_symbol"]
if len([prop for prop in vm.keys() if prop in deprecated]) > 0:
if "default_symbol" in vm.keys():
del vm["default_symbol"]
if "hover_symbol" in vm.keys():
del vm["hover_symbol"]
if "symbol" not in vm.keys():
vm["symbol"] = ":/symbols/computer.svg"
vm.setdefault("appliance_id", str(uuid.uuid4()))
try:
appliance = Appliance(vm["appliance_id"], vm)
appliance.__json__() # Check if loaded without error
self._appliances[appliance.id] = appliance
except KeyError as e:
# appliance data is not complete (missing name or type)
log.warning("Cannot load appliance template {} ('{}'): missing key {}".format(vm["appliance_id"], vm.get("name", "unknown"), e))
continue
#self._appliances = {}
# Add builtins
builtins = []
@ -232,14 +220,14 @@ class Controller:
computes = await self._load_controller_settings()
try:
self._local_server = await self.add_compute(compute_id="local",
name=name,
protocol=server_config.get("protocol", "http"),
host=host,
console_host=console_host,
port=port,
user=server_config.get("user", ""),
password=server_config.get("password", ""),
force=True)
name=name,
protocol=server_config.get("protocol", "http"),
host=host,
console_host=console_host,
port=port,
user=server_config.get("user", ""),
password=server_config.get("password", ""),
force=True)
except aiohttp.web.HTTPConflict as e:
log.fatal("Cannot access to the local server, make sure something else is not running on the TCP port {}".format(port))
sys.exit(1)
@ -288,31 +276,34 @@ class Controller:
# We don't save during the loading otherwise we could lost stuff
if self._settings is None:
return
data = {
"computes": [],
"settings": self._settings,
"gns3vm": self.gns3vm.__json__(),
"appliance_templates_etag": self._appliance_templates_etag,
"version": __version__
}
for c in self._computes.values():
if c.id != "local" and c.id != "vm":
data["computes"].append({
"host": c.host,
"name": c.name,
"port": c.port,
"protocol": c.protocol,
"user": c.user,
"password": c.password,
"compute_id": c.id
})
controller_settings = {"computes": [],
"settings": self._settings,
"appliances": [],
"gns3vm": self.gns3vm.__json__(),
"appliance_templates_etag": self._appliance_templates_etag,
"version": __version__}
for appliance in self._appliances.values():
if not appliance.builtin:
controller_settings["appliances"].append(appliance.__json__())
for compute in self._computes.values():
if compute.id != "local" and compute.id != "vm":
controller_settings["computes"].append({"host": compute.host,
"name": compute.name,
"port": compute.port,
"protocol": compute.protocol,
"user": compute.user,
"password": compute.password,
"compute_id": compute.id})
try:
os.makedirs(os.path.dirname(self._config_file), exist_ok=True)
with open(self._config_file, 'w+') as f:
json.dump(data, f, indent=4)
json.dump(controller_settings, f, indent=4)
except OSError as e:
log.error("Cannnot write configuration file '{}': {}".format(self._config_file, e))
log.error("Cannot write controller configuration file '{}': {}".format(self._config_file, e))
async def _load_controller_settings(self):
"""
@ -324,23 +315,37 @@ class Controller:
await self._import_gns3_gui_conf()
self.save()
with open(self._config_file) as f:
data = json.load(f)
controller_settings = json.load(f)
except (OSError, ValueError) as e:
log.critical("Cannot load configuration file '{}': {}".format(self._config_file, e))
self._settings = {}
return []
if "settings" in data and data["settings"] is not None:
self._settings = data["settings"]
if "settings" in controller_settings and controller_settings["settings"] is not None:
self._settings = controller_settings["settings"]
else:
self._settings = {}
if "gns3vm" in data:
self.gns3vm.settings = data["gns3vm"]
self._appliance_templates_etag = data.get("appliance_templates_etag")
# load the appliances
if "appliances" in controller_settings:
for appliance_settings in controller_settings["appliances"]:
try:
appliance = Appliance(appliance_settings["appliance_id"], appliance_settings)
appliance.__json__() # Check if loaded without error
self._appliances[appliance.id] = appliance
except KeyError as e:
# appliance data is not complete (missing name or type)
log.warning("Cannot load appliance template {} ('{}'): missing key {}".format(appliance_settings["appliance_id"], appliance_settings.get("name", "unknown"), e))
continue
# load GNS3 VM settings
if "gns3vm" in controller_settings:
self.gns3vm.settings = controller_settings["gns3vm"]
self._appliance_templates_etag = controller_settings.get("appliance_templates_etag")
self.load_appliance_templates()
self.load_appliances()
return data.get("computes", [])
return controller_settings.get("computes", [])
async def load_projects(self):
"""
@ -416,18 +421,16 @@ class Controller:
config_file = os.path.join(os.path.dirname(self._config_file), "gns3_gui.conf")
if os.path.exists(config_file):
with open(config_file) as f:
data = json.load(f)
server_settings = data.get("Servers", {})
settings = json.load(f)
server_settings = settings.get("Servers", {})
for remote in server_settings.get("remote_servers", []):
try:
await self.add_compute(
host=remote.get("host", "localhost"),
port=remote.get("port", 3080),
protocol=remote.get("protocol", "http"),
name=remote.get("url"),
user=remote.get("user"),
password=remote.get("password")
)
await self.add_compute(host=remote.get("host", "localhost"),
port=remote.get("port", 3080),
protocol=remote.get("protocol", "http"),
name=remote.get("url"),
user=remote.get("user"),
password=remote.get("password"))
except aiohttp.web.HTTPConflict:
pass # if the server is broken we skip it
if "vm" in server_settings:
@ -458,6 +461,70 @@ class Controller:
"headless": vm_settings.get("headless", False),
"vmname": vmname
}
vms = []
for vm in settings.get("Qemu", {}).get("vms", []):
vm["node_type"] = "qemu"
vms.append(vm)
for vm in settings.get("IOU", {}).get("devices", []):
vm["node_type"] = "iou"
vms.append(vm)
for vm in settings.get("Docker", {}).get("containers", []):
vm["node_type"] = "docker"
vms.append(vm)
for vm in settings.get("Builtin", {}).get("cloud_nodes", []):
vm["node_type"] = "cloud"
vms.append(vm)
for vm in settings.get("Builtin", {}).get("ethernet_switches", []):
vm["node_type"] = "ethernet_switch"
vms.append(vm)
for vm in settings.get("Builtin", {}).get("ethernet_hubs", []):
vm["node_type"] = "ethernet_hub"
vms.append(vm)
for vm in settings.get("Dynamips", {}).get("routers", []):
vm["node_type"] = "dynamips"
vms.append(vm)
for vm in settings.get("VMware", {}).get("vms", []):
vm["node_type"] = "vmware"
vms.append(vm)
for vm in settings.get("VirtualBox", {}).get("vms", []):
vm["node_type"] = "virtualbox"
vms.append(vm)
for vm in settings.get("VPCS", {}).get("nodes", []):
vm["node_type"] = "vpcs"
vms.append(vm)
for vm in settings.get("TraceNG", {}).get("nodes", []):
vm["node_type"] = "traceng"
vms.append(vm)
for vm in vms:
# remove deprecated properties
for prop in vm.copy():
if prop in ["enable_remote_console", "use_ubridge", "acpi_shutdown"]:
del vm[prop]
# remove deprecated default_symbol and hover_symbol
# and set symbol if not present
deprecated = ["default_symbol", "hover_symbol"]
if len([prop for prop in vm.keys() if prop in deprecated]) > 0:
if "default_symbol" in vm.keys():
del vm["default_symbol"]
if "hover_symbol" in vm.keys():
del vm["hover_symbol"]
if "symbol" not in vm.keys():
vm["symbol"] = ":/symbols/computer.svg"
vm.setdefault("appliance_id", str(uuid.uuid4()))
try:
appliance = Appliance(vm["appliance_id"], vm)
appliance.__json__() # Check if loaded without error
self._appliances[appliance.id] = appliance
except KeyError as e:
# appliance data is not complete (missing name or type)
log.warning("Cannot load appliance template {} ('{}'): missing key {}".format(vm["appliance_id"], vm.get("name", "unknown"), e))
continue
self._settings = {}
@property

77
gns3server/controller/appliance.py
View File

@ -18,8 +18,6 @@
import copy
import uuid
# Convert old GUI category to text category
ID_TO_CATEGORY = {
3: "firewall",
2: "guest",
@ -30,7 +28,7 @@ ID_TO_CATEGORY = {
class Appliance:
def __init__(self, appliance_id, data, builtin=False):
def __init__(self, appliance_id, settings, builtin=False):
if appliance_id is None:
self._id = str(uuid.uuid4())
@ -38,18 +36,30 @@ class Appliance:
self._id = str(appliance_id)
else:
self._id = appliance_id
self._data = data.copy()
if "appliance_id" in self._data:
del self._data["appliance_id"]
self._settings = copy.deepcopy(settings)
# Version of the gui before 2.1 use linked_base
# and the server linked_clone
if "linked_base" in self._data:
linked_base = self._data.pop("linked_base")
if "linked_clone" not in self._data:
self._data["linked_clone"] = linked_base
if data["node_type"] == "iou" and "image" in data:
del self._data["image"]
if "linked_base" in self.settings:
linked_base = self._settings.pop("linked_base")
if "linked_clone" not in self._settings:
self._settings["linked_clone"] = linked_base
# Convert old GUI category to text category
try:
self._settings["category"] = ID_TO_CATEGORY[self._settings["category"]]
except KeyError:
pass
# The "server" setting has been replaced by "compute_id" setting in version 2.2
if "server" in self._settings:
self._settings["compute_id"] = self._settings.pop("server")
# Remove an old IOU setting
if settings["node_type"] == "iou" and "image" in settings:
del self._settings["image"]
self._builtin = builtin
@property
@ -57,16 +67,25 @@ class Appliance:
return self._id
@property
def data(self):
return copy.deepcopy(self._data)
def settings(self):
return self._settings
@settings.setter
def settings(self, settings):
self._settings.update(settings)
@property
def name(self):
return self._data["name"]
return self._settings["name"]
@property
def compute_id(self):
return self._data.get("server")
return self._settings["compute_id"]
@property
def node_type(self):
return self._settings["node_type"]
@property
def builtin(self):
@ -74,21 +93,15 @@ class Appliance:
def __json__(self):
"""
Appliance data (a hash)
Appliance settings.
"""
try:
category = ID_TO_CATEGORY[self._data["category"]]
except KeyError:
category = self._data["category"]
settings = self._settings
settings.update({"appliance_id": self._id,
"default_name_format": settings.get("default_name_format", "{name}-{0}"),
"symbol": settings.get("symbol", ":/symbols/computer.svg"),
"builtin": self.builtin})
return {
"appliance_id": self._id,
"node_type": self._data["node_type"],
"name": self._data["name"],
"default_name_format": self._data.get("default_name_format", "{name}-{0}"),
"category": category,
"symbol": self._data.get("symbol", ":/symbols/computer.svg"),
"compute_id": self.compute_id,
"builtin": self._builtin,
"platform": self._data.get("platform", None)
}
if not self.builtin:
settings["compute_id"] = self.compute_id
return settings

5
gns3server/controller/node.py
View File

@ -271,9 +271,8 @@ class Node:
if self._label is None:
# Apply to label user style or default
try:
style = qt_font_to_style(
self._project.controller.settings["GraphicsView"]["default_label_font"],
self._project.controller.settings["GraphicsView"]["default_label_color"])
style = qt_font_to_style(self._project.controller.settings["GraphicsView"]["default_label_font"],
self._project.controller.settings["GraphicsView"]["default_label_color"])
except KeyError:
style = "font-size: 10;font-familly: Verdana"

7
gns3server/controller/project.py
View File

@ -465,7 +465,7 @@ class Project:
Create a node from an appliance
"""
try:
template = self.controller.appliances[appliance_id].data
template = self.controller.appliances[appliance_id].settings
except KeyError:
msg = "Appliance {} doesn't exist".format(appliance_id)
log.error(msg)
@ -473,12 +473,13 @@ class Project:
template["x"] = x
template["y"] = y
node_type = template.pop("node_type")
compute = self.controller.get_compute(template.pop("server", compute_id))
compute = self.controller.get_compute(template.pop("compute_id", compute_id))
name = template.pop("name")
default_name_format = template.pop("default_name_format", "{name}-{0}")
name = default_name_format.replace("{name}", name)
node_id = str(uuid.uuid4())
node = await self.add_node(compute, name, node_id, node_type=node_type, appliance_id=appliance_id, **template)
template.pop("builtin") # not needed to add a node
node = await self.add_node(compute, name, node_id, node_type=node_type, **template)
return node
@open_required

85
gns3server/handlers/api/controller/appliance_handler.py
View File

@ -20,6 +20,11 @@ from gns3server.controller import Controller
from gns3server.schemas.node import NODE_OBJECT_SCHEMA
from gns3server.schemas.appliance import APPLIANCE_USAGE_SCHEMA
from gns3server.schemas.appliance import (
APPLIANCE_OBJECT_SCHEMA,
APPLIANCE_UPDATE_SCHEMA,
APPLIANCE_CREATE_SCHEMA
)
import logging
log = logging.getLogger(__name__)
@ -42,6 +47,74 @@ class ApplianceHandler:
controller.load_appliance_templates()
response.json([c for c in controller.appliance_templates.values()])
@Route.post(
r"/appliances",
description="Create a new appliance",
status_codes={
201: "Appliance created",
400: "Invalid request"
},
input=APPLIANCE_CREATE_SCHEMA,
output=APPLIANCE_OBJECT_SCHEMA)
def create(request, response):
controller = Controller.instance()
appliance = controller.add_appliance(request.json)
response.set_status(201)
response.json(appliance)
@Route.get(
r"/appliances/{appliance_id}",
status_codes={
200: "Appliance found",
400: "Invalid request",
404: "Appliance doesn't exist"
},
description="Get an appliance",
output=APPLIANCE_OBJECT_SCHEMA)
def get(request, response):
controller = Controller.instance()
appliance = controller.get_appliance(request.match_info["appliance_id"])
response.set_status(200)
response.json(appliance)
@Route.put(
r"/appliances/{appliance_id}",
status_codes={
200: "Appliance updated",
400: "Invalid request",
404: "Appliance doesn't exist"
},
description="Update an appliance",
input=APPLIANCE_UPDATE_SCHEMA,
output=APPLIANCE_OBJECT_SCHEMA)
def update(request, response):
controller = Controller.instance()
appliance = controller.get_appliance(request.match_info["appliance_id"])
#TODO: update appliance!
#appliance.settings = request.json
response.set_status(200)
response.json(appliance)
@Route.delete(
r"/appliances/{appliance_id}",
parameters={
"appliance_id": "Node UUID"
},
status_codes={
204: "Appliance deleted",
400: "Invalid request",
404: "Appliance doesn't exist"
},
description="Delete an appliance")
def delete(request, response):
controller = Controller.instance()
controller.delete_appliance(request.match_info["appliance_id"])
response.set_status(204)
@Route.get(
r"/appliances",
description="List of appliance",
@ -50,6 +123,8 @@ class ApplianceHandler:
})
def list(request, response):
#old_etag = request.headers.get('If-None-Match', '')
#print("ETAG => ", old_etag)
controller = Controller.instance()
response.json([c for c in controller.appliances.values()])
@ -58,11 +133,11 @@ class ApplianceHandler:
description="Create a node from an appliance",
parameters={
"project_id": "Project UUID",
"appliance_id": "Appliance template UUID"
"appliance_id": "Appliance UUID"
},
status_codes={
201: "Node created",
404: "The project or template doesn't exist"
404: "The project or appliance doesn't exist"
},
input=APPLIANCE_USAGE_SCHEMA,
output=NODE_OBJECT_SCHEMA)
@ -71,7 +146,7 @@ class ApplianceHandler:
controller = Controller.instance()
project = controller.get_project(request.match_info["project_id"])
await project.add_node_from_appliance(request.match_info["appliance_id"],
x=request.json["x"],
y=request.json["y"],
compute_id=request.json.get("compute_id"))
x=request.json["x"],
y=request.json["y"],
compute_id=request.json.get("compute_id"))
response.set_status(201)

3
gns3server/handlers/api/controller/node_handler.py
View File

@ -76,7 +76,7 @@ class NodeHandler:
400: "Invalid request",
404: "Node doesn't exist"
},
description="Update a node instance",
description="Get a node",
output=NODE_OBJECT_SCHEMA)
def get_node(request, response):
project = Controller.instance().get_project(request.match_info["project_id"])
@ -84,7 +84,6 @@ class NodeHandler:
response.set_status(200)
response.json(node)
@Route.put(
r"/projects/{project_id}/nodes/{node_id}",
status_codes={

48
gns3server/schemas/appliance.py
View File

@ -15,6 +15,54 @@
# 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 copy
from .node import NODE_TYPE_SCHEMA
APPLIANCE_OBJECT_SCHEMA = {
"$schema": "http://json-schema.org/draft-04/schema#",
"description": "A template object",
"type": "object",
"properties": {
"appliance_id": {
"description": "Appliance UUID from which the node has been created. Read only",
"type": ["null", "string"],
"minLength": 36,
"maxLength": 36,
"pattern": "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$"
},
"compute_id": {
"description": "Compute identifier",
"type": "string"
},
"node_type": NODE_TYPE_SCHEMA,
"name": {
"description": "Appliance name",
"type": "string",
"minLength": 1,
},
"default_name_format": {
"description": "Default name format",
"type": "string",
"minLength": 1,
},
"symbol": {
"description": "Symbol of the appliance",
"type": "string",
"minLength": 1
},
},
"additionalProperties": True, #TODO: validate all properties
"required": ["appliance_id", "compute_id", "node_type", "name", "default_name_format", "symbol"]
}
APPLIANCE_CREATE_SCHEMA = copy.deepcopy(APPLIANCE_OBJECT_SCHEMA)
# these properties are not required to create an appliance
APPLIANCE_CREATE_SCHEMA["required"].remove("appliance_id")
APPLIANCE_CREATE_SCHEMA["required"].remove("compute_id")
APPLIANCE_CREATE_SCHEMA["required"].remove("default_name_format")
APPLIANCE_CREATE_SCHEMA["required"].remove("symbol")
APPLIANCE_UPDATE_SCHEMA = copy.deepcopy(APPLIANCE_OBJECT_SCHEMA)
APPLIANCE_USAGE_SCHEMA = {
"$schema": "http://json-schema.org/draft-04/schema#",