arno
/
gns3-server
mirror of https://github.com/GNS3/gns3-server
1
0
Fork 0
Code Issues Releases Wiki Activity

Fake console for simple Ethernet switch

Browse Source 
Fix #454
pull/1055/head
Julien Duponchelle 7 years ago
parent 4f6cca0019
commit 5616ab0e9a
No known key found for this signature in database
GPG Key ID: CE8B29639E07F5E8
5 changed files with 369 additions and 1 deletions
Show Stats Download Patch File Download Diff File

57
gns3server/compute/dynamips/nodes/ethernet_switch.py
Unescape View File

@ -22,6 +22,8 @@ http://github.com/GNS3/dynamips/blob/master/README.hypervisor#L558
import asyncio
from gns3server.utils import parse_version
from gns3server.utils.asyncio.embed_shell import EmbedShell, create_telnet_shell
from .device import Device
from ..nios.nio_udp import NIOUDP
@ -32,6 +34,36 @@ import logging
log = logging.getLogger(__name__)
class EthernetSwitchConsole(EmbedShell):
"""
Console for the ethernet switch
"""
def __init__(self, node):
super().__init__(welcome_message="Welcome to GNS3 builtin ethernet switch.\n\nType help to get help\n")
self._node = node
@asyncio.coroutine
def arp(self):
"""
Show arp table
"""
res = 'Mac VLAN\n'
result = (yield from self._node._hypervisor.send('ethsw show_mac_addr_table {}'.format(self._node.name)))
for line in result:
mac, vlan, _ = line.replace(' ', ' ').split(' ')
mac = mac.replace('.', '')
mac = "{}:{}:{}:{}:{}:{}".format(
mac[0:2],
mac[2:4],
mac[4:6],
mac[6:8],
mac[8:10],
mac[10:12])
res += mac + ' ' + vlan + '\n'
return res
class EthernetSwitch(Device):
"""
@ -50,6 +82,9 @@ class EthernetSwitch(Device):
super().__init__(name, node_id, project, manager, hypervisor)
self._nios = {}
self._mappings = {}
self._telnet_console = None
self._telnet_shell = None
self._console = self._manager.port_manager.get_free_tcp_port(self._project)
if ports is None:
# create 8 ports by default
self._ports = []
@ -61,15 +96,29 @@ class EthernetSwitch(Device):
else:
self._ports = ports
@property
def console(self):
return self._console
def __json__(self):
ethernet_switch_info = {"name": self.name,
"console": self.console,
"console_type": "telnet",
"node_id": self.id,
"project_id": self.project.id,
"ports_mapping": self._ports,
"status": "started"}
return ethernet_switch_info
@property
def console(self):
return self._console
@console.setter
def console(self, val):
self._console = val
@property
def ports_mapping(self):
"""
@ -115,6 +164,12 @@ class EthernetSwitch(Device):
yield from self._hypervisor.send('ethsw create "{}"'.format(self._name))
log.info('Ethernet switch "{name}" [{id}] has been created'.format(name=self._name, id=self._id))
self._telnet_shell = EthernetSwitchConsole(self)
self._telnet_shell.prompt = self._name + '> '
telnet = create_telnet_shell(self._telnet_shell)
self._telnet_server = (yield from asyncio.start_server(telnet.run, self._manager.port_manager.console_host, self.console))
self._hypervisor.devices.append(self)
@asyncio.coroutine
@ -164,7 +219,7 @@ class EthernetSwitch(Device):
for nio in self._nios.values():
if nio and isinstance(nio, NIOUDP):
self.manager.port_manager.release_udp_port(nio.lport, self._project)
self.manager.port_manager.release_tcp_port(self._console, self._project)
if self._hypervisor:
try:
yield from self._hypervisor.send('ethsw delete "{}"'.format(self._name))

20
gns3server/schemas/ethernet_switch.py
Unescape View File

@ -58,6 +58,16 @@ ETHERNET_SWITCH_CREATE_SCHEMA = {
"type": "string",
"minLength": 1,
},
"console": {
"description": "Console TCP port",
"minimum": 1,
"maximum": 65535,
"type": "integer"
},
"console_type": {
"description": "Console type",
"enum": ["telnet"]
},
"node_id": {
"description": "Node UUID",
"oneOf": [
@ -149,6 +159,16 @@ ETHERNET_SWITCH_OBJECT_SCHEMA = {
"description": "Node status",
"enum": ["started", "stopped", "suspended"]
},
"console": {
"description": "Console TCP port",
"minimum": 1,
"maximum": 65535,
"type": "integer"
},
"console_type": {
"description": "Console type",
"enum": ["telnet"]
},
},
"additionalProperties": False,
"required": ["name", "node_id", "project_id"]

187
gns3server/utils/asyncio/embed_shell.py
Unescape View File

@ -0,0 +1,187 @@
#!/usr/bin/env python
#
# Copyright (C) 2017 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 sys
import asyncio
import inspect
from .telnet_server import AsyncioTelnetServer
class EmbedShell:
"""
An asynchronous shell use for stuff like EthernetSwitch console
or built in VPCS
"""
def __init__(self, reader=None, writer=None, loop=None, welcome_message=None):
self._loop = loop
self._reader = reader
self._writer = writer
self._prompt = '> '
self._welcome_message = welcome_message
@property
def writer(self):
return self._writer
@writer.setter
def writer(self, val):
self._writer = val
@property
def reader(self):
return self._reader
@reader.setter
def reader(self, val):
self._reader = val
@property
def prompt(self):
return self._prompt
@prompt.setter
def prompt(self, val):
self._prompt = val
@asyncio.coroutine
def help(self, *args):
"""
Show help
"""
res = ''
if len(args) == 0:
res = 'Help:\n'
for name, value in inspect.getmembers(self):
if not inspect.isgeneratorfunction(value):
continue
if name.startswith('_') or (len(args) and name != args[0]) or name == 'run':
continue
doc = inspect.getdoc(value)
res += name
if len(args) and doc:
res += ': ' + doc
elif doc:
res += ': ' + doc.split('\n')[0]
res += '\n'
if len(args) == 0:
res += '\nhelp command for details about a command\n'
return res
@asyncio.coroutine
def _parse_command(self, text):
cmd = text.split(' ')
found = False
if cmd[0] == '?':
cmd[0] = 'help'
for (name, meth) in inspect.getmembers(self):
if name == cmd[0]:
cmd.pop(0)
res = yield from meth(*cmd)
found = True
break
if not found:
res = ('Command not found {}'.format(cmd[0]) + (yield from self.help()))
return res
@asyncio.coroutine
def run(self):
if self._welcome_message:
self._writer.feed_data(self._welcome_message.encode())
while True:
self._writer.feed_data(self._prompt.encode())
result = yield from self._reader.readline()
result = result.decode().strip('\n')
res = yield from self._parse_command(result)
self._writer.feed_data(res.encode())
def create_telnet_shell(shell, loop=None):
"""
Run a shell application with a telnet frontend
:param application: An EmbedShell instance
:param loop: The event loop
:returns: Telnet server
"""
class Stream(asyncio.StreamReader):
def write(self, data):
self.feed_data(data)
@asyncio.coroutine
def drain(self):
pass
shell.reader = Stream()
shell.writer = Stream()
if loop is None:
loop = asyncio.get_event_loop()
loop.create_task(shell.run())
return AsyncioTelnetServer(reader=shell.writer, writer=shell.reader, binary=False, echo=False)
if __name__ == '__main__':
loop = asyncio.get_event_loop()
class Demo(EmbedShell):
@asyncio.coroutine
def hello(self, *args):
"""
Hello world
This command accept arguments: hello tutu will display tutu
"""
if len(args):
return ' '.join(args)
else:
return 'world\n'
# Demo using telnet
server = create_telnet_shell(Demo())
coro = asyncio.start_server(server.run, '127.0.0.1', 4444, loop=loop)
s = loop.run_until_complete(coro)
try:
loop.run_forever()
except KeyboardInterrupt:
pass
# Demo using stdin
# @asyncio.coroutine
# def feed_stdin(loop, reader):
# while True:
# line = yield from loop.run_in_executor(None, sys.stdin.readline)
# reader.feed_data(line.encode())
#
# @asyncio.coroutine
# def read_stdout(writer):
# while True:
# c = yield from writer.read(1)
# print(c.decode(), end='')
# sys.stdout.flush()
#
# reader = asyncio.StreamReader()
# writer = asyncio.StreamReader()
# shell = Demo(reader, writer, loop=loop)
#
# reader_task = loop.create_task(feed_stdin(loop, reader))
# writer_task = loop.create_task(read_stdout(writer))
# shell_task = loop.create_task(shell.run())
# loop.run_until_complete(asyncio.gather(shell_task, writer_task, reader_task))
# loop.close()

31
tests/compute/dynamips/test_ethernet_switch.py
Unescape View File

@ -0,0 +1,31 @@
#!/usr/bin/env python
#
# Copyright (C) 2017 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/>.
from tests.utils import AsyncioMagicMock
from gns3server.compute.dynamips.nodes.ethernet_switch import EthernetSwitchConsole
def test_arp_command(async_run):
node = AsyncioMagicMock()
node.name = "Test"
node._hypervisor.send = AsyncioMagicMock(return_value=["0050.7966.6801 1 nio1", "0050.7966.6802 1 nio2"])
console = EthernetSwitchConsole(node)
assert async_run(console.arp()) == \
"Mac VLAN\n" \
"00:50:79:66:68:01 1\n" \
"00:50:79:66:68:02 1\n"
node._hypervisor.send.assert_called_with("ethsw show_mac_addr_table Test")

75
tests/utils/asyncio/test_embed_shell.py
Unescape View File

@ -0,0 +1,75 @@
#!/usr/bin/env python
#
# Copyright (C) 2017 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 asyncio
from gns3server.utils.asyncio.embed_shell import EmbedShell
def test_embed_shell_help(async_run):
class Application(EmbedShell):
@asyncio.coroutine
def hello(self):
"""
The hello world function
The hello usage
"""
pass
reader = asyncio.StreamReader()
writer = asyncio.StreamReader()
app = Application(reader, writer)
assert async_run(app._parse_command('help')) == 'Help:\nhello: The hello world function\nhelp: Show help\n\nhelp command for details about a command\n'
assert async_run(app._parse_command('?')) == 'Help:\nhello: The hello world function\nhelp: Show help\n\nhelp command for details about a command\n'
assert async_run(app._parse_command('? hello')) == 'hello: The hello world function\n\nThe hello usage\n'
def test_embed_shell_execute(async_run):
class Application(EmbedShell):
@asyncio.coroutine
def hello(self):
"""
The hello world function
The hello usage
"""
return 'world'
reader = asyncio.StreamReader()
writer = asyncio.StreamReader()
app = Application(reader, writer)
assert async_run(app._parse_command('hello')) == 'world'
def test_embed_shell_welcome(async_run, loop):
reader = asyncio.StreamReader()
writer = asyncio.StreamReader()
app = EmbedShell(reader, writer, welcome_message="Hello")
t = loop.create_task(app.run())
assert async_run(writer.read(5)) == b"Hello"
t.cancel()
def test_embed_shell_prompt(async_run, loop):
reader = asyncio.StreamReader()
writer = asyncio.StreamReader()
app = EmbedShell(reader, writer)
app.prompt = "gbash# "
t = loop.create_task(app.run())
assert async_run(writer.read(7)) == b"gbash# "
t.cancel()
Write Preview
Loading…
Cancel
Save