def run_multiple_routing_bgp(netconf_service, session):
crud = CRUDService()
codec = CodecService()
codec_provider = CodecServiceProvider()
crud.delete(session, bgp())
crud.delete(session, RoutingPolicy())
multi_cfg = _get_bgp_routing_multiple_object()
multi_payload_expected = codec.encode(codec_provider, multi_cfg)
result = netconf_service.edit_config(session, Datastore.candidate, multi_cfg)
assert 'ok' in result
multi_filter = {'bgp':bgp(), 'routing-policy':RoutingPolicy()}
multi_entity_read = netconf_service.get_config(session, Datastore.candidate, multi_filter)
multi_payload_actual = codec.encode(codec_provider, multi_entity_read)
assert multi_payload_expected == multi_payload_actual
class SanityCodec(unittest.TestCase):
@classmethod
def setUpClass(self):
self.codec = CodecService()
self.provider = CodecServiceProvider(type=EncodingFormat.XML)
self._enum_payload_1 = """<built-in-t xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<enum-value>local</enum-value>
</built-in-t>
"""
self._enum_payload_2 = """<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<ytypes>
<built-in-t>
<enum-value>local</enum-value>
</built-in-t>
</ytypes>
</runner>"""
self._runner_payload = """<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<two-list>
<ldata>
<number>21</number>
<name>runner:twolist:ldata[21]:name</name>
<subl1>
<number>211</number>
<name>runner:twolist:ldata[21]:subl1[211]:name</name>
</subl1>
<subl1>
<number>212</number>
<name>runner:twolist:ldata[21]:subl1[212]:name</name>
</subl1>
</ldata>
<ldata>
<number>22</number>
<name>runner:twolist:ldata[22]:name</name>
<subl1>
<number>221</number>
<name>runner:twolist:ldata[22]:subl1[221]:name</name>
</subl1>
<subl1>
<number>222</number>
<name>runner:twolist:ldata[22]:subl1[222]:name</name>
</subl1>
</ldata>
</two-list>
</runner>
"""
def _get_runner_entity(self):
r_1 = ysanity.Runner()
e_1, e_2 = ysanity.Runner.TwoList.Ldata(
), ysanity.Runner.TwoList.Ldata()
e_11, e_12 = ysanity.Runner.TwoList.Ldata.Subl1(
), ysanity.Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:name'
e_11.number = 211
e_11.name = 'runner:twolist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 212
e_12.name = 'runner:twolist:ldata[' + str(
e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = ysanity.Runner.TwoList.Ldata.Subl1(
), ysanity.Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:name'
e_21.number = 221
e_21.name = 'runner:twolist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 222
e_22.name = 'runner:twolist:ldata[' + str(
e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
return r_1
_entity_pattern = "'provider' and 'entity_holder' cannot be None"
_payload_pattern = "'provider' and 'payload_holder' cannot be None"
@assert_with_error(_entity_pattern, YServiceError)
def test_encode_invalid_1(self):
self.codec.encode(self.provider, None)
@assert_with_error(_entity_pattern, YServiceError)
def test_encode_invalid_2(self):
self.codec.encode(None, self._get_runner_entity())
@assert_with_error(_entity_pattern, YServiceError)
def test_encode_invalid_3(self):
self.codec.encode(None, None)
@assert_with_error(_payload_pattern, YServiceError)
def test_decode_invalid_1(self):
self.codec.decode(None, self._enum_payload_2)
@assert_with_error(_payload_pattern, YServiceError)
def test_decode_invalid_2(self):
self.codec.decode(self.provider, None)
@assert_with_error(_payload_pattern, YServiceError)
def test_decode_invalid_3(self):
self.codec.decode(None, None)
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
bgp = xr_ipv4_bgp_cfg.Bgp() # create object
config_bgp(bgp) # add object configuration
# encode and print object
print(codec.encode(provider, bgp))
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
grpc = xr_man_ems_cfg.Grpc() # create object
config_grpc(grpc) # add object configuration
# encode and print object
print(codec.encode(provider, grpc))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ip_domain = xr_ip_domain_cfg.IpDomain() # create object
config_ip_domain(ip_domain) # add object configuration
# encode and print object
print(codec.encode(provider, ip_domain))
exit()
# End of script
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.codec = CodecService()
self.provider = CodecServiceProvider(type='xml')
self._enum_payload_1 = \
'<built-in-t xmlns="http://cisco.com/ns/yang/ydktest-sanity">\n <enum-value>local</enum-value>\n</built-in-t>\n'
self._enum_payload_2 = \
'<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">\n <ytypes>\n <built-in-t>\n <enum-value>local</enum-value>\n </built-in-t>\n </ytypes>\n</runner>\n'
self._runner_payload = \
'<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">\n\
<two-list>\n\
<ldata>\n\
<number>21</number>\n\
<name>runner:twolist:ldata[21]:name</name>\n\
<subl1>\n\
<number>211</number>\n\
<name>runner:twolist:ldata[21]:subl1[211]:name</name>\n\
</subl1>\n\
<subl1>\n\
<number>212</number>\n\
<name>runner:twolist:ldata[21]:subl1[212]:name</name>\n\
</subl1>\n\
</ldata>\n\
<ldata>\n\
<number>22</number>\n\
<name>runner:twolist:ldata[22]:name</name>\n\
<subl1>\n\
<number>221</number>\n\
<name>runner:twolist:ldata[22]:subl1[221]:name</name>\n\
</subl1>\n\
<subl1>\n\
<number>222</number>\n\
<name>runner:twolist:ldata[22]:subl1[222]:name</name>\n\
</subl1>\n\
</ldata>\n\
</two-list>\n\
</runner>\n'
@classmethod
def tearDownClass(self):
pass
def setUp(self):
print '\nIn method', self._testMethodName + ':'
def tearDown(self):
pass
def _get_runner_entity(self):
r_1 = ysanity.Runner()
e_1, e_2 = ysanity.Runner.TwoList.Ldata(), ysanity.Runner.TwoList.Ldata()
e_11, e_12 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:name'
e_11.number = 211
e_11.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 212
e_12.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:name'
e_21.number = 221
e_21.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 222
e_22.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
return r_1
def test_encode_1(self):
r_1 = self._get_runner_entity()
payload = self.codec.encode(self.provider, r_1)
self.assertEqual(self._runner_payload, payload)
def test_encode_2(self):
from ydk.models.ydktest.ydktest_sanity import YdkEnumTestEnum
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.LOCAL
payload = self.codec.encode(self.provider, r_1)
self.assertEqual(self._enum_payload_1, payload)
def test_decode_1(self):
entity = self.codec.decode(self.provider, self._enum_payload_2)
self.assertEqual(self._enum_payload_2, self.codec.encode(self.provider, entity))
def test_encode_decode(self):
r_1 = self._get_runner_entity()
payload = self.codec.encode(self.provider, r_1)
entity = self.codec.decode(self.provider, payload)
self.assertEqual(is_equal(r_1, entity), True)
self.assertEqual(payload, self.codec.encode(self.provider, entity))
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
global_interface_configuration = xr_ifmgr_cfg.GlobalInterfaceConfiguration() # create object
config_global_interface_configuration(global_interface_configuration) # add object configuration
# encode and print object
print(codec.encode(provider, global_interface_configuration))
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
cdp = xr_cdp_cfg.Cdp() # create object
config_cdp(cdp) # add object configuration
# encode and print object
print(codec.encode(provider, cdp))
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
routing_policy = oc_routing_policy.RoutingPolicy() # create object
config_routing_policy(routing_policy) # add object configuration
# encode and print object
print(codec.encode(provider, routing_policy))
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
interface_configurations = xr_ifmgr_cfg.InterfaceConfigurations() # create object
config_interface_configurations(interface_configurations) # add object configuration
# encode and print object
print(codec.encode(provider, interface_configurations))
provider.close()
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
syslog = xr_infra_syslog_cfg.Syslog() # create object
config_syslog(syslog) # add object configuration
# encode and print object
print(codec.encode(provider, syslog))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
syslog_service = xr_infra_syslog_cfg.SyslogService() # create object
config_syslog_service(syslog_service) # add object configuration
# encode and print object
print(codec.encode(provider, syslog_service))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
arp = xr_ipv4_arp_cfg.Arp() # create object
config_arp(arp) # add object configuration
# encode and print object
print(codec.encode(provider, arp))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
keychains = xr_lib_keychain_cfg.Keychains() # create object
config_keychains(keychains) # add object configuration
# encode and print object
print(codec.encode(provider, keychains))
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
network_instances = oc_network_instance.NetworkInstances()
config_mpls(network_instances) # add object configuration
# encode and print object
print(codec.encode(provider, network_instances))
exit()
# End of script
if __name__ == "__main__":
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
routing_policy = oc_routing_policy.RoutingPolicy() # create config object
config_routing_policy(routing_policy) # add object configuration
print(codec.encode(provider, routing_policy)) # encode and print object
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
sr = xr_segment_routing_ms_cfg.Sr() # create object
config_sr(sr) # add object configuration
# encode and print object
print(codec.encode(provider, sr))
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
clock = xr_infra_infra_clock_linux_cfg.Clock() # create object
config_clock(clock) # add object configuration
# encode and print object
print(codec.encode(provider, clock))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
telemetry_system = oc_telemetry.TelemetrySystem() # create object
config_telemetry_system(telemetry_system) # add object configuration
# encode and print object
print(codec.encode(provider, telemetry_system))
exit()
# End of script
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
aaa = xr_aaa_lib_cfg.Aaa() # create object
config_aaa(aaa) # add object configuration
# encode and print object
print(codec.encode(provider, aaa))
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ipv4_acl_and_prefix_list = xr_ipv4_acl_cfg.Ipv4AclAndPrefixList() # create object
config_ipv4_acl_and_prefix_list(ipv4_acl_and_prefix_list) # add object configuration
# encode and print object
print(codec.encode(provider, ipv4_acl_and_prefix_list))
exit()
# End of script
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
telemetry_model_driven = xr_telemetry_model_driven_cfg.TelemetryModelDriven(
) # create object
config_telemetry_model_driven(
telemetry_model_driven) # add object configuration
# encode and print object
print(codec.encode(provider, telemetry_model_driven))
provider.close()
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
isis = xr_clns_isis_cfg.Isis() # create object
config_isis(isis) # add object configuration
# encode and print object
print(codec.encode(provider, isis))
provider.close()
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
telemetry_system = oc_telemetry.TelemetrySystem() # create object
config_telemetry_system(telemetry_system) # add object configuration
# encode and print object
print(codec.encode(provider, telemetry_system))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
rsvp = xr_ip_rsvp_cfg.Rsvp() # create object
config_rsvp(rsvp) # add object configuration
# encode and print object
print(codec.encode(provider, rsvp))
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
cdp = xr_cdp_cfg.Cdp() # create object
config_cdp(cdp) # add object configuration
# encode and print object
print(codec.encode(provider, cdp))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
clock = xr_infra_infra_clock_linux_cfg.Clock() # create object
config_clock(clock) # add object configuration
# encode and print object
print(codec.encode(provider, clock))
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ip_domain = xr_ip_domain_cfg.IpDomain() # create object
config_ip_domain(ip_domain) # add object configuration
# encode and print object
print(codec.encode(provider, ip_domain))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ntp = xr_ip_ntp_cfg.Ntp() # create object
config_ntp(ntp) # add object configuration
# encode and print object
print(codec.encode(provider, ntp))
exit()
# End of script
if __name__ == "__main__":
"""Execute main program."""
parser = argparse.ArgumentParser()
parser.add_argument('-v', "--verbose", help="print debugging messages",
action="store_true")
# parser.add_argument('-n', required=True, help='specify node(s) ; Mandatory', nargs='*')
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
connection = NetconfServiceProvider(address="10.92.77.167", port=830, username="******", password='******')
crud = CRUDService()
nativeobject = Cisco_IOS_XE_native.Native()
nativedata = crud.read(connection, nativeobject)
provider = CodecServiceProvider(type="xml")
codec = CodecService()
xmls = codec.encode(provider, nativedata)
print (xmls)
connection.close()
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
arpgmp = xr_ipv4_arp_cfg.Arpgmp() # create object
config_arpgmp(arpgmp) # add object configuration
# encode and print object
print(codec.encode(provider, arpgmp))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
native = xe_native.Native() # create object
config_native(native) # add object configuration
# encode and print object
print(codec.encode(provider, native))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
vrfs = xr_infra_rsi_cfg.Vrfs() # create object
config_vrfs(vrfs) # add object configuration
# encode and print object
print(codec.encode(provider, vrfs))
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
grpc = xr_man_ems_cfg.Grpc() # create object
config_grpc(grpc) # add object configuration
# encode and print object
print(codec.encode(provider, grpc))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
lldp = xr_ethernet_lldp_cfg.Lldp() # create object
config_lldp(lldp) # add object configuration
# encode and print object
print(codec.encode(provider, lldp))
exit()
# End of script
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
sr = xr_segment_routing_ms_cfg.Sr() # create object
config_sr(sr) # add object configuration
# encode and print object
print(codec.encode(provider, sr))
provider.close()
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
global_interface_configuration = xr_ifmgr_cfg.GlobalInterfaceConfiguration() # create object
config_global_interface_configuration(global_interface_configuration) # add object configuration
# encode and print object
print(codec.encode(provider, global_interface_configuration))
provider.close()
exit()
# End of script
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
isis = xr_clns_isis_cfg.Isis() # create object
config_isis(isis) # add object configuration
# encode and print object
print(codec.encode(provider, isis))
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ospf = xr_ipv4_ospf_cfg.Ospf() # create object
config_ospf(ospf) # add object configuration
# encode and print object
print(codec.encode(provider, ospf))
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
lldp = xr_ethernet_lldp_cfg.Lldp() # create object
config_lldp(lldp) # add object configuration
# encode and print object
print(codec.encode(provider, lldp))
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
telemetry_model_driven = xr_telemetry_model_driven_cfg.TelemetryModelDriven() # create object
config_telemetry_model_driven(telemetry_model_driven) # add object configuration
# encode and print object
print(codec.encode(provider, telemetry_model_driven))
exit()
# End of script
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
host_names = xr_shellutil_cfg.HostNames() # create object
config_host_names(host_names) # add object configuration
# encode and print object
print(codec.encode(provider, host_names))
provider.close()
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
interface_configurations = xr_ifmgr_cfg.InterfaceConfigurations() # create object
config_interface_configurations(interface_configurations) # add object configuration
# encode and print object
print(codec.encode(provider, interface_configurations))
exit()
# End of script
class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.csp = CodecServiceProvider(type=EncodingFormat.XML)
self.es = ExecutorService()
self.cs = CodecService()
def setUp(self):
# start a brand new session for every single test case
# so test_close_session_rpc will not interfere with other test cases
# self.ncc = NetconfServiceProvider('127.0.0.1', 'admin', 'admin', 12022)
self.ncc = NetconfServiceProvider(self.hostname, self.username,
self.password, self.port,
self.protocol, self.on_demand,
self.common_cache, self.timeout)
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
# close session by close session rpc
try:
rpc = ietf_netconf.CloseSession()
self.es.execute_rpc(self.ncc, rpc)
except YError:
pass
del self.ncc
def test_close_session_rpc(self):
rpc = ietf_netconf.CloseSession()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_commit_rpc(self):
rpc = ietf_netconf.Commit()
rpc.input.confirmed = Empty()
rpc.input.confirm_timeout = 5
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_copy_config_rpc(self):
rpc = ietf_netconf.CopyConfig()
rpc.input.target.candidate = Empty()
rpc.input.source.running = Empty()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
@unittest.skip('Issues in netsim')
def test_delete_config_rpc(self):
rpc = ietf_netconf.DeleteConfig()
rpc.input.target.url = "http://test"
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_discard_changes_rpc(self):
rpc = ietf_netconf.DiscardChanges()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
# test edit config, get config, and get rpcs
def test_edit_config_rpc(self):
runner = ysanity.Runner()
runner.ydktest_sanity_one.number = 1
runner.ydktest_sanity_one.name = 'runner:one:name'
runner_xml = self.cs.encode(self.csp, runner)
filter_xml = self.cs.encode(self.csp, ysanity.Runner())
# Edit Config
edit_rpc = ietf_netconf.EditConfig()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner_xml
reply = self.es.execute_rpc(self.ncc, edit_rpc)
self.assertIsNone(reply)
# Get Config
get_config_rpc = ietf_netconf.GetConfig()
get_config_rpc.input.source.candidate = Empty()
get_config_rpc.input.filter = filter_xml
reply = self.es.execute_rpc(self.ncc, get_config_rpc, runner)
self.assertIsNotNone(reply)
self.assertEqual(reply, runner)
# Commit
commit_rpc = ietf_netconf.Commit()
reply = self.es.execute_rpc(self.ncc, commit_rpc)
self.assertIsNone(reply)
# Get
get_rpc = ietf_netconf.Get()
get_rpc.input.filter = filter_xml
reply = self.es.execute_rpc(self.ncc, get_rpc, runner)
self.assertIsNotNone(reply)
self.assertEqual(reply, runner)
@unittest.skip('YServiceProviderError')
def test_kill_session(self):
rpc = ietf_netconf.KillSession()
rpc.input.session_id = 3
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
# test lock, unlock rpc
def test_lock_rpc(self):
lock_rpc = ietf_netconf.Lock()
lock_rpc.input.target.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, lock_rpc)
self.assertIsNone(reply)
unlock_rpc = ietf_netconf.Unlock()
unlock_rpc.input.target.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, unlock_rpc)
self.assertIsNone(reply)
def test_unlock_rpc_fail(self):
lock_rpc = ietf_netconf.Lock()
lock_rpc.input.target.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, lock_rpc)
self.assertIsNone(reply)
unlock_rpc = ietf_netconf.Unlock()
unlock_rpc.input.target.running = Empty()
try:
reply = self.es.execute_rpc(self.ncc, unlock_rpc)
except Exception as e:
self.assertIsInstance(e, YError)
def test_validate_rpc_1(self):
rpc = ietf_netconf.Validate()
rpc.input.source.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_validate_rpc_2(self):
runner = ysanity.Runner()
runner.ydktest_sanity_one.number = 1
runner.ydktest_sanity_one.name = 'runner:one:name'
runner_xml = self.cs.encode(self.csp, runner)
rpc = ietf_netconf.Validate()
rpc.input.source.config = runner_xml
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_non_rpc_fail(self):
runner = ysanity.Runner()
try:
self.es.execute_rpc(self.ncc, runner)
except Exception as e:
self.assertIsInstance(e, YError)
# self.assertEqual(e.code, YErrorCode.INVALID_RPC)
@unittest.skip('TODO: get-schema rpc is not yet supported on netsim')
def test_execute_get_schema(self):
get_schema_rpc = ietf_netconf_monitoring.GetSchema()
get_schema_rpc.input.identifier = 'ietf-netconf-monitoring'
get_schema_rpc.input.format = ietf_netconf_monitoring.Yang_Identity()
self.executor.execute_rpc(self.ncc, get_schema_rpc)
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
syslog = xr_infra_syslog_cfg.Syslog() # create object
config_syslog(syslog) # add object configuration
# encode and print object
print(codec.encode(provider, syslog))
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
rsvp = xr_ip_rsvp_cfg.Rsvp() # create object
config_rsvp(rsvp) # add object configuration
# encode and print object
print(codec.encode(provider, rsvp))
exit()
# End of script
class SanityTest(unittest.TestCase):
@classmethod
def setUpClass(self):
self.csp = CodecServiceProvider(type=EncodingFormat.XML)
self.es = ExecutorService()
self.cs = CodecService()
def setUp(self):
# start a brand new session for every single test case
# so test_close_session_rpc will not interfere with other test cases
# self.ncc = NetconfServiceProvider('127.0.0.1', 'admin', 'admin', 12022)
self.ncc = NetconfServiceProvider(
self.hostname,
self.username,
self.password,
self.port,
self.protocol,
self.on_demand,
self.common_cache,
self.timeout)
from ydk.services import CRUDService
crud = CRUDService()
runner = ysanity.Runner()
crud.delete(self.ncc, runner)
def tearDown(self):
# close session by close session rpc
try:
rpc = ietf_netconf.CloseSession()
self.es.execute_rpc(self.ncc, rpc)
except YError:
pass
del self.ncc
@unittest.skip('Issues in confd')
def test_close_session_rpc(self):
rpc = ietf_netconf.CloseSession()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_commit_rpc(self):
rpc = ietf_netconf.Commit()
rpc.input.confirmed = Empty()
rpc.input.confirm_timeout = 5
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_copy_config_rpc(self):
rpc = ietf_netconf.CopyConfig()
rpc.input.target.candidate = Empty()
rpc.input.source.running = Empty()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
@unittest.skip('Issues in netsim')
def test_delete_config_rpc(self):
rpc = ietf_netconf.DeleteConfig()
rpc.input.target.url = "http://test"
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_discard_changes_rpc(self):
rpc = ietf_netconf.DiscardChanges()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
# test edit config, get config, and get rpcs
def test_edit_config_rpc(self):
runner = ysanity.Runner()
runner.ydktest_sanity_one.number = 1
runner.ydktest_sanity_one.name = 'runner:one:name'
runner_xml = self.cs.encode(self.csp, runner)
filter_xml = self.cs.encode(self.csp, ysanity.Runner())
# Edit Config
edit_rpc = ietf_netconf.EditConfig()
edit_rpc.input.target.candidate = Empty()
edit_rpc.input.config = runner_xml
reply = self.es.execute_rpc(self.ncc, edit_rpc)
self.assertIsNone(reply)
# Get Config
get_config_rpc = ietf_netconf.GetConfig()
get_config_rpc.input.source.candidate = Empty()
get_config_rpc.input.filter = filter_xml
reply = self.es.execute_rpc(self.ncc, get_config_rpc, runner)
self.assertIsNotNone(reply)
self.assertEqual(reply, runner)
# Commit
commit_rpc = ietf_netconf.Commit()
reply = self.es.execute_rpc(self.ncc, commit_rpc)
self.assertIsNone(reply)
# Get
get_rpc = ietf_netconf.Get()
get_rpc.input.filter = filter_xml
reply = self.es.execute_rpc(self.ncc, get_rpc, runner)
self.assertIsNotNone(reply)
self.assertEqual(reply, runner)
@unittest.skip('YServiceProviderError')
def test_kill_session(self):
rpc = ietf_netconf.KillSession()
rpc.input.session_id = 3
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
# test lock, unlock rpc
def test_lock_rpc(self):
lock_rpc = ietf_netconf.Lock()
lock_rpc.input.target.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, lock_rpc)
self.assertIsNone(reply)
unlock_rpc = ietf_netconf.Unlock()
unlock_rpc.input.target.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, unlock_rpc)
self.assertIsNone(reply)
def test_unlock_rpc_fail(self):
lock_rpc = ietf_netconf.Lock()
lock_rpc.input.target.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, lock_rpc)
self.assertIsNone(reply)
unlock_rpc = ietf_netconf.Unlock()
unlock_rpc.input.target.running = Empty()
try:
reply = self.es.execute_rpc(self.ncc, unlock_rpc)
except Exception as e:
self.assertIsInstance(e, YError)
def test_validate_rpc_1(self):
rpc = ietf_netconf.Validate()
rpc.input.source.candidate = Empty()
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_validate_rpc_2(self):
runner = ysanity.Runner()
runner.ydktest_sanity_one.number = 1
runner.ydktest_sanity_one.name = 'runner:one:name'
runner_xml = self.cs.encode(self.csp, runner)
rpc = ietf_netconf.Validate()
rpc.input.source.config = runner_xml
reply = self.es.execute_rpc(self.ncc, rpc)
self.assertIsNone(reply)
def test_non_rpc_fail(self):
runner = ysanity.Runner()
try:
self.es.execute_rpc(self.ncc, runner)
except Exception as e:
self.assertIsInstance(e, YError)
# self.assertEqual(e.code, YErrorCode.INVALID_RPC)
def test_execute_get_schema(self):
get_rpc = ietf_netconf.Get()
get_rpc.input.filter = '<bgp xmlns="http://openconfig.net/yang/bgp"/>'
self.es.execute_rpc(self.ncc, get_rpc, openconfig_bgp.Bgp())
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
bgp = xr_ipv4_bgp_cfg.Bgp() # create object
config_bgp(bgp) # add object configuration
# encode and print object
print(codec.encode(provider, bgp))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
native = xe_native.Native() # create object
config_native(native) # add object configuration
# encode and print object
print(codec.encode(provider, native))
exit()
# End of script
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ipv4_acl_and_prefix_list = xr_ipv4_acl_cfg.Ipv4AclAndPrefixList(
) # create object
config_ipv4_acl_and_prefix_list(
ipv4_acl_and_prefix_list) # add object configuration
# encode and print object
print(codec.encode(provider, ipv4_acl_and_prefix_list))
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
locale = xr_infra_infra_locale_cfg.Locale() # create object
config_locale(locale) # add object configuration
# encode and print object
print(codec.encode(provider, locale))
provider.close()
exit()
# End of script
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
locale = xr_infra_infra_locale_cfg.Locale() # create object
config_locale(locale) # add object configuration
# encode and print object
print(codec.encode(provider, locale))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
syslog_service = xr_infra_syslog_cfg.SyslogService() # create object
config_syslog_service(syslog_service) # add object configuration
# encode and print object
print(codec.encode(provider, syslog_service))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
router_static = xr_ip_static_cfg.RouterStatic() # create object
config_router_static(router_static) # add object configuration
# encode and print object
print(codec.encode(provider, router_static))
exit()
# End of script
class SanityYang(unittest.TestCase):
@classmethod
def setUpClass(self):
self.codec = CodecService()
self.provider = CodecServiceProvider(type='xml')
self._enum_payload_1 = '''<built-in-t xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<enum-value>local</enum-value>
</built-in-t>
'''
self._enum_payload_2 = '''<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<ytypes>
<built-in-t>
<enum-value>local</enum-value>
</built-in-t>
</ytypes>
</runner>
'''
self._runner_payload = '''<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<two-list>
<ldata>
<number>21</number>
<name>runner:twolist:ldata[21]:name</name>
<subl1>
<number>211</number>
<name>runner:twolist:ldata[21]:subl1[211]:name</name>
</subl1>
<subl1>
<number>212</number>
<name>runner:twolist:ldata[21]:subl1[212]:name</name>
</subl1>
</ldata>
<ldata>
<number>22</number>
<name>runner:twolist:ldata[22]:name</name>
<subl1>
<number>221</number>
<name>runner:twolist:ldata[22]:subl1[221]:name</name>
</subl1>
<subl1>
<number>222</number>
<name>runner:twolist:ldata[22]:subl1[222]:name</name>
</subl1>
</ldata>
</two-list>
</runner>
'''
self._oc_pattern_payload = '''<oc-A xmlns="http://cisco.com/ns/yang/oc-pattern">
<a>Hello</a>
</oc-A>
'''
@classmethod
def tearDownClass(self):
pass
def setUp(self):
pass
def tearDown(self):
pass
def _get_runner_entity(self):
r_1 = ysanity.Runner()
e_1, e_2 = ysanity.Runner.TwoList.Ldata(), ysanity.Runner.TwoList.Ldata()
e_11, e_12 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_1.number = 21
e_1.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:name'
e_11.number = 211
e_11.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:subl1[' + str(e_11.number) + ']:name'
e_12.number = 212
e_12.name = 'runner:twolist:ldata[' + str(e_1.number) + ']:subl1[' + str(e_12.number) + ']:name'
e_1.subl1.extend([e_11, e_12])
e_21, e_22 = ysanity.Runner.TwoList.Ldata.Subl1(), ysanity.Runner.TwoList.Ldata.Subl1()
e_2.number = 22
e_2.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:name'
e_21.number = 221
e_21.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:subl1[' + str(e_21.number) + ']:name'
e_22.number = 222
e_22.name = 'runner:twolist:ldata[' + str(e_2.number) + ']:subl1[' + str(e_22.number) + ']:name'
e_2.subl1.extend([e_21, e_22])
r_1.two_list.ldata.extend([e_1, e_2])
return r_1
def test_encode_1(self):
r_1 = self._get_runner_entity()
payload = self.codec.encode(self.provider, r_1)
self.assertEqual(self._runner_payload, payload)
def test_encode_2(self):
from ydk.models.ydktest_sanity import YdkEnumTestEnum
r_1 = ysanity.Runner.Ytypes.BuiltInT()
r_1.enum_value = YdkEnumTestEnum.LOCAL
payload = self.codec.encode(self.provider, r_1)
self.assertEqual(self._enum_payload_1, payload)
def test_encode_invalid_1(self):
try:
self.codec.encode(self.provider, None)
except YPYServiceError as err:
self.assertEqual(
err.message, "'encoder' and 'entity' cannot be None")
else:
raise Exception('YPYServiceError not raised')
def test_encode_invalid_2(self):
try:
self.codec.encode(None, self._get_runner_entity())
except YPYServiceError as e:
err = e
self.assertEqual(
err.message, "'encoder' and 'entity' cannot be None")
else:
raise Exception('YPYServiceError not raised')
def test_encode_invalid_3(self):
try:
self.codec.encode(None, None)
except YPYServiceError as e:
err = e
self.assertEqual(
err.message, "'encoder' and 'entity' cannot be None")
else:
raise Exception('YPYServiceError not raised')
def test_decode_1(self):
entity = self.codec.decode(self.provider, self._enum_payload_2)
self.assertEqual(
self._enum_payload_2, self.codec.encode(self.provider, entity))
def test_decode_invalid_1(self):
try:
self.codec.decode(None, self._enum_payload_2)
except YPYServiceError as e:
err = e
self.assertEqual(
err.message, "'decoder' and 'payload' cannot be None")
else:
raise Exception('YPYServiceError not raised')
def test_decode_invalid_2(self):
try:
self.codec.decode(self.provider, None)
except YPYServiceError as e:
err = e
self.assertEqual(
err.message, "'decoder' and 'payload' cannot be None")
else:
raise Exception('YPYServiceError not raised')
def test_decode_invalid_3(self):
try:
self.codec.decode(None, None)
except YPYServiceError as e:
err = e
self.assertEqual(
err.message, "'decoder' and 'payload' cannot be None")
else:
raise Exception('YPYServiceError not raised')
def test_encode_decode(self):
r_1 = self._get_runner_entity()
payload = self.codec.encode(self.provider, r_1)
entity = self.codec.decode(self.provider, payload)
self.assertEqual(is_equal(r_1, entity), True)
self.assertEqual(payload, self.codec.encode(self.provider, entity))
def test_encode_decode_dict(self):
r_1 = self._get_runner_entity()
r_entity = {'ydktest-sanity':r_1}
payload = self.codec.encode(self.provider, r_entity)
entity = self.codec.decode(self.provider, payload)
for module in entity:
self.assertEqual(is_equal(r_entity[module], entity[module]), True)
self.assertEqual(payload, self.codec.encode(self.provider, entity))
def test_decode_oc_pattern(self):
obj_A = oc_pattern.OcA()
obj_A.a = 'Hello'
entity = self.codec.decode(self.provider, self._oc_pattern_payload)
self.assertEqual(is_equal(obj_A, entity), True)
parser.add_argument("-v",
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
ospfv3 = xr_ipv6_ospfv3_cfg.Ospfv3() # create object
config_ospfv3(ospfv3) # add object configuration
# encode and print object
print(codec.encode(provider, ospfv3))
exit()
# End of script
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
router_static = xr_ip_static_cfg.RouterStatic() # create object
config_router_static(router_static) # add object configuration
# encode and print object
print(codec.encode(provider, router_static))
provider.close()
exit()
# End of script
"--verbose",
help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
mac_sec_keychains = xr_lib_keychain_macsec_cfg.MacSecKeychains(
) # create object
config_mac_sec_keychains(mac_sec_keychains) # add object configuration
# encode and print object
print(codec.encode(provider, mac_sec_keychains))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
routing_policy = oc_routing_policy.RoutingPolicy() # create object
config_routing_policy(routing_policy) # add object configuration
# encode and print object
print(codec.encode(provider, routing_policy))
exit()
# End of script
"""Execute main program."""
parser = ArgumentParser()
parser.add_argument("-v", "--verbose", help="print debugging messages",
action="store_true")
args = parser.parse_args()
# log debug messages if verbose argument specified
if args.verbose:
logger = logging.getLogger("ydk")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter(("%(asctime)s - %(name)s - "
"%(levelname)s - %(message)s"))
handler.setFormatter(formatter)
logger.addHandler(handler)
# create codec provider
provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
aaa = xr_aaa_lib_cfg.Aaa() # create object
config_aaa(aaa) # add object configuration
# encode and print object
print(codec.encode(provider, aaa))
exit()
# End of script
