def _mock_manager(self, *args, **kwargs):
if kwargs:
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == 'command':
if args[0].text == 'show cli directory':
return self._read_file('show-cli-directory.xml')
if args[0].text == 'show interface terse':
return self._read_file('show-interface-terse.json')
elif args[0].text == 'show configuration':
return self._read_file('show-configuration.xml')
elif args[0].text == 'show system alarms':
return self._read_file('show-system-alarms.xml')
elif args[0].text == 'show system uptime | display xml rpc':
return self._read_file('show-system-uptime-rpc.xml')
elif args[0].text == 'show configuration interfaces':
return self._read_file('show-configuration-interfaces.xml')
elif args[0].text == 'show interfaces terse asdf':
return self._read_file('show-interfaces-terse-asdf.xml')
else:
raise RpcError
else:
if args[0].attrib.get('format')=='json':
return self._read_file(args[0].tag + '.json')
return self._read_file(args[0].tag + '.xml')
def _mock_manager(self, *args, **kwargs):
if kwargs:
# if 'path' in kwargs and 'detail' in kwargs:
# return self._read_file('dir_list_detail.xml')
if 'path' in kwargs:
if kwargs['path'] == 'test/stat/decode_dir':
return self._read_file('file-list_dir.xml')
elif kwargs['path'] == 'test/stat/decode_file':
return self._read_file('file-list_file.xml')
elif kwargs['path'] == 'test/checksum':
return self._read_file('checksum.xml')
elif kwargs['path'] == 'test/stat/decode_symbolic_link':
return self._read_file('file-list_symlink.xml')
if 'directory' in kwargs:
if kwargs['directory'] == 'change/directory':
return self._read_file('set-cli-working-directory.xml')
if 'filename' in kwargs:
if kwargs['filename'] == 'test/cat.txt':
return self._read_file('file-show.xml')
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == 'command':
if args[0].text == 'show cli directory':
return self._read_file('show-cli-directory.xml')
elif args[0].tag == 'get-system-storage':
return self._read_file('get-system-storage.xml')
elif args[0].tag == 'request-system-storage-cleanup':
return self._read_file('request-system-storage-cleanup.xml')
elif args[0].tag == 'file-archive':
return self._read_file('file-archive.xml')
def _test_data(self, path):
with open(path, 'r') as f:
reply = f.read()
return NCElement(
reply,
manager.make_device_handler({'name': 'junos'}).transform_reply()
)
def test_execute_rpc(self, mock_request, mock_session):
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = ExecuteRpc(session, device_handler, raise_mode=RaiseMode.ALL)
rpc = new_ele('get-software-information')
obj.request(rpc)
mock_request.assert_called_once_with(rpc)
def test_execute_rpc_str(self, mock_request, mock_session):
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = ExecuteRpc(session, device_handler, raise_mode=RaiseMode.ALL)
rpc = '<get-software-information/>'
obj.request(rpc)
self.assertEqual(True, isinstance(rpc, str))
def mock_manager(*args, **kwargs):
if 'device_params' in kwargs:
# open connection
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
# rpc request
rpc_request = args[0].tag
rpc_command = str(args[0].text)
rpc_command = rpc_command.strip()
rpc_command = rpc_command.replace(" ", "_")
if rpc_request in rpc_reply_dict:
xml = rpc_reply_dict[rpc_request]
elif 'dir' in rpc_reply_dict:
fname = os.path.join(rpc_reply_dict['dir'], 'rpc-reply', rpc_command, rpc_request + '.xml')
with open(fname, 'r') as f:
xml = f.read()
else:
_rpc_reply_dict['dir']
fname = os.path.join(os.path.dirname(__file__), 'rpc-reply', rpc_command, rpc_request + '.xml')
with open(fname, 'r') as f:
xml = f.read()
rpc_reply = NCElement(xml, dev._conn._device_handler.transform_reply())
return rpc_reply
def test_ncelement_find(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
self.assertEqual(result.find(".//name").tag, "name")
self.assertEqual(result.find(".//name").text, "junos")
def test_rpc_send(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
reply = RPCReply(xml1)
obj._reply = reply
node = new_ele("commit")
sub_ele(node, "confirmed")
sub_ele(node, "confirm-timeout").text = "50"
sub_ele(node, "log").text = "message"
result = obj._request(node)
ele = new_ele("rpc",
{"message-id": obj._id},
**device_handler.get_xml_extra_prefix_kwargs())
ele.append(node)
node = to_xml(ele)
mock_send.assert_called_once_with(node)
self.assertEqual(
result.data_xml,
(NCElement(
reply,
device_handler.transform_reply())).data_xml)
self.assertEqual(obj.session, session)
self.assertEqual(reply, obj.reply)
def mock_manager(*args, **kwargs):
if 'device_params' in kwargs:
# open connection
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
# rpc request
rpc_request = args[0].tag
if rpc_request == "command":
# CLI commands
rpc_request = "%s_%s" % (rpc_request, args[0].text.replace(" ", "_"))
if rpc_request in rpc_reply_dict:
# result for rpc request is in dict
reply = rpc_reply_dict[rpc_request]
if isinstance(reply, Exception):
raise reply
else:
xml = reply
else:
# get rpc result from file
fname = os.path.join(os.getcwd(), 'tests', 'rpc-reply', rpc_request + '.xml')
with open(fname, 'r') as f:
xml = f.read()
rpc_reply = NCElement(xml, dev._conn._device_handler.transform_reply())
return rpc_reply
def test_halt(self, mock_request, mock_session):
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = Halt(session, device_handler, raise_mode=RaiseMode.ALL)
obj.request()
node = new_ele('request-halt')
call = mock_request.call_args_list[0][0][0]
self.assertEqual(call.tag, node.tag)
def test_validated_element_fail_3(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
XMLError.message = "Element does not meet requirement"
result_xml = result.data_xml
self.assertRaises(XMLError, validated_element, result_xml, tags=["rpc"])
def test_ncelement_reply_001(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
self.assertEqual(result.xpath("//name")[0].text, "junos")
self.assertEqual(result.xpath("//name")[0].tag, "name")
self.assertEqual(result.xpath("//package-information")[0].tag, "package-information")
def test_parse_root(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
tag, attrib = parse_root(result.data_xml)
self.assertEqual(tag, "rpc-reply")
self.assertEqual(attrib, {"attrib1": "test"})
def cscript_conf(reply):
try:
device_params = {'name': 'junos'}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
return NCElement(reply, transform_reply)._NCElement__doc
except:
return None
def cscript_conf(reply):
try:
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
return NCElement(etree.tostring(reply), transform_reply)._NCElement__doc
except:
return None
def test_commit_confirmed_at_time(
self, mock_assert, mock_request, mock_session):
# mock_session.server_capabilities.return_value = [':candidate']
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = Commit(session, device_handler, raise_mode=RaiseMode.ALL)
self.assertRaises(NCClientError,
obj.request, at_time="1111-11-11 00:00:00", synchronize=True,
confirmed=True)
def test_rpc_capability_error(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
session._server_capabilities = [':running']
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
obj._assert(':running')
self.assertRaises(MissingCapabilityError,
obj._assert, ':candidate')
def _mock_manager(self, *args, **kwargs):
if kwargs:
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
if args:
return self._read_file(args[0].tag + '.xml')
def test_validated_element_fail_2(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
XMLError.message = "Element does not meet requirement"
result_xml = result.data_xml
with self.assertRaises(XMLError):
validated_element(result_xml, tags=["rpc-reply", "rpc"], attrs=[["attrib1"], ["attrib2"]])
def test_to_ele(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
ele = to_ele((result.find(".//name")))
self.assertEqual(ele.tag, "name")
self.assertEqual(ele.text, "junos")
ele = to_ele(self.reply)
self.assertEqual(ele.tag, "rpc-reply")
def test_rpc_timeout_error(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
reply = RPCReply(xml1)
obj.deliver_reply(reply)
node = new_ele("commit")
sub_ele(node, "confirmed")
mock_thread.return_value = False
self.assertRaises(TimeoutExpiredError, obj._request, node)
def test_commit(self, mock_assert, mock_request, mock_session):
# mock_session.server_capabilities.return_value = [':candidate']
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = Commit(session, device_handler, raise_mode=RaiseMode.ALL)
obj.request()
node = new_ele_ns("commit-configuration", "")
xml = ElementTree.tostring(node)
call = mock_request.call_args_list[0][0][0]
call = ElementTree.tostring(call)
self.assertEqual(call, xml)
def test_validated_element_pass(self):
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
result_xml = result.data_xml
ele = validated_element(result_xml, tags=["rpc-reply", "rpc"], attrs=[["attrib1", "attrib2"]])
self.assertEqual(ele.tag, "rpc-reply")
ele = validated_element(result_xml, attrs=[["attrib1", "attrib2"]])
self.assertEqual(ele.tag, "rpc-reply")
ele = validated_element(result_xml)
self.assertEqual(ele.tag, "rpc-reply")
def test_ncelement_reply_001(self):
"""test parse rpc_reply and string/data_xml"""
#read in reply1 contents
with open('test/reply1', 'r') as f:
reply = f.read()
device_params = {'name':'junos'}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(reply, transform_reply)
assert_equal(str(result), result.tostring)
#data_xml != tostring
assert_not_equal(result.tostring, result.data_xml)
def test_ncelement_reply_003(self):
"""test parse rpc_reply and find"""
# read in reply1 contents
with open(file_path, "r") as f:
reply = f.read()
device_params = {"name": "junos"}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(reply, transform_reply)
# find
assert_equal(result.findtext(".//host-name"), "R1")
assert_equal(result.find(".//host-name").tag, "host-name")
def _mock_manager(self, *args, **kwargs):
if kwargs:
if 'path' in kwargs:
if kwargs['path'] == '/packages':
return self._read_file('file-list_dir.xml')
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
return self._read_file(args[0].tag + '.xml')
def test_validated_element_fail_3(self):
device_params = {'name': 'junos'}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
XMLError.message = "Element does not meet requirement"
if sys.version >= '3':
result_xml = bytes(result.data_xml, "utf-8")
else:
result_xml = result.data_xml
with self.assertRaises(XMLError):
validated_element(result_xml, tags=["rpc"])
def test_command(self, mock_request, mock_session):
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = Command(session, device_handler, raise_mode=RaiseMode.ALL)
command = 'show system users'
format = 'text'
obj.request(command=command, format=format)
node = new_ele('command', {'format': format})
node.text = command
call = mock_request.call_args_list[0][0][0]
self.assertEqual(call.tag, node.tag)
self.assertEqual(call.text, node.text)
def _mock_manager(self, *args, **kwargs):
if kwargs:
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
if args:
if args[0].xpath('//configuration/system/login/user'):
return self._read_file('get-configuration-user.xml')
else:
return self._read_file(args[0].tag + '.xml')
def test_ncelement_remove_namespace(self):
device_params = {'name': 'junos'}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
re = result.remove_namespaces(self.reply)
self.assertEqual(re.tag, "rpc-reply")
ele = to_ele((result.find(".//name")))
self.assertEqual(ele.tag, "name")
self.assertEqual(ele.text, "junos")
ele = to_ele(self.reply)
self.assertEqual(ele.tag, "rpc-reply")
def test_ncelement_reply_002(self):
"""test parse rpc_reply and xpath"""
# read in reply1 contents
with open(file_path, 'r') as f:
reply = f.read()
device_params = {'name': 'junos'}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(reply, transform_reply)
# XPATH checks work
self.assertEqual(result.xpath("//host-name")[0].text, "R1")
self.assertEqual(
result.xpath("/rpc-reply/software-information/host-name")[0].text,
"R1")
self.assertEqual(
result.xpath("software-information/host-name")[0].text,
"R1")
def test_loadconf_json(self, mock_request, mock_session):
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = LoadConfiguration(session,
device_handler,
raise_mode=RaiseMode.ALL)
location = '{ "configuration": { "system": { "location": { "floor": "7" }}}}'
config_json = json.loads(location)
config = json.dumps(config_json)
obj.request(format='json', action='merge', config=config)
node = new_ele('load-configuration', {
'format': 'json',
'action': 'merge'
})
sub_ele(node, 'configuration-json').text = config
call = mock_request.call_args_list[0][0][0]
self.assertEqual(call.tag, node.tag)
self.assertEqual(call.attrib, node.attrib)
def _mock_manager(self, *args, **kwargs):
if kwargs:
# Little hack for mocked execute
if 'dev_timeout' in kwargs:
return self._read_file(args[0].tag + '.xml')
if 'path' in kwargs:
if kwargs['path'] == '/packages':
return self._read_file('file-list_dir.xml')
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].find('at') is not None:
return self._read_file('request-reboot-at.xml')
else:
return self._read_file(args[0].tag + '.xml')
def _mock_manager(self, *args, **kwargs):
if kwargs:
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
if args:
if self.vc is True and args[0].tag == 'get-virtual-chassis-information':
if self.vct is True:
return True
elif self.vcf is True:
return self._read_file(
'get-virtual-chassis-information_mmvcf.xml')
else:
return self._read_file(
'get-virtual-chassis-information.xml')
return self._read_file(args[0].tag + '_' + self.mode + '.xml')
def test_rpc_enable_nc_prefix_exception(self):
# invalid value in "with_ns"
self.device_handler = manager.make_device_handler({
'name':
'ericsson',
'with_ns':
"Invalid_value"
})
session = ncclient.transport.SSHSession(self.device_handler)
obj = RPC(session,
self.device_handler,
raise_mode=RaiseMode.ALL,
timeout=0)
node = new_ele("get-config")
child = sub_ele(node, "source")
sub_ele(child, "running")
self.assertRaises(OperationError, obj._wrap, node)
def test_loadconf_xml(self, mock_request, mock_session):
device_handler = manager.make_device_handler({'name': 'junos'})
session = ncclient.transport.SSHSession(device_handler)
obj = LoadConfiguration(session,
device_handler,
raise_mode=RaiseMode.ALL)
root_config = new_ele('configuration')
system_config = sub_ele(root_config, 'system')
location_config = sub_ele(system_config, 'location')
floor_config = sub_ele(location_config, 'floor').text = "7"
obj.request(format='xml', config=root_config)
node = new_ele('load-configuration', {
'format': 'xml',
'action': 'merge'
})
node.append(root_config)
call = mock_request.call_args_list[0][0][0]
self.assertEqual(call.tag, node.tag)
self.assertEqual(call.attrib, node.attrib)
def _mock_manager(self, *args, **kwargs):
if kwargs and "ignore_warning" not in kwargs:
# Little hack for mocked execute
if "dev_timeout" in kwargs:
if (args and args[0].findtext("package-name")
== "/var/tmp/test_no_result.tgz"):
return self._read_file(args[0].tag + ".no_result.xml")
else:
return self._read_file(args[0].tag + ".xml")
if "path" in kwargs:
if kwargs["path"] == "/packages":
return self._read_file("file-list_dir.xml")
if args and self._testMethodName == "test_sw_zeroize":
return self._read_file("request-zeroize.xml")
device_params = kwargs["device_params"]
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if self._testMethodName == "test_sw_reboot_output_in_reply":
return self._read_file("request-reboot-output.xml")
elif args[0].find("at") is not None:
return self._read_file("request-reboot-at.xml")
elif self._testMethodName == "test_sw_check_pending_install":
if args[0].text == "request-package-check-pending-install":
return self._read_file(
"request-package-check-pending-install-error.xml")
elif (self._testMethodName ==
"test_sw_check_pending_install_RpcError_continue"):
if args[0].text == "request-package-check-pending-install":
xml = """<rpc-error>
<error-type>protocol</error-type>
<error-tag>operation-failed</error-tag>
<error-severity>error</error-severity>
<error-message>syntax error</error-message>
<error-info>
<bad-element>request-package-check-pendings-install</bad-element>
</error-info>
</rpc-error>"""
return RpcError(rsp=etree.fromstring(xml))
else:
return self._read_file(args[0].tag + ".xml")
def mock_manager(*args, **kwargs):
if 'device_params' in kwargs:
# open connection
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
# rpc request
rpc_request = args[0].tag
if rpc_request in rpc_reply_dict:
xml = rpc_reply_dict[rpc_request]
else:
fname = os.path.join(os.path.dirname(__file__), 'rpc-reply', rpc_request + '.xml')
with open(fname, 'r') as f:
xml = f.read()
rpc_reply = NCElement(xml, dev._conn._device_handler.transform_reply())
return rpc_reply
def test_rpc_enable_nc_prefix(self):
# It is a switch for user to turn on/off "nc" prefix
self.device_handler = manager.make_device_handler({
'name': 'ericsson',
'with_ns': True
})
session = ncclient.transport.SSHSession(self.device_handler)
obj = RPC(session,
self.device_handler,
raise_mode=RaiseMode.ALL,
timeout=0)
expected = """<?xml version="1.0" encoding="UTF-8"?><nc:rpc xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="%s"><nc:get-config><nc:source><nc:running/></nc:source></nc:get-config></nc:rpc>""" % obj.id
node = new_ele("get-config")
child = sub_ele(node, "source")
sub_ele(child, "running")
rpc_node = obj._wrap(node)
self.assertEqual(rpc_node, expected)
def _mock_manager(self, *args, **kwargs):
if kwargs and 'ignore_warning' not in kwargs:
# Little hack for mocked execute
if 'dev_timeout' in kwargs:
if (args and args[0].findtext('package-name')
== '/var/tmp/test_no_result.tgz'):
return self._read_file(args[0].tag + '.no_result.xml')
else:
return self._read_file(args[0].tag + '.xml')
if 'path' in kwargs:
if kwargs['path'] == '/packages':
return self._read_file('file-list_dir.xml')
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].find('at') is not None:
return self._read_file('request-reboot-at.xml')
else:
return self._read_file(args[0].tag + '.xml')
def test_rpc_send(self, mock_thread, mock_send):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
obj = RPC(session, device_handler, raise_mode=RaiseMode.ALL, timeout=0)
reply = RPCReply(xml1)
obj._reply = reply
node = new_ele("commit")
sub_ele(node, "confirmed")
sub_ele(node, "confirm-timeout").text = "50"
sub_ele(node, "log").text = "message"
result = obj._request(node)
ele = new_ele("rpc", {"message-id": obj._id},
**device_handler.get_xml_extra_prefix_kwargs())
ele.append(node)
node = to_xml(ele)
mock_send.assert_called_once_with(node)
self.assertEqual(result.data_xml, (NCElement(
reply, device_handler.transform_reply())).data_xml)
self.assertEqual(obj.session, session)
self.assertEqual(reply, obj.reply)
def _mock_manager(self, *args, **kwargs):
if kwargs:
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == 'command':
if args[0].text == 'show cli directory':
return self._read_file('show-cli-directory.xml')
elif args[0].text == 'show configuration':
return self._read_file('show-configuration.xml')
elif args[0].text == 'show system alarms':
return self._read_file('show-system-alarms.xml')
elif args[0].text == 'show system uptime | display xml rpc':
return self._read_file('show-system-uptime-rpc.xml')
else:
raise RpcError
else:
return self._read_file(args[0].tag + '.xml')
def _mock_manager(self, *args, **kwargs):
if kwargs and 'normalize' not in kwargs:
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == 'command':
if args[0].text == 'show cli directory':
return self._read_file('show-cli-directory.xml')
if args[0].text == 'show interface terse':
return self._read_file('show-interface-terse.json')
elif args[0].text == 'show configuration':
return self._read_file('show-configuration.xml')
elif args[0].text == 'show system alarms':
return self._read_file('show-system-alarms.xml')
elif args[0].text == 'show system uptime| display xml rpc':
return self._read_file('show-system-uptime-rpc.xml')
elif args[0].text == 'show configuration interfaces':
return self._read_file('show-configuration-interfaces.xml')
elif args[0].text == 'show interfaces terse asdf':
return self._read_file('show-interfaces-terse-asdf.xml')
elif args[0].text == 'show interfaces ge-0/0/0.0 ' \
'routing-instance all media':
return self._read_file(
'show-interfaces-routing-instance-media.xml')
elif args[0].text == 'show interfaces ge-0/0/0.0 ' \
'routing-instance all media| display ' \
'xml rpc':
return self._read_file(
'show-interfaces-routing-instance-media-rpc.xml')
else:
raise RpcError
else:
if args[0].attrib.get('format') == 'json':
return self._read_file(args[0].tag + '.json')
return self._read_file(args[0].tag + '.xml')
def _mock_manager(self, *args, **kwargs):
if kwargs and "normalize" not in kwargs:
device_params = kwargs["device_params"]
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == "command":
if args[0].text == "show cli directory":
return self._read_file("show-cli-directory.xml")
if args[0].text == "show interface terse":
return self._read_file("show-interface-terse.json")
elif args[0].text == "show configuration":
return self._read_file("show-configuration.xml")
elif args[0].text == "show system alarms":
return self._read_file("show-system-alarms.xml")
elif args[0].text == "show system uptime| display xml rpc":
return self._read_file("show-system-uptime-rpc.xml")
elif args[0].text == "show configuration interfaces":
return self._read_file("show-configuration-interfaces.xml")
elif args[0].text == "show interfaces terse asdf":
return self._read_file("show-interfaces-terse-asdf.xml")
elif (args[0].text == "show interfaces ge-0/0/0.0 "
"routing-instance all media"):
return self._read_file(
"show-interfaces-routing-instance-media.xml")
elif (args[0].text == "show interfaces ge-0/0/0.0 "
"routing-instance all media| display "
"xml rpc"):
return self._read_file(
"show-interfaces-routing-instance-media-rpc.xml")
else:
raise RpcError
else:
if args[0].attrib.get("format") == "json":
return self._read_file(args[0].tag + ".json")
return self._read_file(args[0].tag + ".xml")
def _mock_manager(self, *args, **kwargs):
if kwargs:
# if 'path' in kwargs and 'detail' in kwargs:
# return self._read_file('dir_list_detail.xml')
if "path" in kwargs:
if kwargs["path"] == "test/stat/decode_dir":
return self._read_file("file-list_dir.xml")
elif kwargs["path"] == "test/stat/decode_file":
return self._read_file("file-list_file.xml")
elif kwargs["path"] == "test/checksum":
return self._read_file("checksum.xml")
elif kwargs["path"] == "test/stat/decode_symbolic_link":
return self._read_file("file-list_symlink.xml")
if "directory" in kwargs:
if kwargs["directory"] == "change/directory":
return self._read_file("set-cli-working-directory.xml")
if "filename" in kwargs:
if kwargs["filename"] == "test/cat.txt":
return self._read_file("file-show.xml")
device_params = kwargs["device_params"]
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == "command":
if args[0].text == "show cli directory":
return self._read_file("show-cli-directory.xml")
elif args[0].tag == "get-system-storage":
return self._read_file("get-system-storage.xml")
elif args[0].tag == "get-directory-usage-information":
return self._read_file("get-directory-usage-information.xml")
elif args[0].tag == "request-system-storage-cleanup":
return self._read_file("request-system-storage-cleanup.xml")
elif args[0].tag == "file-archive":
return self._read_file("file-archive.xml")
def _mock_manager(self, *args, **kwargs):
if kwargs:
# if 'path' in kwargs and 'detail' in kwargs:
# return self._read_file('dir_list_detail.xml')
if 'path' in kwargs:
if kwargs['path'] == 'test/stat/decode_dir':
return self._read_file('file-list_dir.xml')
elif kwargs['path'] == 'test/stat/decode_file':
return self._read_file('file-list_file.xml')
elif kwargs['path'] == 'test/checksum':
return self._read_file('checksum.xml')
elif kwargs['path'] == 'test/stat/decode_symbolic_link':
return self._read_file('file-list_symlink.xml')
if 'directory' in kwargs:
if kwargs['directory'] == 'change/directory':
return self._read_file('set-cli-working-directory.xml')
if 'filename' in kwargs:
if kwargs['filename'] == 'test/cat.txt':
return self._read_file('file-show.xml')
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].tag == 'command':
if args[0].text == 'show cli directory':
return self._read_file('show-cli-directory.xml')
elif args[0].tag == 'get-system-storage':
return self._read_file('get-system-storage.xml')
elif args[0].tag == 'get-directory-usage-information':
return self._read_file('get-directory-usage-information.xml')
elif args[0].tag == 'request-system-storage-cleanup':
return self._read_file('request-system-storage-cleanup.xml')
elif args[0].tag == 'file-archive':
return self._read_file('file-archive.xml')
def _mock_manager(self, *args, **kwargs):
if kwargs and 'ignore_warning' not in kwargs:
# Little hack for mocked execute
if 'dev_timeout' in kwargs:
if (args and args[0].findtext('package-name')
== '/var/tmp/test_no_result.tgz'):
return self._read_file(args[0].tag + '.no_result.xml')
else:
return self._read_file(args[0].tag + '.xml')
if 'path' in kwargs:
if kwargs['path'] == '/packages':
return self._read_file('file-list_dir.xml')
device_params = kwargs['device_params']
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
elif args:
if args[0].find('at') is not None:
return self._read_file('request-reboot-at.xml')
elif self._testMethodName == 'test_sw_check_pending_install':
if args[0].text == 'request-package-check-pending-install':
return self._read_file(
'request-package-check-pending-install-error.xml')
elif self._testMethodName == 'test_sw_check_pending_install_RpcError_continue':
if args[0].text == 'request-package-check-pending-install':
xml = '''<rpc-error>
<error-type>protocol</error-type>
<error-tag>operation-failed</error-tag>
<error-severity>error</error-severity>
<error-message>syntax error</error-message>
<error-info>
<bad-element>request-package-check-pendings-install</bad-element>
</error-info>
</rpc-error>'''
return RpcError(rsp=etree.fromstring(xml))
else:
return self._read_file(args[0].tag + '.xml')
def connect_ssh(*args, **kwds):
"""
Initialize a :class:`Manager` over the SSH transport.
For documentation of arguments see :meth:
`ncclient.transport.SSHSession.connect`.
The underlying :class:`ncclient.transport.SSHSession` is created with
:data:`CAPABILITIES`. It is first instructed to
:meth:`~ncclient.transport.SSHSession.load_known_hosts` and then
all the provided arguments are passed directly to its implement
ation of :meth:`~ncclient.transport.SSHSession.connect`.
To invoke advanced vendor related operation add device_params =
{'name':'<vendor_alias>'} in connection paramerers. For the time,
'junos' and 'nexus' are supported for Juniper and Cisco Nexus
respectively.
"""
if "device_params" in kwds:
device_params = kwds["device_params"]
del kwds["device_params"]
else:
device_params = None
device_handler = manager.make_device_handler(device_params)
device_handler.add_additional_ssh_connect_params(kwds)
session = EmMonitorSSHSession(device_handler)
if "hostkey_verify" not in kwds or kwds["hostkey_verify"]:
session.load_known_hosts()
try:
session.connect(*args, **kwds)
except Exception as ex:
if session.transport:
session.close()
print ex
raise
return EmMonitorManager(session, device_handler, **kwds)
def _mock_manager_setup(self, *args, **kwargs):
if kwargs:
device_params = kwargs["device_params"]
device_handler = make_device_handler(device_params)
session = SSHSession(device_handler)
return Manager(session, device_handler)
def test_make_device_handler(self):
device_handler = manager.make_device_handler({'name': 'junos'})
self.assertEqual(
device_handler.__class__.__name__,
"JunosDeviceHandler")
def test_ncelement_findtext(self):
device_params = {'name': 'junos'}
device_handler = manager.make_device_handler(device_params)
transform_reply = device_handler.transform_reply()
result = NCElement(self.reply, transform_reply)
self.assertEqual(result.findtext(".//name"), "junos")
def _mock_device_handler_and_session(self):
device_handler = manager.make_device_handler({'name': 'junos'})
capabilities = Capabilities(device_handler.get_capabilities())
session = ncclient.transport.Session(capabilities)
return device_handler, session
def test_make_device_handler_provided_handler(self):
device_handler = manager.make_device_handler(
{'handler': JunosDeviceHandler})
self.assertEqual(
device_handler.__class__.__name__,
"JunosDeviceHandler")
def _mock_device_handler(self):
return manager.make_device_handler({'name': 'default'})
def test_filter_xml_delimiter_multiple_rpc_in_parallel(
self, mock_uuid4, mock_select, mock_session, mock_recv,
mock_close, mock_send, mock_send_ready, mock_connected):
mock_send.return_value = True
mock_send_ready.return_value = -1
mock_uuid4.side_effect = [
type('xyz', (),
{'urn': "urn:uuid:ddef40cb-5745-481d-974d-7188f9f2bb33"}),
type('pqr', (),
{'urn': "urn:uuid:549ef9d1-024a-4fd0-88bf-047d25f0870d"})
]
device_handler = manager.make_device_handler({
'name': 'junos',
'use_filter': True
})
rpc = '<get-software-information/>'
mock_recv.side_effect = [
b"""
<rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" xmlns:junos="http://xml.juniper.net/junos/19.2I0/junos" xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="urn:uuid:ddef40cb-5745-481d-974d-7188f9f2bb33">
<ospf-neighbor-information xmlns="http://xml.juniper.net/junos/19.2I0/junos-routing">
<ospf-neighbor>
<neighbor-address>13.1.1.2</neighbor-address>
<interface-name>ge-0/0/0.1</interface-name>
<ospf-neighbor-state>Exchange</ospf-neighbor-state>
<neighbor-id>2.2.2.2</neighbor-id>
<neighbor-priority>128</neighbor-priority>
<activity-timer>36</activity-timer>
<ospf-area>0.0.0.0</ospf-area>
<options>0x52</options>
<dr-address>13.1.1.1</dr-address>
<bdr-address>13.1.1.2</bdr-address>
<neighbor-up-time junos:seconds="17812">
04:56:52
</neighbor-up-time>
<neighbor-adjacency-time junos:seconds="17812">
04:56:52
</neighbor-adjacency-time>
<master-slave>slave</master-slave>
<sequence-number>0x204b6fd</sequence-number>
<dbd-retransmit-time>3</dbd-retransmit-time>
<lsreq-retransmit-time>0</lsreq-retransmit-time>
<lsa-list>
Link state retransmission list:
Type LSA ID Adv rtr Seq
Router 1.1.1.1 1.1.1.1 0x80000019
OpaqArea 1.0.0.1 1.1.1.1 0x80000011
Router 3.3.3.3 3.3.3.3 0x80000004
Network 23.1.1.2 3.3.3.3 0x80000001
OpaqArea 1.0.0.1 2.2.2.2 0x80000002
OpaqArea 1.0.0.1 3.3.3.3 0x80000002
OpaqArea 1.0.0.3 1.1.1.1 0x80000002
OpaqArea 1.0.0.3 3.3.3.3 0x80000001
OpaqArea 1.0.0.4 2.2.2.2 0x80000001
</lsa-list>
<ospf-neighbor-topology>
<ospf-topology-name>default</ospf-topology-name>
<ospf-topology-id>0</ospf-topology-id>
<ospf-neighbor-topology-state>Forward Only</ospf-neighbor-topology-state>
</ospf-neighbor-topology>
</ospf-neighbor>
</ospf-neighbor-information>
</rpc-reply>]]>]]><rpc-reply xmlns="urn:ietf:params:xml:ns:netconf:base:1.0" xmlns:junos="http://xml.juniper.net/junos/19.2I0/junos" xmlns:nc="urn:ietf:params:xml:ns:netconf:base:1.0" message-id="urn:uuid:549ef9d1-024a-4fd0-88bf-047d25f0870d">
<pfe-statistics>
<pfe-traffic-statistics>
<pfe-input-packets>22450</pfe-input-packets>
<input-pps>0</input-pps>
<pfe-output-packets>31992</pfe-output-packets>
<output-pps>0</output-pps>
<pfe-fabric-input>0</pfe-fabric-input>
<pfe-fabric-input-pps>0</pfe-fabric-input-pps>
<pfe-fabric-output>0</pfe-fabric-output>
<pfe-fabric-output-pps>0</pfe-fabric-output-pps>
</pfe-traffic-statistics></pfe-statistics></rpc-reply>]]>]]>"""
]
session = SSHSession(device_handler)
session._connected = True
session._channel = paramiko.Channel("c100")
session.parser = session._device_handler.get_xml_parser(session)
obj = ExecuteRpc(session, device_handler, raise_mode=RaiseMode.ALL)
obj = ExecuteRpc(session, device_handler, raise_mode=RaiseMode.ALL)
obj._filter_xml = '<multi-routing-engine-results><multi-routing-engine-item><re-name/></multi-routing-engine-item></multi-routing-engine-results>'
session.run()
resp = obj.request(rpc)._NCElement__doc[0]
self.assertEqual(len(resp.xpath('pfe-traffic-statistics')), 1)
def setUp(self):
self.device_handler = manager.make_device_handler({'name': 'ericsson'})
def setUp(self):
self.device_handler = manager.make_device_handler({'name': 'junos'})
def setUp(self):
self.device_handler = manager.make_device_handler(
{'name': 'hpcomware'})
def setUp(self):
self.device_handler = manager.make_device_handler({'name': 'huawei'})
