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 main(*margs):
parser = argparse.ArgumentParser("Example System Server")
parser.add_argument("--debug",
action="store_true",
help="Enable debug logging")
parser.add_argument("--password",
default="admin",
help='Use "env:" or "file:" prefix to specify source')
parser.add_argument('--port',
type=int,
default=8300,
help='Netconf server port')
parser.add_argument("--username", default="admin", help='Netconf username')
args = parser.parse_args(*margs)
#logging.basicConfig(level=logging.DEBUG if args.debug else logging.INFO)
logging.basicConfig(level=logging.DEBUG if args.debug else logging.WARNING)
args.password = parse_password_arg(args.password)
host_key = os.path.dirname(__file__) + "/server-key"
auth = server.SSHUserPassController(username=args.username,
password=args.password)
s = SystemServer(args.port, host_key, auth, args.debug)
if sys.stdout.isatty():
print("^C to quit server")
try:
while True:
time.sleep(1)
except Exception:
print("quitting server")
s.close()
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 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 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 startMyServer():
# logging: https://cloud.tencent.com/developer/article/1354396
debug = True
level = logging.DEBUG if debug else logging.INFO
logging.basicConfig(
level=level,
filename='server.log',
filemode='w',
format='%(asctime)s %(levelname)s:%(name)s(L%(lineno)d): %(message)s')
host_key = os.path.join(os.path.dirname(__file__), "server-key")
auth = server.SSHUserPassController(username='******', password='******')
s = SystemServer(830, host_key, auth, debug)
if s.server:
print('Server started.')
serverIsRunning = True
while True:
# time.sleep(5)
#print(s.server.sockets, len(s.server.sockets)) #当前已经建链的socket
if s.server.thread.isAlive():
if not serverIsRunning:
print('Server is running.')
serverIsRunning = True
else:
print('Server stopped. Restarting...')
# s.close()
serverIsRunning = False
s = SystemServer(830, host_key, auth, debug)
cli = prompt(
'>',
history=FileHistory('history.txt'),
auto_suggest=AutoSuggestFromHistory(),
completer=nc_completer,
)
if cli == 'exit':
return
elif cli in nc_completer.words:
# locals()['s.' + cli]()
getattr(s, cli)()
else:
print('Not supported!')
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 rpc_system_shutdown(self, session, rpc, *params):
raise error.AccessDeniedAppError(rpc)
if __name__ == "__main__":
conf = {
'host_key': '/home/heweiwei/.ssh/id_rsa',
'port': 8300,
'username': '******',
'password': '******',
'debug': True
}
print(conf)
auth = server.SSHUserPassController(username=conf['username'],
password=conf['password'])
s = SystemServer(conf['port'], conf['host_key'], auth, conf['debug'])
loop = asyncio.get_event_loop()
q = queue.Queue()
#loop.run_forever()
while True:
try:
q.put('hello heweiwei')
q.put('hello maonini')
while q.empty() == False:
loop.run_until_complete(run(loop, q.get()))
time.sleep(5)
except Exception as e:
time.sleep(5)
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)
def __init__(self,
username=None,
password=None,
port=830,
system_status=None,
host_key=None):
'''
Constructor
'''
self.nc_server = None
self.que_events = Queue.Queue(10)
self.stop_event = threading.Event()
self.started = True
self.__rpc_error_message = """
<rpc-error>
<error-type>application</error-type>
<error-tag>operation-failed</error-tag>
<error-severity>error</error-severity>
<error-message xml:lang="en">dummy</error-message>
<error-info>
<operator-mediation>false</operator-mediation>
</error-info>
</rpc-error>
"""
self._response_plugin = None
if system_status is None:
GlobalModule.EMSYSCOMUTILDB.write_system_status(
"UPDATE", EmSysCommonUtilityDB.STATE_STOP,
EmSysCommonUtilityDB.GET_DATA_TYPE_BOTH)
GlobalModule.EM_LOGGER.info(
"102009 EM Status Transition[%s -> %s]", "UNKNOWN", "STOP")
raise IOError("system_status is not set")
self.stop_state = GlobalModule.COM_STOP_NORMAL
(ret, lo_status) = GlobalModule.EMSYSCOMUTILDB.read_system_status(
EmSysCommonUtilityDB.GET_DATA_TYPE_MEMORY)
if lo_status != EmSysCommonUtilityDB.STATE_STOP:
raise RuntimeError("Detect start request other than stop status")
if system_status != EmSysCommonUtilityDB.STATE_CHANGE_OVER:
GlobalModule.EMSYSCOMUTILDB.write_system_status(
"UPDATE", EmSysCommonUtilityDB.STATE_READY_TO_START,
EmSysCommonUtilityDB.GET_DATA_TYPE_BOTH)
GlobalModule.EM_LOGGER.info(
"102009 EM Status Transition[%s -> %s]", "STOP",
"READY_TO_START")
else:
GlobalModule.EMSYSCOMUTILDB.write_system_status(
"UPDATE", EmSysCommonUtilityDB.STATE_CHANGE_OVER,
EmSysCommonUtilityDB.GET_DATA_TYPE_MEMORY)
GlobalModule.EM_LOGGER.info(
"102009 EM Status Transition[%s -> %s]", "STOP", "CHG_OVER")
try:
if username is None:
raise IOError("username is not set")
if password is None:
raise IOError("password is not set")
result, conf_log_level = (
GlobalModule.EM_CONFIG.read_sys_common_conf("Em_log_level"))
if not result:
raise IOError("failed to get config Em_log_level")
debug_flg = bool(conf_log_level == "DEBUG")
self._response_plugin = self._load_response_plugin()
except Exception as ex:
GlobalModule.EM_LOGGER.debug(ex.message)
GlobalModule.EM_LOGGER.debug("traceback:%s",
traceback.format_exc())
GlobalModule.EMSYSCOMUTILDB.write_system_status(
"UPDATE", EmSysCommonUtilityDB.STATE_STOP,
EmSysCommonUtilityDB.GET_DATA_TYPE_BOTH)
GlobalModule.EM_LOGGER.info(
"102009 EM Status Transition[%s -> %s]", "READY_TO_START",
"STOP")
raise
server_ctl = server.SSHUserPassController(username=username,
password=password)
try:
self.nc_server = EmNetconfServer(server_ctl=server_ctl,
server_methods=NetconfMethods(),
port=port,
host_key=host_key,
debug=debug_flg)
except Exception as exception:
GlobalModule.EM_LOGGER.debug("Connect Error:%s",
str(type(exception)))
GlobalModule.EMSYSCOMUTILDB.write_system_status(
"UPDATE", EmSysCommonUtilityDB.STATE_STOP,
EmSysCommonUtilityDB.GET_DATA_TYPE_BOTH)
GlobalModule.EM_LOGGER.info(
"102009 EM Status Transition[%s -> %s]", "READY_TO_START",
"STOP")
raise
self.stop_mon_thread = threading.Thread(target=self._stop_monitoring)
self.stop_mon_thread.daemon = True
self.stop_mon_thread.start()
self.wait_order_thread = threading.Thread(target=self._wait_order_resp)
self.wait_order_thread.daemon = True
self.wait_order_thread.start()
