def test_server_close():
server_ctl = server.SSHUserPassController(username=getpass.getuser(),
password="******")
port = None
LAST_INDEX = 40000 + 5000
for port in range(40000, LAST_INDEX + 1):
try:
logger.info("Create server on port %d", port)
ns = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=port,
host_key="tests/host_key",
debug=SERVER_DEBUG)
break
except socket.error as error:
logger.info("Got exception: %s %d %d", str(error), error.errno,
errno.EADDRINUSE)
if error.errno != errno.EADDRINUSE or port == LAST_INDEX:
raise
logger.info("Connect to server on port %d", port)
session = client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
session.close()
# NetconfSSHSession.flush()
logger.debug("Closing")
ns.close()
logger.debug("Joining")
ns.join()
# import time
# time.sleep(.1)
for i in range(0, 10):
logger.debug("Starting %d iteration", i)
ns = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=port,
host_key="tests/host_key",
debug=SERVER_DEBUG)
logger.info("Connect to server on port %d", port)
session = client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
session.close()
# NetconfSSHSession.flush()
logger.debug("Closing")
ns.close()
logger.debug("Joining")
ns.join()
logger.debug("Test Complete")
def __init__(self, username, password, port, agent):
"""
The constructor for the NETCONF Server class.
:param username: username to allow the NETCONF server
:type username: str
:param password: password to allow the NETCONF server
:type password: str
:param port: port number to bind the NETCONF server
:type port: int
:param agent: Agent Core module
:type agent: AgentCore
"""
self.ac = agent
self.capability = None
self.configuration = bindingConfiguration.blueSPACE_DRoF_configuration(
)
self.capabilities = [
"blueSPACE-DRoF-configuration", "blueSPACE-DRoF-TP-capability"
]
try:
auth = server.SSHUserPassController(username=username,
password=password)
self.server = server.NetconfSSHServer(server_ctl=auth,
server_methods=self,
port=port,
debug=False)
logger.debug(
"CONNECTION to NETCONF Server on port {} created".format(port))
except Exception as e:
logger.error(
"CONNECTION to NETCONF Server refused, error: {}".format(e))
raise e
def start_server():
# Configure Netconf server listener and ip route
global netconf_server, ip_route
# Setup Netconf
if netconf_server is not None:
logger.error("Netconf Server is already up and running")
else:
server_ctl = server.SSHUserPassController(username=NC_USER,
password=NC_PASSWORD)
netconf_server = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=SRv6NetconfMethods(),
port=NC_PORT,
debug=SERVER_DEBUG)
# Setup ip route
if ip_route is not None:
logger.error("IP Route is already setup")
else:
ip_route = IPRoute()
# Resolve the interfaces
for interface in interfaces:
idxs[interface] = ip_route.link_lookup(ifname=interface)[0]
# Start the loop for Netconf
logger.info("Listening Netconf")
while True:
time.sleep(5)
def test_server_close():
server_ctl = server.SSHUserPassController(username=getpass.getuser(),
password="******")
for i in range(0, 10):
logger.debug("Starting %d iteration", i)
ns = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=None,
host_key="tests/host_key",
debug=SERVER_DEBUG)
port = ns.port
logger.info("Connect to server on port %d", port)
session = client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
session.close()
# NetconfSSHSession.flush()
logger.debug("Closing")
ns.close()
logger.debug("Joining")
ns.join()
logger.debug("Test Complete")
def _test_multi_open(client_cache):
logger.info("Create Server")
server_ctl = server.SSHUserPassController(username=getpass.getuser(),
password="******")
ns = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=NC_PORT,
host_key="tests/host_key",
debug=SERVER_DEBUG)
port = ns.port
logger.info("Open sessions")
sessions = [
client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG,
cache=client_cache)
for unused in range(0, 25)
]
logger.info("Close sessions")
for session in sessions:
session.close()
logger.info("Reopening")
sessions = [
client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
for unused in range(0, 25)
]
logger.info("Closeing")
for session in sessions:
session.close()
logger.info("Reopening")
sessions = [
client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
for unused in range(0, 25)
]
logger.info("Reclosing")
for session in sessions:
session.close()
# Close down the server and join it to make sure it's closed
logger.info("Closing server")
ns.close()
logger.info("Joining server")
ns.join()
# Delete the server so that we don't end up with a bunch of logging going on on exit.
del ns
del server_ctl
def __init__(self, port, host_key, auth, debug):
self.server = server.NetconfSSHServer(auth, self, port, host_key,
debug)
self.manufacturerCert = OpenSSL.crypto.load_certificate(
OpenSSL.crypto.FILETYPE_PEM,
getCertStringfromFile(
'/usr/src/app/vendorCert/www.ownership.vendor1.com.cert.pem'))
self.ownerCertificate = None
def __init__(self, username, password, port):
auth = server.SSHUserPassController(username=username,
password=password)
self.server = server.NetconfSSHServer(server_ctl=auth,
server_methods=self,
port=port,
debug=False)
self.node_topology = None
self.node_connectivity = node_connectivity()
def setup_module(unused_module):
if setup_module.init:
logger.error("XXX Called setup_module multiple times")
else:
logging.basicConfig(level=logging.DEBUG)
global ncserver
server_ctl = server.SSHUserPassController(username=getpass.getuser(),
password="******")
ncserver = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=NC_PORT,
host_key="tests/host_key",
debug=SERVER_DEBUG)
setup_module.init = True
def init_mock_server():
# logging.basicConfig(level=logging.DEBUG)
if init_mock_server.server is not None:
logger.error("XXX Called init_mock_server called multiple times")
else:
sctrl = ncserver.SSHUserPassController(username=getpass.getuser(), password="******")
init_mock_server.server = ncserver.NetconfSSHServer(
server_ctl=sctrl,
server_methods=MockMethods(),
port=None,
host_key="tests/host_key",
debug=NC_DEBUG)
return init_mock_server.server.port
def setup_module(unused_module):
global nc_server
logging.basicConfig(level=logging.DEBUG)
if nc_server is not None:
logger.error("XXX Called setup_module multiple times")
else:
sctrl = server.SSHUserPassController(username=getpass.getuser(),
password="******")
nc_server = server.NetconfSSHServer(server_ctl=sctrl,
server_methods=NetconfMethods(),
port=NC_PORT,
host_key="tests/host_key",
debug=NC_DEBUG)
def setup_module (unused_module):
global nc_server, uuid_set, device_category
yangModel, command_dict, uuid_set, device_category = generate_yang(test, uuid_set)
logging.basicConfig(level=logging.DEBUG)
if nc_server is not None:
logger.error("XXX Called setup_module multiple times")
else:
sctrl = netconf_server.SSHUserPassController(username=getpass.getuser(),
password="******")
nc_server = netconf_server.NetconfSSHServer(server_ctl=sctrl,
server_methods=NetconfMethods(),
port=NC_PORT,
host_key="tests/host_key",
debug=NC_DEBUG)
def setup_netconf():
"Configure Netconf server listener"
global netconf_server # pylint: disable=C0103
if netconf_server is not None:
logger.error("Netconf Server is already up and running")
else:
server_ctl = server.SSHUserPassController(username=USER,
password=PASSWORD)
netconf_server = server.NetconfSSHServer(
server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=NC_PORT,
host_key="keys/host_key",
debug=SERVER_DEBUG)
def start(self):
self.server = server.NetconfSSHServer(self.auth,
port=self.port,
server_methods=self.plugin,
host_key=os.path.join(
MYDIR, 'id_rsa'),
debug=True,
queue=self.queue)
register_event('summary', NETCONF_EVENTS, self.summary)
register_event('update', NETCONF_EVENTS, self.update)
register_event('register', NETCONF_EVENTS, self.register)
register_event('dic', NETCONF_EVENTS, self.dic_callback)
register_listener(self.socket, NETCONF_EVENTS)
try:
while True:
time.sleep(1)
except:
pass
self.close()
def __init__(self,
device,
host_key,
ssh_port=830,
username=None,
password=None,
debug=False):
#-----------------
# Open the device
#-----------------
self.debug = debug
host_key_path = os.path.expanduser(host_key)
assert os.path.exists(host_key_path)
idn = device.get_idn_data()
# XXX Is this where we get the port count?
assert idn[4] == "cal04" or idn[4] == "cal02"
if idn[4] == "cal04":
self.nports = 4
self.is_tfm = False
else:
self.nports = 1
self.is_tfm = True
self.device = device
self.device_lock = threading.Lock()
#-----------------------
# Start the server.
#-----------------------
self.controller = server.SSHUserPassController(username=username,
password=password)
self.server = server.NetconfSSHServer(server_ctl=self.controller,
port=ssh_port,
host_key=host_key_path,
server_methods=self,
debug=debug)
logger.info("Listening on port %d", self.server.port)
def __init__(self, port, host_key, auth, debug):
self.server = server.NetconfSSHServer(auth, self, port, host_key,
debug)
self.ns_of_filter = []
def __init__(self, config_file=''):
"""
:param config_file: server config file path
"""
# Set up logger
global logger
logger = logging.getLogger('publisher')
logger.setLevel(logging.DEBUG)
# create file handler which logs all messages
fh = logging.FileHandler('publisher_debug.log')
fh.setLevel(logging.DEBUG)
ch_level = logging.DEBUG if cfg.debug else logging.INFO
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(ch_level)
formatter = logging.Formatter(
'%(asctime)s %(name)s %(threadName)s %(levelname)s: %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)
logger.addHandler(fh)
logger.addHandler(ch)
self.subscriptions = {}
self.last_subscription_id = 0
self.port = cfg.port
self.debug = cfg.debug
self._storage_file_lock = Lock()
self.datasource = None
try:
self.datasource = MongoDataSource(cfg.mongo_host, cfg.mongo_port,
cfg.mongo_db,
cfg.mongo_collection)
except Exception as e:
logger.error(f"MongoDB error: {e}")
raise e
if not os.path.isabs(cfg.ssh_host_key_path):
cfg.ssh_host_key_path = os.path.join(os.path.dirname(config_file),
cfg.ssh_host_key_path)
# Authentication
#
# There are two available authentication methods:
# 1. User and password (used now), allowing only one user (no way to establish access rules)
# 2. SSH authorized keys. A list of the allowed clients public keys
auth_controller = server.SSHUserPassController(username=cfg.username,
password=cfg.password)
server.NetconfSSHServer(server_ctl=auth_controller,
server_methods=self,
port=cfg.port,
host_key=cfg.ssh_host_key_path,
debug=cfg.debug)
logger.info(f"Server started on port {self.port}")
def test_multi_open():
global nc_server
print "Create Server "
logger.info("Create Server")
server_ctl = server.SSHUserPassController(username=getpass.getuser(),
password="******")
nc_server = server.NetconfSSHServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=NC_PORT,
host_key="host_key",
debug=SERVER_DEBUG)
port = nc_server.port
print "the port is ", port, nc_server.port
logger.info("Open sessions")
sessions = [
client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
for unused in range(0, 25)
]
logger.info("Close sessions")
for session in sessions:
session.close()
test_get()
test_get_config()
#####HS CLOSE TEST##########
logger.info("Reopening")
sessions = [
client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
for unused in range(0, 25)
]
logger.info("Closeing")
for session in sessions:
session.close()
logger.info("Reopening")
sessions = [
client.NetconfSSHSession("127.0.0.1",
password="******",
port=port,
debug=CLIENT_DEBUG)
for unused in range(0, 25)
]
logger.info("Reclosing")
for session in sessions:
session.close()
# Close down the server and join it to make sure it's closed
logger.info("Closing server")
nc_server.close()
logger.info("Joining server")
nc_server.join()
# Delete the server so that we don't end up with a bunch of logging going on on exit.
del nc_server
del server_ctl
def __init__(self, user, pw):
controller = server.SSHUserPassController(username=user, password=pw)
self.server = server.NetconfSSHServer(server_ctl=controller,
server_methods=self)
