mirror of
https://github.com/GNS3/gns3-server.git
synced 2026-11-19 20:55:14 +02:00
Creating a node from a template whose name has characters invalid in a hostname, such as "MikroTik CCR1072-1G-8S+", failed on the compute with "'MikroTikCCR1072-1G-8S+-1' is an invalid name to create a Qemu node": the template name was only stripped of spaces. Replace the other invalid characters by hyphens, following the rules the compute validates node names with (RFC 1123 for Qemu and Docker, IOS for Dynamips and IOU), as project import already does for existing nodes. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1400 lines
46 KiB
Python
1400 lines
46 KiB
Python
#!/usr/bin/env python
|
|
#
|
|
# Copyright (C) 2020 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/>.
|
|
|
|
import json
|
|
import os
|
|
import uuid
|
|
from unittest.mock import MagicMock, patch
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
import pytest_asyncio
|
|
|
|
from gns3server.controller.controller_error import (
|
|
ComputeConflictError,
|
|
ControllerError,
|
|
ControllerForbiddenError,
|
|
ControllerNotFoundError,
|
|
)
|
|
from gns3server.controller.node import Node
|
|
from gns3server.controller.ports.ethernet_port import EthernetPort
|
|
from gns3server.controller.project import Project
|
|
from tests.utils import AsyncioMagicMock, asyncio_patch
|
|
|
|
|
|
@pytest_asyncio.fixture
|
|
async def node(controller, project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
return node
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_affect_uuid():
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
|
|
p = Project(name="Test")
|
|
mock_notification.assert_called()
|
|
assert len(p.id) == 36
|
|
p = Project(project_id="00010203-0405-0607-0809-0a0b0c0d0e0f", name="Test 2")
|
|
assert p.id == "00010203-0405-0607-0809-0a0b0c0d0e0f"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_json():
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
|
|
p = Project(name="Test")
|
|
mock_notification.assert_called()
|
|
|
|
assert p.asdict() == {
|
|
"name": "Test",
|
|
"project_id": p.id,
|
|
"path": p.path,
|
|
"status": "opened",
|
|
"filename": "Test.gns3",
|
|
"auto_start": False,
|
|
"auto_close": True,
|
|
"auto_open": False,
|
|
"scene_width": 2000,
|
|
"scene_height": 1000,
|
|
"zoom": 100,
|
|
"show_grid": False,
|
|
"show_interface_labels": True,
|
|
"show_layers": False,
|
|
"snap_to_grid": False,
|
|
"grid_size": 75,
|
|
"drawing_grid_size": 25,
|
|
"supplier": None,
|
|
"variables": None,
|
|
"marker_definitions": {},
|
|
"created_by": None,
|
|
}
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_created_by():
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification"):
|
|
p = Project(name="Test", created_by="admin")
|
|
|
|
assert p.created_by == "admin"
|
|
assert p.asdict()["created_by"] == "admin"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update(controller):
|
|
|
|
project = Project(controller=controller, name="Hello")
|
|
project.emit_controller_notification = MagicMock()
|
|
assert project.name == "Hello"
|
|
await project.update(name="World")
|
|
assert project.name == "World"
|
|
project.emit_controller_notification.assert_any_call("project.updated", project.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_update_on_compute(controller):
|
|
|
|
variables = [{"name": "TEST", "value": "VAL1"}]
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
project = Project(controller=controller, name="Test")
|
|
project._project_created_on_compute = [compute]
|
|
project.emit_notification = MagicMock()
|
|
await project.update(variables=variables)
|
|
compute.put.assert_any_call(f"/projects/{project.id}", {"variables": variables})
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_path(projects_dir):
|
|
|
|
directory = projects_dir
|
|
with patch("gns3server.utils.path.get_default_project_directory", return_value=directory):
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
|
|
p = Project(project_id=str(uuid4()), name="Test")
|
|
mock_notification.assert_called()
|
|
assert p.path == os.path.join(directory, p.id)
|
|
assert os.path.exists(os.path.join(directory, p.id))
|
|
|
|
|
|
def test_path_exist(tmpdir):
|
|
"""
|
|
Should raise an error when you try to overwrite
|
|
an existing project
|
|
"""
|
|
|
|
os.makedirs(str(tmpdir / "demo"))
|
|
with pytest.raises(ControllerForbiddenError):
|
|
Project(name="Test", path=str(tmpdir / "demo"))
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_init_path(projects_dir):
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification") as mock_notification:
|
|
project_id = str(uuid4())
|
|
p = Project(project_id=project_id, name="Test")
|
|
mock_notification.assert_called()
|
|
assert p.path == os.path.join(projects_dir, project_id)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_changing_path_with_quote_not_allowed(projects_dir):
|
|
|
|
with pytest.raises(ControllerForbiddenError):
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification"):
|
|
p = Project(project_id=str(uuid4()), name="Test")
|
|
p.path = os.path.join(projects_dir, 'project"53')
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_captures_directory(tmpdir):
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification"):
|
|
p = Project(name="Test")
|
|
assert p.captures_directory == str(p.path + os.path.sep + "project-files" + os.path.sep + "captures")
|
|
assert os.path.exists(p.captures_directory)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_local(controller):
|
|
"""
|
|
For a local server we send the project path
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_script": "test.cfg"})
|
|
assert node.id in project._nodes
|
|
|
|
compute.post.assert_any_call(
|
|
"/projects",
|
|
data={
|
|
"name": project._name,
|
|
"project_id": project._id,
|
|
"path": project._path,
|
|
},
|
|
)
|
|
compute.post.assert_any_call(
|
|
f"/projects/{project.id}/vpcs/nodes",
|
|
data={"node_id": node.id, "startup_script": "test.cfg", "name": "test"},
|
|
timeout=1200,
|
|
)
|
|
assert compute in project._project_created_on_compute
|
|
project.emit_notification.assert_any_call("node.created", node.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_from_template_seeds_default_credentials(controller):
|
|
"""
|
|
The appliance metadata stays template level: creating a node from a
|
|
template seeds the default credentials on the node and must not leak
|
|
the metadata into the node properties sent to the compute.
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
controller._computes["local"] = compute
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
template = {
|
|
"name": "VPCS_TEST",
|
|
"template_type": "vpcs",
|
|
"compute_id": "local",
|
|
"default_name_format": "PC{0}",
|
|
"properties": {"startup_script": "test.cfg"},
|
|
"appliance_metadata": {
|
|
"vendor_name": "Test vendor",
|
|
"default_username": "admin",
|
|
"default_password": "secret",
|
|
},
|
|
}
|
|
|
|
node = await project.add_node_from_template(template)
|
|
|
|
# credentials seeded from the appliance metadata
|
|
assert node.default_username == "admin"
|
|
assert node.default_password == "secret"
|
|
# the metadata itself never reaches the node properties
|
|
assert "appliance_metadata" not in node.properties
|
|
assert "default_username" not in node.properties
|
|
assert "default_password" not in node.properties
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_from_template_name_invalid_in_hostname(controller):
|
|
"""
|
|
A template name with characters invalid in a hostname (e.g. "+" in a model name)
|
|
gives node names the compute accepts.
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
controller._computes["local"] = compute
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
template = {
|
|
"name": "MikroTik CCR1072-1G-8S+",
|
|
"template_type": "qemu",
|
|
"compute_id": "local",
|
|
"default_name_format": "{name}-{0}",
|
|
"properties": {},
|
|
}
|
|
|
|
node = await project.add_node_from_template(template)
|
|
assert node.name == "MikroTikCCR1072-1G-8S-1"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_non_local(controller):
|
|
"""
|
|
For a non local server we do not send the project path
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "remote"
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_script": "test.cfg"})
|
|
|
|
compute.post.assert_any_call("/projects", data={"name": project._name, "project_id": project._id})
|
|
compute.post.assert_any_call(
|
|
f"/projects/{project.id}/vpcs/nodes",
|
|
data={"node_id": node.id, "startup_script": "test.cfg", "name": "test"},
|
|
timeout=1200,
|
|
)
|
|
assert compute in project._project_created_on_compute
|
|
project.emit_notification.assert_any_call("node.created", node.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_iou(controller):
|
|
"""
|
|
Test if an application ID is allocated for IOU nodes
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
project = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node1 = await project.add_node(compute, "test1", None, node_type="iou")
|
|
node2 = await project.add_node(compute, "test2", None, node_type="iou")
|
|
node3 = await project.add_node(compute, "test3", None, node_type="iou")
|
|
assert node1.properties["application_id"] == 1
|
|
assert node2.properties["application_id"] == 2
|
|
assert node3.properties["application_id"] == 3
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_iol_docker(controller):
|
|
"""
|
|
IOL Docker nodes (GNS3_IOL_RUNNER marker) get an application ID from the
|
|
upper half of the id space, disjoint from IOU's lower half
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
project = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
# template shape: environment as a top-level kwarg
|
|
node1 = await project.add_node(
|
|
compute, "iol1", None, node_type="docker", image="iol-xe/iol-xe:17-18-02", environment="GNS3_IOL_RUNNER=1"
|
|
)
|
|
# raw API shape: environment nested in properties
|
|
node2 = await project.add_node(
|
|
compute,
|
|
"iol2",
|
|
None,
|
|
node_type="docker",
|
|
properties={"image": "iol-xe/iol-xe:17-18-02", "environment": "GNS3_IOL_RUNNER=1"},
|
|
)
|
|
# plain docker nodes are left alone
|
|
node3 = await project.add_node(
|
|
compute, "web", None, node_type="docker", image="nginx", environment="FOO=1", adapters=1
|
|
)
|
|
|
|
assert node1.properties["application_id"] == 512
|
|
assert node2.properties["application_id"] == 513
|
|
assert "application_id" not in node3.properties
|
|
|
|
# IOU keeps its own pool: a subsequent IOU node still gets the lower half
|
|
node4 = await project.add_node(compute, "iou1", None, node_type="iou")
|
|
assert node4.properties["application_id"] == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_iou_with_multiple_projects(controller):
|
|
"""
|
|
Test if an application ID is allocated for IOU nodes with different projects already opened
|
|
"""
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
project1 = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
|
|
project1.emit_notification = MagicMock()
|
|
project2 = await controller.add_project(project_id=str(uuid.uuid4()), name="test2")
|
|
project2.emit_notification = MagicMock()
|
|
project3 = await controller.add_project(project_id=str(uuid.uuid4()), name="test3")
|
|
project3.emit_notification = MagicMock()
|
|
response = MagicMock()
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node1 = await project1.add_node(compute, "test1", None, node_type="iou")
|
|
node2 = await project1.add_node(compute, "test2", None, node_type="iou")
|
|
node3 = await project1.add_node(compute, "test3", None, node_type="iou")
|
|
|
|
node4 = await project2.add_node(compute, "test4", None, node_type="iou")
|
|
node5 = await project2.add_node(compute, "test5", None, node_type="iou")
|
|
node6 = await project2.add_node(compute, "test6", None, node_type="iou")
|
|
|
|
node7 = await project3.add_node(compute, "test7", None, node_type="iou")
|
|
node8 = await project3.add_node(compute, "test8", None, node_type="iou")
|
|
node9 = await project3.add_node(compute, "test9", None, node_type="iou")
|
|
|
|
assert node1.properties["application_id"] == 1
|
|
assert node2.properties["application_id"] == 2
|
|
assert node3.properties["application_id"] == 3
|
|
|
|
assert node4.properties["application_id"] == 4
|
|
assert node5.properties["application_id"] == 5
|
|
assert node6.properties["application_id"] == 6
|
|
|
|
assert node7.properties["application_id"] == 7
|
|
assert node8.properties["application_id"] == 8
|
|
assert node9.properties["application_id"] == 9
|
|
|
|
controller.remove_project(project1)
|
|
project4 = await controller.add_project(project_id=str(uuid.uuid4()), name="test4")
|
|
project4.emit_notification = MagicMock()
|
|
|
|
node10 = await project3.add_node(compute, "test10", None, node_type="iou")
|
|
node11 = await project3.add_node(compute, "test11", None, node_type="iou")
|
|
node12 = await project3.add_node(compute, "test12", None, node_type="iou")
|
|
|
|
assert node10.properties["application_id"] == 1
|
|
assert node11.properties["application_id"] == 2
|
|
assert node12.properties["application_id"] == 3
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_iou_with_multiple_projects_different_computes(controller):
|
|
"""
|
|
Test if an application ID is allocated for IOU nodes with different projects already opened
|
|
"""
|
|
compute1 = MagicMock()
|
|
compute1.id = "remote1"
|
|
compute2 = MagicMock()
|
|
compute2.id = "remote2"
|
|
project1 = await controller.add_project(project_id=str(uuid.uuid4()), name="test1")
|
|
project1.emit_notification = MagicMock()
|
|
project2 = await controller.add_project(project_id=str(uuid.uuid4()), name="test2")
|
|
project2.emit_notification = MagicMock()
|
|
response = MagicMock()
|
|
compute1.post = AsyncioMagicMock(return_value=response)
|
|
compute2.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node1 = await project1.add_node(compute1, "test1", None, node_type="iou")
|
|
node2 = await project1.add_node(compute1, "test2", None, node_type="iou")
|
|
|
|
node3 = await project2.add_node(compute2, "test3", None, node_type="iou")
|
|
node4 = await project2.add_node(compute2, "test4", None, node_type="iou")
|
|
|
|
assert node1.properties["application_id"] == 1
|
|
assert node2.properties["application_id"] == 2
|
|
|
|
assert node3.properties["application_id"] == 1
|
|
assert node4.properties["application_id"] == 2
|
|
|
|
node5 = await project1.add_node(compute2, "test5", None, node_type="iou")
|
|
node6 = await project2.add_node(compute1, "test6", None, node_type="iou")
|
|
|
|
assert node5.properties["application_id"] == 3
|
|
assert node6.properties["application_id"] == 4
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_iou_no_id_available(controller):
|
|
"""
|
|
Test if an application ID is allocated for IOU nodes
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
project = await controller.add_project(project_id=str(uuid.uuid4()), name="test")
|
|
project.emit_notification = MagicMock()
|
|
response = MagicMock()
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
with pytest.raises(ControllerError):
|
|
for i in range(1, 513):
|
|
prop = {"properties": {"application_id": i}}
|
|
project._nodes[i] = Node(project, compute, f"Node{i}", node_id=i, node_type="iou", **prop)
|
|
await project.add_node(compute, "test1", None, node_type="iou")
|
|
|
|
|
|
# @pytest.mark.asyncio
|
|
# async def test_add_node_from_template(controller):
|
|
# """
|
|
# For a local server we send the project path
|
|
# """
|
|
#
|
|
# compute = MagicMock()
|
|
# compute.id = "local"
|
|
# project = Project(controller=controller, name="Test")
|
|
# project.emit_notification = MagicMock()
|
|
# template = Template(str(uuid.uuid4()), {
|
|
# "compute_id": "local",
|
|
# "name": "Test",
|
|
# "template_type": "vpcs",
|
|
# "builtin": False,
|
|
# })
|
|
# controller.template_manager.templates[template.id] = template
|
|
# controller._computes["local"] = compute
|
|
#
|
|
# response = MagicMock()
|
|
# response.json = {"console": 2048}
|
|
# compute.post = AsyncioMagicMock(return_value=response)
|
|
#
|
|
# node = await project.add_node_from_template(template.id, x=23, y=12)
|
|
# compute.post.assert_any_call('/projects', data={
|
|
# "name": project._name,
|
|
# "project_id": project._id,
|
|
# "path": project._path
|
|
# })
|
|
#
|
|
# assert compute in project._project_created_on_compute
|
|
# project.emit_notification.assert_any_call("node.created", node.asdict())
|
|
#
|
|
#
|
|
# @pytest.mark.asyncio
|
|
# async def test_add_builtin_node_from_template(controller):
|
|
# """
|
|
# For a local server we send the project path
|
|
# """
|
|
#
|
|
# compute = MagicMock()
|
|
# compute.id = "local"
|
|
# project = Project(controller=controller, name="Test")
|
|
# project.emit_notification = MagicMock()
|
|
# template = Template(str(uuid.uuid4()), {
|
|
# "name": "Builtin-switch",
|
|
# "template_type": "ethernet_switch",
|
|
# }, builtin=True)
|
|
#
|
|
# controller.template_manager.templates[template.id] = template
|
|
# template.asdict()
|
|
# controller._computes["local"] = compute
|
|
#
|
|
# response = MagicMock()
|
|
# response.json = {"console": 2048}
|
|
# compute.post = AsyncioMagicMock(return_value=response)
|
|
#
|
|
# node = await project.add_node_from_template(template.id, x=23, y=12, compute_id="local")
|
|
# compute.post.assert_any_call('/projects', data={
|
|
# "name": project._name,
|
|
# "project_id": project._id,
|
|
# "path": project._path
|
|
# })
|
|
#
|
|
# assert compute in project._project_created_on_compute
|
|
# project.emit_notification.assert_any_call("node.created", node.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_node(controller):
|
|
"""
|
|
For a local server we send the project path
|
|
"""
|
|
compute = MagicMock()
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert node.id in project._nodes
|
|
await project.delete_node(node.id)
|
|
assert node.id not in project._nodes
|
|
|
|
compute.delete.assert_any_call(f"/projects/{project.id}/vpcs/nodes/{node.id}")
|
|
project.emit_notification.assert_any_call("node.deleted", node.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_locked_node(controller):
|
|
"""
|
|
For a local server we send the project path
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert node.id in project._nodes
|
|
node.locked = True
|
|
with pytest.raises(ControllerError):
|
|
await project.delete_node(node.id)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_node_delete_link(controller):
|
|
"""
|
|
Delete a node delete all the node connected
|
|
"""
|
|
compute = MagicMock()
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
|
|
link = await project.add_link()
|
|
await link.add_node(node, 0, 0)
|
|
|
|
await project.delete_node(node.id)
|
|
assert node.id not in project._nodes
|
|
assert link.id not in project._links
|
|
|
|
compute.delete.assert_any_call(f"/projects/{project.id}/vpcs/nodes/{node.id}")
|
|
project.emit_notification.assert_any_call("node.deleted", node.asdict())
|
|
project.emit_notification.assert_any_call("link.deleted", link.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_node(controller):
|
|
|
|
compute = MagicMock()
|
|
project = Project(controller=controller, name="Test")
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
vm = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert project.get_node(vm.id) == vm
|
|
|
|
with pytest.raises(ControllerNotFoundError):
|
|
project.get_node("test")
|
|
|
|
# Raise an error if the project is not opened
|
|
await project.close()
|
|
with pytest.raises(ControllerForbiddenError):
|
|
project.get_node(vm.id)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_nodes(controller):
|
|
|
|
compute = MagicMock()
|
|
project = Project(controller=controller, name="Test")
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
vm = await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert len(project.nodes) == 1
|
|
assert isinstance(project.nodes, dict)
|
|
|
|
await project.close()
|
|
assert len(project.nodes) == 1
|
|
assert isinstance(project.nodes, dict)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_link(project):
|
|
|
|
compute = MagicMock()
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
vm1 = await project.add_node(compute, "test1", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
vm1._ports = [EthernetPort("E0", 0, 3, 1)]
|
|
vm2 = await project.add_node(compute, "test2", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
vm2._ports = [EthernetPort("E0", 0, 4, 2)]
|
|
project.emit_notification = MagicMock()
|
|
link = await project.add_link()
|
|
await link.add_node(vm1, 3, 1)
|
|
with asyncio_patch("gns3server.controller.udp_link.UDPLink.create") as mock_udp_create:
|
|
await link.add_node(vm2, 4, 2)
|
|
assert mock_udp_create.called
|
|
assert len(link._nodes) == 2
|
|
project.emit_notification.assert_any_call("link.created", link.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_links(project):
|
|
|
|
compute = MagicMock()
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
await project.add_link()
|
|
assert len(project.links) == 1
|
|
|
|
await project.close()
|
|
assert len(project.links) == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_link(project):
|
|
|
|
compute = MagicMock()
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
link = await project.add_link()
|
|
assert project.get_link(link.id) == link
|
|
|
|
with pytest.raises(ControllerNotFoundError):
|
|
project.get_link("test")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_link(project):
|
|
|
|
compute = MagicMock()
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
assert len(project._links) == 0
|
|
link = await project.add_link()
|
|
assert len(project._links) == 1
|
|
project.emit_notification = MagicMock()
|
|
await project.delete_link(link.id)
|
|
project.emit_notification.assert_any_call("link.deleted", link.asdict())
|
|
assert len(project._links) == 0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_drawing(project):
|
|
|
|
project.emit_notification = MagicMock()
|
|
drawing = await project.add_drawing(None, svg="<svg></svg>")
|
|
assert len(project._drawings) == 1
|
|
project.emit_notification.assert_any_call("drawing.created", drawing.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_get_drawing(project):
|
|
|
|
drawing = await project.add_drawing(None)
|
|
assert project.get_drawing(drawing.id) == drawing
|
|
|
|
with pytest.raises(ControllerNotFoundError):
|
|
project.get_drawing("test")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_drawing(project):
|
|
|
|
await project.add_drawing(None)
|
|
assert len(project.drawings) == 1
|
|
|
|
await project.close()
|
|
assert len(project.drawings) == 1
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_drawing(project):
|
|
|
|
assert len(project._drawings) == 0
|
|
drawing = await project.add_drawing()
|
|
assert len(project._drawings) == 1
|
|
project.emit_notification = MagicMock()
|
|
await project.delete_drawing(drawing.id)
|
|
project.emit_notification.assert_any_call("drawing.deleted", drawing.asdict())
|
|
assert len(project._drawings) == 0
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clean_pictures(project):
|
|
"""
|
|
When a project is close old pictures should be removed
|
|
"""
|
|
|
|
drawing = await project.add_drawing()
|
|
drawing._svg = "test.png"
|
|
open(os.path.join(project.pictures_directory, "test.png"), "w+").close()
|
|
open(os.path.join(project.pictures_directory, "test2.png"), "w+").close()
|
|
await project.close()
|
|
assert os.path.exists(os.path.join(project.pictures_directory, "test.png"))
|
|
assert not os.path.exists(os.path.join(project.pictures_directory, "test2.png"))
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_clean_pictures_and_keep_supplier_logo(project):
|
|
"""
|
|
When a project is close old pictures should be removed
|
|
"""
|
|
|
|
project.supplier = {"logo": "logo.png", "url": "http://acme.com"}
|
|
|
|
drawing = await project.add_drawing()
|
|
drawing._svg = "test.png"
|
|
open(os.path.join(project.pictures_directory, "test.png"), "w+").close()
|
|
open(os.path.join(project.pictures_directory, "test2.png"), "w+").close()
|
|
open(os.path.join(project.pictures_directory, "logo.png"), "w+").close()
|
|
|
|
await project.close()
|
|
assert os.path.exists(os.path.join(project.pictures_directory, "test.png"))
|
|
assert not os.path.exists(os.path.join(project.pictures_directory, "test2.png"))
|
|
assert os.path.exists(os.path.join(project.pictures_directory, "logo.png"))
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete(project):
|
|
|
|
assert os.path.exists(project.path)
|
|
await project.delete()
|
|
assert not os.path.exists(project.path)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_refuses_to_delete_projects_directory(project, projects_dir):
|
|
"""
|
|
A poisoned entry whose path is the projects directory itself (a .gns3
|
|
loaded directly from the projects root before the guard existed) must
|
|
not be deletable: rmtree would wipe every project on the controller.
|
|
"""
|
|
|
|
other_project = os.path.join(projects_dir, "another-project")
|
|
os.makedirs(other_project, exist_ok=True)
|
|
|
|
# Simulate the poisoned in-memory state directly: the path setter now
|
|
# rejects such an assignment, but a long-running server can still hold
|
|
# an entry created before the fix.
|
|
project._path = projects_dir
|
|
|
|
with pytest.raises(ControllerError):
|
|
await project.delete()
|
|
assert os.path.exists(other_project)
|
|
|
|
|
|
def test_path_setter_rejects_projects_directory(project, projects_dir):
|
|
"""
|
|
The projects directory itself must never become a project directory.
|
|
"""
|
|
|
|
with pytest.raises(ControllerForbiddenError):
|
|
project.path = projects_dir
|
|
assert project.path == os.path.join(projects_dir, project.id)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_does_not_start_nodes(project):
|
|
"""
|
|
Deleting a project must not start its nodes, even when auto_start is enabled.
|
|
"""
|
|
|
|
project.auto_start = True
|
|
project.dump()
|
|
await project.close()
|
|
project.start_all = AsyncioMagicMock()
|
|
await project.delete()
|
|
assert not project.start_all.called
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_dump(projects_dir):
|
|
|
|
directory = projects_dir
|
|
with patch("gns3server.utils.path.get_default_project_directory", return_value=directory):
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification"):
|
|
p = Project(project_id="00010203-0405-0607-0809-0a0b0c0d0e0f", name="Test")
|
|
p.dump()
|
|
with open(os.path.join(directory, p.id, "Test.gns3")) as f:
|
|
content = f.read()
|
|
assert "00010203-0405-0607-0809-0a0b0c0d0e0f" in content
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_open_close(controller):
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification"):
|
|
project = Project(controller=controller, name="Test")
|
|
assert project.status == "opened"
|
|
await project.close()
|
|
project.start_all = AsyncioMagicMock()
|
|
await project.open()
|
|
assert not project.start_all.called
|
|
assert project.status == "opened"
|
|
project.emit_controller_notification = MagicMock()
|
|
await project.close()
|
|
assert project.status == "closed"
|
|
project.emit_controller_notification.assert_any_call("project.closed", project.asdict())
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_open_auto_start(controller):
|
|
|
|
with patch("gns3server.controller.project.Project.emit_controller_notification"):
|
|
project = Project(controller=controller, name="Test", auto_start=True)
|
|
assert project.status == "opened"
|
|
await project.close()
|
|
# project.start_all = AsyncioMagicMock()
|
|
# await project.open()
|
|
# assert project.start_all.called
|
|
|
|
|
|
def test_is_running(project, node):
|
|
"""
|
|
If a node is started or paused return True
|
|
"""
|
|
|
|
assert project.is_running() is False
|
|
node._status = "started"
|
|
assert project.is_running() is True
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_duplicate(project, controller):
|
|
"""
|
|
Duplicate a project, the node should remain on the remote server
|
|
if they were on remote server
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "remote"
|
|
compute.list_files = AsyncioMagicMock(return_value=[])
|
|
controller._computes["remote"] = compute
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
remote_vpcs = await project.add_node(
|
|
compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
|
|
)
|
|
|
|
# We allow node not allowed for standard import / export
|
|
remote_virtualbox = await project.add_node(
|
|
compute, "test", None, node_type="vmware", properties={"startup_config": "test.cfg"}
|
|
)
|
|
|
|
new_project = await project.duplicate(name="Hello")
|
|
assert new_project.id != project.id
|
|
assert new_project.name == "Hello"
|
|
|
|
await new_project.open()
|
|
|
|
assert list(new_project.nodes.values())[0].compute.id == "remote"
|
|
assert list(new_project.nodes.values())[1].compute.id == "remote"
|
|
|
|
|
|
def test_snapshots(project):
|
|
"""
|
|
List the snapshots
|
|
"""
|
|
|
|
os.makedirs(os.path.join(project.path, "snapshots"))
|
|
open(os.path.join(project.path, "snapshots", "test1_260716_103713.gns3project"), "w+").close()
|
|
project.reset()
|
|
|
|
assert len(project.snapshots) == 1
|
|
assert list(project.snapshots.values())[0].name == "test1"
|
|
|
|
|
|
def test_get_snapshot(project):
|
|
|
|
os.makedirs(os.path.join(project.path, "snapshots"))
|
|
open(os.path.join(project.path, "snapshots", "test1_260716_103713.gns3project"), "w+").close()
|
|
project.reset()
|
|
|
|
snapshot = list(project.snapshots.values())[0]
|
|
assert project.get_snapshot(snapshot.id) == snapshot
|
|
|
|
with pytest.raises(ControllerNotFoundError):
|
|
project.get_snapshot("BLU")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_delete_snapshot(project):
|
|
|
|
os.makedirs(os.path.join(project.path, "snapshots"))
|
|
open(os.path.join(project.path, "snapshots", "test1_260716_103713.gns3project"), "w+").close()
|
|
project.reset()
|
|
|
|
snapshot = list(project.snapshots.values())[0]
|
|
assert project.get_snapshot(snapshot.id) == snapshot
|
|
|
|
await project.delete_snapshot(snapshot.id)
|
|
|
|
with pytest.raises(ControllerNotFoundError):
|
|
project.get_snapshot(snapshot.id)
|
|
|
|
assert not os.path.exists(os.path.join(project.path, "snapshots", "test1.gns3project"))
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_snapshot(project):
|
|
"""
|
|
Create a snapshot
|
|
"""
|
|
|
|
assert len(project.snapshots) == 0
|
|
snapshot = await project.snapshot("test1")
|
|
assert snapshot.name == "test1"
|
|
|
|
assert len(project.snapshots) == 1
|
|
assert list(project.snapshots.values())[0].name == "test1"
|
|
|
|
# Raise a conflict if name is already use
|
|
with pytest.raises(ControllerError):
|
|
snapshot = await project.snapshot("test1")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_start_all(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
for node_i in range(0, 10):
|
|
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
|
|
compute.post = AsyncioMagicMock()
|
|
await project.start_all()
|
|
assert len(compute.post.call_args_list) == 10
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_stop_all(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
for node_i in range(0, 10):
|
|
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
|
|
compute.post = AsyncioMagicMock()
|
|
await project.stop_all()
|
|
assert len(compute.post.call_args_list) == 10
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_stop_all_skips_nodes_with_missing_images(project):
|
|
node = MagicMock()
|
|
node.is_always_running.return_value = False
|
|
node.missing_image = True
|
|
node.stop = AsyncioMagicMock()
|
|
project._nodes[node.id] = node
|
|
|
|
await project.stop_all()
|
|
|
|
node.stop.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_suspend_all(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
for node_i in range(0, 10):
|
|
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
|
|
compute.post = AsyncioMagicMock()
|
|
await project.suspend_all()
|
|
assert len(compute.post.call_args_list) == 10
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_suspend_all_skips_nodes_with_missing_images(project):
|
|
node = MagicMock()
|
|
node.missing_image = True
|
|
node.suspend = AsyncioMagicMock()
|
|
project._nodes[node.id] = node
|
|
|
|
await project.suspend_all()
|
|
|
|
node.suspend.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_console_reset_all(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048, "console_type": "telnet"}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
for node_i in range(0, 10):
|
|
await project.add_node(compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
|
|
compute.post = AsyncioMagicMock()
|
|
await project.reset_console_all()
|
|
assert len(compute.post.call_args_list) == 10
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_console_reset_all_skips_nodes_with_missing_images(project):
|
|
node = MagicMock()
|
|
node.missing_image = True
|
|
node.reset_console = AsyncioMagicMock()
|
|
project._nodes[node.id] = node
|
|
|
|
await project.reset_console_all()
|
|
|
|
node.reset_console.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_node_name(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(
|
|
compute, "test-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
|
|
)
|
|
assert node.name == "test-1"
|
|
node = await project.add_node(
|
|
compute, "test-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
|
|
)
|
|
assert node.name == "test-2"
|
|
node = await project.add_node(
|
|
compute, "hello world-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
|
|
)
|
|
assert node.name == "helloworld-1"
|
|
node = await project.add_node(
|
|
compute, "hello world-{0}", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
|
|
)
|
|
assert node.name == "helloworld-2"
|
|
node = await project.add_node(compute, "VPCS-1", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert node.name == "VPCS-1"
|
|
node = await project.add_node(compute, "VPCS-1", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert node.name == "VPCS-2"
|
|
|
|
node = await project.add_node(compute, "R3", None, node_type="vpcs", properties={"startup_config": "test.cfg"})
|
|
assert node.name == "R3"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_node_name_strict(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node = await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=True)
|
|
assert node.name == "R1"
|
|
with pytest.raises(ControllerError):
|
|
await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=True)
|
|
assert len(project.nodes) == 1
|
|
|
|
node = await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=False)
|
|
assert node.name == "R2"
|
|
node = await project.add_node(compute, "T{0}", None, node_type="vpcs", strict_names=True)
|
|
assert node.name == "T1"
|
|
node = await project.add_node(compute, "T{0}", None, node_type="vpcs", strict_names=True)
|
|
assert node.name == "T2"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_node_name_released_when_creation_fails(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
compute.post = AsyncioMagicMock(side_effect=ControllerError("failure"))
|
|
|
|
with pytest.raises(ControllerError):
|
|
await project.add_node(compute, "R1", None, node_type="vpcs")
|
|
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
node = await project.add_node(compute, "R1", None, node_type="vpcs", strict_names=True)
|
|
assert node.name == "R1"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_duplicate_node(project):
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
original = await project.add_node(
|
|
compute, "test", None, node_type="vpcs", properties={"startup_config": "test.cfg"}
|
|
)
|
|
new_node = await project.duplicate_node(original, 42, 10, 11)
|
|
assert new_node.x == 42
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_add_node_missing_image_kept_in_degraded_state(controller):
|
|
"""
|
|
A node whose image is missing is kept on the controller with the missing
|
|
image list instead of failing, when allow_missing_image is set.
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
compute.connected = True
|
|
project = Project(controller=controller, name="Test")
|
|
project.emit_notification = MagicMock()
|
|
|
|
async def post(url, data=None, **kwargs):
|
|
if url.endswith("/qemu/nodes"):
|
|
raise ComputeConflictError(
|
|
url, {"message": "missing", "image": "missing.qcow2", "exception": "ImageMissingError"}
|
|
)
|
|
response = MagicMock()
|
|
response.json = {}
|
|
return response
|
|
|
|
compute.post = AsyncioMagicMock(side_effect=post)
|
|
|
|
node = await project.add_node(
|
|
compute,
|
|
"r1",
|
|
None,
|
|
node_type="qemu",
|
|
allow_missing_image=True,
|
|
properties={"hda_disk_image": "missing.qcow2", "ram": 256},
|
|
)
|
|
assert node.missing_image is True
|
|
assert node.id in project._nodes
|
|
assert node.missing_images == [{"property": "hda_disk_image", "image": "missing.qcow2", "image_type": "qemu"}]
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_open_with_missing_image_defers_links(controller, projects_dir):
|
|
"""
|
|
Opening a project with a missing image succeeds, keeps the degraded node
|
|
and its links in the topology, but does not create the NIOs.
|
|
"""
|
|
|
|
project_id = "3c1be6f9-b4ba-4737-b209-63c47c23359f"
|
|
qemu_id = "11111111-1111-1111-1111-111111111111"
|
|
iou_id = "33333333-3333-3333-3333-333333333333"
|
|
vpcs_id = "22222222-2222-2222-2222-222222222222"
|
|
link_id = "5a3e3a64-e853-4055-9503-4a14e01290f1"
|
|
|
|
topology = {
|
|
"auto_close": True,
|
|
"auto_open": False,
|
|
"auto_start": False,
|
|
"name": "demo",
|
|
"project_id": project_id,
|
|
"revision": 5,
|
|
"topology": {
|
|
"computes": [],
|
|
"drawings": [],
|
|
"links": [
|
|
{
|
|
"link_id": link_id,
|
|
"nodes": [
|
|
{"adapter_number": 0, "node_id": qemu_id, "port_number": 0},
|
|
{"adapter_number": 0, "node_id": vpcs_id, "port_number": 0},
|
|
],
|
|
}
|
|
],
|
|
"nodes": [
|
|
{
|
|
"compute_id": "local",
|
|
"name": "R1",
|
|
"node_id": qemu_id,
|
|
"node_type": "qemu",
|
|
"properties": {"hda_disk_image": "missing.qcow2", "adapters": 1, "ram": 256},
|
|
"symbol": ":/symbols/router.svg",
|
|
"x": 0,
|
|
"y": 0,
|
|
},
|
|
{
|
|
"compute_id": "local",
|
|
"name": "IOU1",
|
|
"node_id": iou_id,
|
|
"node_type": "iou",
|
|
"properties": {"path": "missing.bin"},
|
|
"symbol": ":/symbols/router.svg",
|
|
"x": 200,
|
|
"y": 0,
|
|
},
|
|
{
|
|
"compute_id": "local",
|
|
"name": "PC1",
|
|
"node_id": vpcs_id,
|
|
"node_type": "vpcs",
|
|
"properties": {},
|
|
"symbol": ":/symbols/computer.svg",
|
|
"x": 100,
|
|
"y": 0,
|
|
},
|
|
],
|
|
},
|
|
"type": "topology",
|
|
"version": "2.0.0",
|
|
}
|
|
|
|
project_dir = os.path.join(projects_dir, "demo")
|
|
os.makedirs(project_dir, exist_ok=True)
|
|
with open(os.path.join(project_dir, "demo.gns3"), "w+") as f:
|
|
json.dump(topology, f)
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
compute.connected = True
|
|
compute.name = "local"
|
|
compute.console_host = "127.0.0.1"
|
|
controller._computes["local"] = compute
|
|
|
|
async def post(url, data=None, **kwargs):
|
|
if url.endswith("/qemu/nodes"):
|
|
raise ComputeConflictError(
|
|
url, {"message": "missing", "image": "missing.qcow2", "exception": "ImageMissingError"}
|
|
)
|
|
if url.endswith("/iou/nodes"):
|
|
raise ComputeConflictError(
|
|
url, {"message": "missing", "image": "missing.bin", "exception": "ImageMissingError"}
|
|
)
|
|
response = MagicMock()
|
|
if "ports/udp/batch" in url:
|
|
response.json = {"udp_ports": [20000]}
|
|
else:
|
|
response.json = {}
|
|
return response
|
|
|
|
compute.post = AsyncioMagicMock(side_effect=post)
|
|
|
|
project = Project(
|
|
name="demo",
|
|
project_id=project_id,
|
|
path=project_dir,
|
|
controller=controller,
|
|
filename="demo.gns3",
|
|
status="closed",
|
|
)
|
|
|
|
await project.open()
|
|
assert project.status == "opened"
|
|
|
|
qemu_node = project.get_node(qemu_id)
|
|
assert qemu_node.missing_image is True
|
|
assert qemu_node.missing_images[0]["image"] == "missing.qcow2"
|
|
|
|
iou_node = project.get_node(iou_id)
|
|
assert iou_node.missing_image is True
|
|
assert iou_node.missing_images[0]["image"] == "missing.bin"
|
|
assert iou_node.missing_images[0]["image_type"] == "iou"
|
|
|
|
link = project._links[link_id]
|
|
assert link._deferred is True
|
|
assert link.created is False
|
|
assert link in qemu_node.links
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_restore_deferred_links(project):
|
|
"""
|
|
Once a degraded node is created, the deferred links are created on the
|
|
computes and no longer flagged as deferred.
|
|
"""
|
|
|
|
compute = MagicMock()
|
|
compute.id = "local"
|
|
response = MagicMock()
|
|
response.json = {"console": 2048}
|
|
compute.post = AsyncioMagicMock(return_value=response)
|
|
|
|
node1 = await project.add_node(compute, "n1", None, node_type="vpcs", properties={})
|
|
node2 = await project.add_node(compute, "n2", None, node_type="vpcs", properties={})
|
|
|
|
link = await project.add_link()
|
|
await link.add_node(node1, 0, 0, batch=True)
|
|
await link.add_node(node2, 0, 0, batch=True)
|
|
link._nodes[0]["port"].link = link
|
|
link._nodes[1]["port"].link = link
|
|
node1.add_link(link)
|
|
node2.add_link(link)
|
|
link._deferred = True
|
|
link.create = AsyncioMagicMock()
|
|
|
|
project.emit_notification = MagicMock()
|
|
await project.restore_deferred_links(node1)
|
|
|
|
assert link._deferred is False
|
|
assert link.create.called is True
|