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

Merge pull request #1134 from GNS3/suspend_link

Browse Source 
Suspend link
This commit is contained in:
Jeremy Grossmann 2017-07-20 11:14:15 +07:00 committed by GitHub
commit 90cdf14c2a
7 changed files with 163 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
gns3server/controller/link.py
View File

@ -122,6 +122,7 @@ class Link:
self._streaming_pcap = None
self._created = False
self._link_type = "ethernet"
self._suspend = False
self._filters = {}
@property
@ -131,6 +132,15 @@ class Link:
"""
return self._filters
def get_active_filters(self):
"""
Return the active filters.
Filters are overridden if the link is suspended.
"""
if self._suspend:
return {"frequency_drop": [-1]}
return self._filters
@asyncio.coroutine
def update_filters(self, filters):
"""
@ -155,6 +165,12 @@ class Link:
if self._created:
yield from self.update()
@asyncio.coroutine
def update_suspend(self, value):
if value != self._suspend:
self._suspend = value
yield from self.update()
@property
def created(self):
"""
@ -401,7 +417,8 @@ class Link:
return {
"nodes": res,
"link_id": self._id,
"filters": self._filters
"filters": self._filters,
"suspend": self._suspend
}
return {
"nodes": res,
@ -411,5 +428,6 @@ class Link:
"capture_file_name": self._capture_file_name,
"capture_file_path": self.capture_file_path,
"link_type": self._link_type,
"filters": self._filters
"filters": self._filters,
"suspend": self._suspend
}

10
gns3server/controller/udp_link.py
View File

@ -66,9 +66,9 @@ class UDPLink(Link):
node2_filters = {}
filter_node = self._get_filter_node()
if filter_node == node1:
node1_filters = self._filters
node1_filters = self.get_active_filters()
elif filter_node == node2:
node2_filters = self._filters
node2_filters = self.get_active_filters()
# Create the tunnel on both side
self._link_data.append({
@ -106,12 +106,12 @@ class UDPLink(Link):
if node1 == filter_node:
adapter_number1 = self._nodes[0]["adapter_number"]
port_number1 = self._nodes[0]["port_number"]
self._link_data[0]["filters"] = self._filters
self._link_data[0]["filters"] = self.get_active_filters()
yield from node1.put("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number1, port_number=port_number1), data=self._link_data[0], timeout=120)
elif node2 == filter_node:
adapter_number2 = self._nodes[1]["adapter_number"]
port_number2 = self._nodes[1]["port_number"]
self._link_data[1]["filters"] = self._filters
self._link_data[1]["filters"] = self.get_active_filters()
yield from node2.put("/adapters/{adapter_number}/ports/{port_number}/nio".format(adapter_number=adapter_number2, port_number=port_number2), data=self._link_data[1], timeout=221)
@asyncio.coroutine
@ -199,7 +199,7 @@ class UDPLink(Link):
if node["node"].node_type and node["node"].status == "started":
return node
raise aiohttp.web.HTTPConflict(text="Can not capture because no running device on this link")
raise aiohttp.web.HTTPConflict(text="Cannot capture because there is no running device on this link")
@asyncio.coroutine
def read_pcap_from_source(self):

10
gns3server/handlers/api/controller/link_handler.py
View File

@ -62,7 +62,10 @@ class LinkHandler:
project = yield from Controller.instance().get_loaded_project(request.match_info["project_id"])
link = yield from project.add_link()
yield from link.update_filters(request.json.get("filters", {}))
if "filters" in request.json:
yield from link.update_filters(request.json["filters"])
if "suspend" in request.json:
yield from link.update_suspend(request.json["suspend"])
try:
for node in request.json["nodes"]:
yield from link.add_node(project.get_node(node["node_id"]),
@ -110,7 +113,10 @@ class LinkHandler:
project = yield from Controller.instance().get_loaded_project(request.match_info["project_id"])
link = project.get_link(request.match_info["link_id"])
yield from link.update_filters(request.json.get("filters", {}))
if "filters" in request.json:
yield from link.update_filters(request.json["filters"])
if "suspend" in request.json:
yield from link.update_suspend(request.json["suspend"])
if "nodes" in request.json:
yield from link.update_nodes(request.json["nodes"])
response.set_status(201)

4
gns3server/schemas/link.py
View File

@ -64,6 +64,10 @@ LINK_OBJECT_SCHEMA = {
"additionalProperties": False
}
},
"suspend": {
"type": "boolean",
"description": "Suspend the link"
},
"filters": FILTER_OBJECT_SCHEMA,
"capturing": {
"description": "Read only property. True if a capture running on the link",

4
tests/controller/test_link.py
View File

@ -231,6 +231,7 @@ def test_json(async_run, project, compute, link):
}
],
"filters": {},
"suspend": False,
"link_type": "ethernet",
"capturing": False,
"capture_file_name": None,
@ -264,7 +265,8 @@ def test_json(async_run, project, compute, link):
}
}
],
"filters": {}
"filters": {},
"suspend": False
}

65
tests/controller/test_udp_link.py
View File

@ -384,3 +384,68 @@ def test_update(async_run, project):
"bpf": ["icmp[icmptype] == 8"]
}
}, timeout=120)
def test_update_suspend(async_run, project):
compute1 = MagicMock()
compute2 = MagicMock()
node1 = Node(project, compute1, "node1", node_type="vpcs")
node1._ports = [EthernetPort("E0", 0, 0, 4)]
node2 = Node(project, compute2, "node2", node_type="vpcs")
node2._ports = [EthernetPort("E0", 0, 3, 1)]
@asyncio.coroutine
def subnet_callback(compute2):
"""
Fake subnet callback
"""
return ("192.168.1.1", "192.168.1.2")
compute1.get_ip_on_same_subnet.side_effect = subnet_callback
link = UDPLink(project)
async_run(link.add_node(node1, 0, 4))
async_run(link.update_filters({"latency": [10]}))
async_run(link.update_suspend(True))
@asyncio.coroutine
def compute1_callback(path, data={}, **kwargs):
"""
Fake server
"""
if "/ports/udp" in path:
response = MagicMock()
response.json = {"udp_port": 1024}
return response
@asyncio.coroutine
def compute2_callback(path, data={}, **kwargs):
"""
Fake server
"""
if "/ports/udp" in path:
response = MagicMock()
response.json = {"udp_port": 2048}
return response
compute1.post.side_effect = compute1_callback
compute1.host = "example.com"
compute2.post.side_effect = compute2_callback
compute2.host = "example.org"
async_run(link.add_node(node2, 3, 1))
compute1.post.assert_any_call("/projects/{}/vpcs/nodes/{}/adapters/0/ports/4/nio".format(project.id, node1.id), data={
"lport": 1024,
"rhost": "192.168.1.2",
"rport": 2048,
"type": "nio_udp",
"filters": {"frequency_drop": [-1]}
}, timeout=120)
compute2.post.assert_any_call("/projects/{}/vpcs/nodes/{}/adapters/3/ports/1/nio".format(project.id, node2.id), data={
"lport": 2048,
"rhost": "192.168.1.1",
"rport": 1024,
"type": "nio_udp",
"filters": {}
}, timeout=120)

58
tests/handlers/api/controller/test_link.py
View File

@ -128,6 +128,64 @@ def test_create_link_failure(http_controller, tmpdir, project, compute, async_ru
assert len(project.links) == 0
def test_update_link_suspend(http_controller, tmpdir, project, compute, async_run):
response = MagicMock()
response.json = {"console": 2048}
compute.post = AsyncioMagicMock(return_value=response)
node1 = async_run(project.add_node(compute, "node1", None, node_type="qemu"))
node1._ports = [EthernetPort("E0", 0, 0, 3)]
node2 = async_run(project.add_node(compute, "node2", None, node_type="qemu"))
node2._ports = [EthernetPort("E0", 0, 2, 4)]
with asyncio_patch("gns3server.controller.udp_link.UDPLink.create"):
response = http_controller.post("/projects/{}/links".format(project.id), {
"nodes": [
{
"node_id": node1.id,
"adapter_number": 0,
"port_number": 3,
"label": {
"text": "Text",
"x": 42,
"y": 0
}
},
{
"node_id": node2.id,
"adapter_number": 2,
"port_number": 4
}
]
})
link_id = response.json["link_id"]
assert response.json["nodes"][0]["label"]["x"] == 42
response = http_controller.put("/projects/{}/links/{}".format(project.id, link_id), {
"nodes": [
{
"node_id": node1.id,
"adapter_number": 0,
"port_number": 3,
"label": {
"text": "Hello",
"x": 64,
"y": 0
}
},
{
"node_id": node2.id,
"adapter_number": 2,
"port_number": 4
}
],
"suspend": True
})
assert response.status == 201
assert response.json["nodes"][0]["label"]["x"] == 64
assert response.json["suspend"]
assert response.json["filters"] == {}
def test_update_link(http_controller, tmpdir, project, compute, async_run):
response = MagicMock()
response.json = {"console": 2048}