def test_sanity_crud_read_interface(self):
address = ysanity.Native.Interface.Loopback.Ipv4.Address()
address.ip = "2.2.2.2"
address.netmask = "255.255.255.255"
loopback = ysanity.Native.Interface.Loopback()
loopback.name = 2222
loopback.ipv4.address.append(address)
native = ysanity.Native()
native.interface.loopback.append(loopback)
crud = CRUDService()
result = crud.create(self.ncc, native)
self.assertEqual(result, True)
native_read = ysanity.Native()
interfaces = crud.read(self.ncc, native_read)
codec_service = CodecService()
codec_provider = CodecServiceProvider()
codec_provider.encoding = EncodingFormat.XML
xml_encode = codec_service.encode(codec_provider, interfaces)
print('\n===== Printing entity: {}'.format(interfaces))
print(xml_encode)
# Delete configuration
result = crud.delete(self.ncc, native)
self.assertEqual(result, True)
def setUpClass(self):
self.codec_provider = CodecServiceProvider()
self.codec = CodecService()
self.repo = Repository(get_local_repo_dir())
self.provider = gNMIServiceProvider( self.repo, "127.0.0.1", "admin", "admin", port=50051)
self.schema = self.provider.get_session().get_root_schema()
self.crud = CRUDService()
def setUpClass(cls):
cls.ncc = NetconfServiceProvider(cls.hostname, cls.username,
cls.password, cls.port, cls.protocol,
cls.on_demand, cls.common_cache,
cls.timeout)
cls.executor = ExecutorService()
cls.codec = CodecService()
cls.codec_provider = CodecServiceProvider(type=EncodingFormat.XML)
def prepare_config(datafile):
data = ''
# read xml file passes
with open(datafile) as fh:
data = fh.read()
#associate this with codec service to get an ydk object
codec = CodecService()
return codec.decode(CodecServiceProvider(type='xml'), data)
def test_anyxml(self):
provider = CodecServiceProvider(type='xml')
payload = '<?xml version="1.0"?><runner xmlns="http://cisco.com/ns/yang/ydktest-sanity"/>'
result = self.codec.decode(provider, payload)
self.assertIsNotNone(result)
payload = '''<?xml version="1.0"?>
<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity"/>'''
result = self.codec.decode(provider, payload)
self.assertIsNotNone(result)
def test_crud_read_collection(self):
crud = CRUDService()
# Build configuration of multiple objects
create_list = Config()
native = ysanity.Native()
native.hostname = 'NativeHost'
native.version = '0.1.0'
create_list.append(native)
bgp = openconfig.Bgp()
bgp.global_.config.as_ = 65001
bgp.global_.config.router_id = "1.2.3.4"
create_list.append(bgp)
create_list = Config([native, bgp])
# Configure device
result = crud.create(self.ncc, create_list)
self.assertEqual(result, True)
# Read configuration
read_filter = Filter([ysanity.Native(),
openconfig.Bgp()])
read_config = crud.read(self.ncc, read_filter)
self.assertEqual(isinstance(read_config, Config), True)
self.assertEqual(len(read_config), 2)
# Print configuration
codec_service = CodecService()
codec_provider = CodecServiceProvider()
codec_provider.encoding = EncodingFormat.XML
for entity in read_config:
xml = codec_service.encode(codec_provider, entity)
print('\n===== Printing entity: {}'.format(entity))
print(xml)
# Delete configuration
result = crud.delete(self.ncc, create_list)
self.assertEqual(result, True)
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\
def test_list_no_keys(self):
payload = '''<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<no-key-list>
<test>abc</test>
</no-key-list>
<no-key-list>
<test>xyz</test>
</no-key-list>
</runner>'''
xml_provider = CodecServiceProvider(type='xml')
no_key = self.codec.decode(xml_provider, payload)
no_key_payload = self.codec.encode(xml_provider, no_key, subtree=True)
self.assertEqual(payload, no_key_payload)
def test_encode_decode(self):
intf = interface_configurations.InterfaceConfigurations()
iss = intf.InterfaceConfiguration()
iss.active = 'act'
iss.interface_name = 'Loopback0'
iss.vrf = 'red'
intf.interface_configuration.append(iss)
codec = CodecService()
codec_p = CodecServiceProvider(type='json')
json = codec.encode(codec_p, intf)
print(json)
obj = codec.decode(codec_p, json)
print(obj)
def test_sanity_crud_read_interface(self):
enable_logging(logging.ERROR)
address = ysanity.Native.Interface.Loopback.Ipv4.Address();
address.ip = "2.2.2.2"
address.netmask = "255.255.255.255"
loopback = ysanity.Native.Interface.Loopback()
loopback.name = 2222
loopback.ipv4.address.append(address)
native = ysanity.Native()
native.interface.loopback.append(loopback)
crud = CRUDService()
result = crud.create(self.ncc, native)
native_read = ysanity.Native()
interfaces = crud.read(self.ncc, native_read)
codec_service = CodecService()
codec_provider = CodecServiceProvider()
codec_provider.encoding = EncodingFormat.XML
xml_encode = codec_service.encode(codec_provider, interfaces)
def setUpClass(cls):
tmp_dir = tempfile.mkdtemp()
repo = Repository(tmp_dir)
cls.ncc_empty_repo = NetconfServiceProvider(repo, cls.hostname,
cls.username, cls.password,
cls.port, cls.protocol,
cls.on_demand)
cls.ncc = NetconfServiceProvider(cls.hostname, cls.username,
cls.password, cls.port, cls.protocol,
cls.on_demand, cls.common_cache)
cls.crud = CRUDService()
cls.codec_provider = CodecServiceProvider()
cls.codec = CodecService()
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">
def _get_decoded_entity():
from ydk.providers import CodecServiceProvider
from ydk.services import CodecService
payload = '''
<system xmlns="urn:ietf:params:xml:ns:yang:ietf-system">
<contact>[email protected]</contact>
<hostname>1.2.3.4</hostname>
<clock>
<timezone-name>Argentina</timezone-name>
</clock>
<ntp>
<server>
<name>xyz</name>
<udp>
<address>1.2.3.4</address>
<port>22</port>
</udp>
<association-type>peer</association-type>
</server>
</ntp>
<dns-resolver>
<search>abc.com</search>
<search>fff.com</search>
<server>
<name>abc</name>
<udp-and-tcp>
<address>1.2.3.4</address>
<port>830</port>
</udp-and-tcp>
</server>
</dns-resolver>
<authentication>
<user>
<name>guest</name>
<password>guest</password>
</user>
<user>
<name>admin</name>
<password>admin</password>
</user>
</authentication>
</system>
'''
codec = CodecService()
provider = CodecServiceProvider(type='xml')
return codec.decode(provider, payload)
def test_embedded_quote_leaflist_value(self):
xml = '''<routing-policy xmlns="http://openconfig.net/yang/routing-policy">
<defined-sets>
<bgp-defined-sets xmlns="http://openconfig.net/yang/bgp-policy">
<community-sets>
<community-set>
<community-set-name>COMMUNITY-SET1</community-set-name>
<config>
<community-member>ios-regex '^65172:17...$'</community-member>
<community-member>65172:16001</community-member>
<community-set-name>COMMUNITY-SET1</community-set-name>
</config>
<state>
<community-member>ios-regex '^65172:17...$'</community-member>
<community-member>65172:16001</community-member>
<community-set-name>COMMUNITY-SET1</community-set-name>
</state>
</community-set>
</community-sets>
</bgp-defined-sets>
</defined-sets>
</routing-policy>
'''
from ydk.models.ydktest import openconfig_routing_policy \
as oc_routing_policy
routing_policy = oc_routing_policy.RoutingPolicy()
com = oc_routing_policy.RoutingPolicy.DefinedSets.BgpDefinedSets.CommunitySets.CommunitySet(
)
com.community_set_name = "COMMUNITY-SET1"
com.config.community_set_name = "COMMUNITY-SET1"
com.config.community_member.append("ios-regex '^65172:17...$'")
com.config.community_member.append("65172:16001")
com.state.community_set_name = "COMMUNITY-SET1"
com.state.community_member.append("ios-regex '^65172:17...$'")
com.state.community_member.append("65172:16001")
routing_policy.defined_sets.bgp_defined_sets.community_sets.community_set.append(
com)
xml_provider = CodecServiceProvider(type='xml')
payload = self.codec.encode(xml_provider, routing_policy)
self.assertEqual(xml, payload)
routing_policy_decode = self.codec.decode(xml_provider, payload)
self.assertEqual(routing_policy, routing_policy_decode)
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">
def test_embedded_quote_leaflist_value(self):
xml = '''<routing-policy xmlns="http://openconfig.net/yang/routing-policy">
<defined-sets>
<bgp-defined-sets xmlns="http://openconfig.net/yang/bgp-policy">
<community-sets>
<community-set>
<community-set-name>COMMUNITY-SET1</community-set-name>
<config>
<community-set-name>COMMUNITY-SET1</community-set-name>
<community-member>ios-regex '^65172:17...$'</community-member>
<community-member>65172:16001</community-member>
</config>
<state>
<community-set-name>COMMUNITY-SET1</community-set-name>
<community-member>ios-regex '^65172:17...$'</community-member>
<community-member>65172:16001</community-member>
</state>
</community-set>
</community-sets>
</bgp-defined-sets>
</defined-sets>
</routing-policy>
'''
routing_policy = RoutingPolicy()
com = RoutingPolicy.DefinedSets.BgpDefinedSets.CommunitySets.CommunitySet(
)
com.community_set_name = "COMMUNITY-SET1"
com.config.community_set_name = "COMMUNITY-SET1"
com.config.community_member.append("ios-regex '^65172:17...$'")
com.config.community_member.append("65172:16001")
com.state.community_set_name = "COMMUNITY-SET1"
com.state.community_member.append("ios-regex '^65172:17...$'")
com.state.community_member.append("65172:16001")
routing_policy.defined_sets.bgp_defined_sets.community_sets.community_set.append(
com)
xml_provider = CodecServiceProvider(type='xml')
payload = self.codec.encode(xml_provider, routing_policy)
routing_policy_decode = self.codec.decode(xml_provider, payload)
if routing_policy == routing_policy_decode: # TODO failing on travis for --one-module-per-class option
self.assertEqual(routing_policy, routing_policy_decode)
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
def setUpClass(self):
from ydk.providers import CodecServiceProvider
from ydk.services import CodecService
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">
def test_ylist_runner_no_key_list(self):
runner = ysanity.Runner()
t1 = ysanity.Runner().NoKeyList()
t1.test = 't1'
t2 = ysanity.Runner().NoKeyList()
t2.test = 't2'
t3 = ysanity.Runner().NoKeyList()
t3.test = 't3'
runner.no_key_list.extend([t1, t2, t3])
count = ''
for elem in runner.no_key_list:
count += elem.test
self.assertEqual(count, 't1t2t3')
from ydk.providers import CodecServiceProvider
from ydk.services import CodecService
provider = CodecServiceProvider(type='xml')
codec = CodecService()
payload = codec.encode(provider, runner)
expected = '''<runner xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<no-key-list>
<test>t1</test>
</no-key-list>
<no-key-list>
<test>t2</test>
</no-key-list>
<no-key-list>
<test>t3</test>
</no-key-list>
</runner>
'''
self.assertEqual(payload, expected)
runner_decode = codec.decode(provider, payload)
self.assertEqual(runner_decode, runner)
)
comm_set.community_set_name = 'testing'
comm_set.community_member.append("oooo")
comm_set.community_member.append("a")
routing_policy.defined_sets.bgp_defined_sets.community_sets.community_set.append(
comm_set)
routing_payload = codec_service.encode(provider, routing_policy)
print routing_payload
routing_entity = codec_service.decode(provider, routing_payload)
print 'Encoded payload:\n', routing_payload, \
'\nRe-encode the decoded payload:\n', codec_service.encode(provider, routing_entity)
assert routing_payload == codec_service.encode(provider, routing_entity)
def init_logging():
import logging
log = logging.getLogger('ydk')
log.setLevel(logging.DEBUG)
ch = logging.StreamHandler()
log.addHandler(ch)
if __name__ == "__main__":
init_logging()
provider = CodecServiceProvider(type='xml')
codec_service = CodecService()
bgp_run(codec_service, provider)
run_routing(codec_service, provider)
exit()
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
def serialize_model(model):
provider = CodecServiceProvider(type="xml")
codec = CodecService()
return codec.encode(provider, model)
def setUpClass(self):
self.csp = CodecServiceProvider(type=EncodingFormat.XML)
self.es = ExecutorService()
self.cs = CodecService()
from main import celery
from ydk.services import CodecService
from ydk.providers import CodecServiceProvider
from ydk.errors import YModelError, YCodecError, YCoreError, YError, YClientError
from main.models import NetConf, Devices
from requests import post
import json
json_provider = CodecServiceProvider(type='json')
codec = CodecService()
@celery.task(time_limit=15)
def net_conf(message):
data = message.get('data')
json_data = [json.dumps({k: v}) for k, v in data.items()]
sid = message.get('sid')
url = message.get('url')
errors = []
response = {}
try:
_codec = codec.decode(json_provider, json_data)
except (RuntimeError, ValueError, IndexError, YModelError, YCodecError,
YCoreError) as err:
_codec = None
errors.append(str(err))
if _codec is not None:
device_id = message.get('device_id')
def to_string(self):
from ydk.providers import CodecServiceProvider
from ydk.services import CodecService
provider = CodecServiceProvider(type="xml")
codec = CodecService()
return codec.encode(provider, self.binding)
def setUpClass(self):
self.maxDiff = None
self.codec = CodecService()
self.provider = CodecServiceProvider(type='xml')
self._xml_enum_payload_1 = '''<built-in-t xmlns="http://cisco.com/ns/yang/ydktest-sanity">
<enum-value>local</enum-value>
</built-in-t>
'''
self._json_enum_payload_1 = """{
"ydktest-sanity:built-in-t": {
"enum-value": "local"
}
}
"""
self._xml_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._xml_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._json_runner_payload = """{
"ydktest-sanity:runner": {
"two-list": {
"ldata": [
{
"number": 21,
"name": "runner:twolist:ldata[21]:name",
"subl1": [
{
"number": 211,
"name": "runner:twolist:ldata[21]:subl1[211]:name"
},
{
"number": 212,
"name": "runner:twolist:ldata[21]:subl1[212]:name"
}
]
},
{
"number": 22,
"name": "runner:twolist:ldata[22]:name",
"subl1": [
{
"number": 221,
"name": "runner:twolist:ldata[22]:subl1[221]:name"
},
{
"number": 222,
"name": "runner:twolist:ldata[22]:subl1[222]:name"
}
]
}
]
}
}
}
"""
self._xml_oc_pattern_payload = '''<oc-A xmlns="http://cisco.com/ns/yang/oc-pattern">
<a>Hello</a>
</oc-A>
'''
self._json_oc_pattern_payload = """{
import argparse
import json
import yaml
from ydk.providers import CodecServiceProvider
from ydk.services import CodecService
PARSER = argparse.ArgumentParser(description='convert yang json to xml')
PARSER.add_argument('-j', '--json_file', help='json_file')
PARSER.add_argument('-y', '--yaml_file', help='yaml_file')
ARGS = vars(PARSER.parse_args())
CODEC = CodecService()
JSON_PROVIDER = CodecServiceProvider(type='json')
XML_PROVIDER = CodecServiceProvider(type='xml')
def yang_yaml_to_xml(yaml_file):
"""
Convert YAML to XML
"""
with open(yaml_file, 'r') as yaml_in:
yaml_object = yaml.safe_load(yaml_in)
config_json_yang = json.dumps(yaml_object)
decoded_json_yang = CODEC.decode(JSON_PROVIDER, config_json_yang)
yang_xml = CODEC.encode(XML_PROVIDER, decoded_json_yang)
return yang_xml
def create_service(request, nc_provider):
# create CRUD service
crud = CRUDService()
# create codec provider
codec_provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
interface_name = request['interface-name']
# create ifmgr obj
if_cfg = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration()
if_cfg.active = "act"
if_cfg.interface_name = interface_name
if_cfg.interface_mode_non_physical = xr_ifmgr_cfg.InterfaceModeEnum.l2_transport
# creat ethernet service Encapsulation obj
if_cfg.ethernet_service.encapsulation = if_cfg.ethernet_service.Encapsulation(
)
encap_type = xr_eth_infra_dt.Match.match_dot1q
encap_value = xr_eth_infra_dt.Vlan = int(request['vlan-id'])
if_cfg.ethernet_service.encapsulation.outer_tag_type = encap_type
if_cfg.ethernet_service.encapsulation.outer_range1_low = encap_value
if_cfg.ethernet_service.rewrite = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.EthernetService.Rewrite(
)
rewrite_type = xr_eth_infra_dt.Rewrite.pop1
if_cfg.ethernet_service.rewrite.rewrite_type = rewrite_type
# create localtraffic obj
local_traffic_def_encap = if_cfg.ethernet_service.LocalTrafficDefaultEncapsulation(
)
if_cfg.ethernet_service.local_traffic_default_encapsulation = local_traffic_def_encap
if_cfg.ethernet_service.local_traffic_default_encapsulation = if_cfg.ethernet_service.encapsulation
# create the interface configurations add the if_cfg to it
if_cfgs = xr_ifmgr_cfg.InterfaceConfigurations()
if_cfgs.interface_configuration.append(if_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, if_cfgs)
elif request['delete-config'] == 'on':
crud.delete(nc_provider, if_cfg)
# create the l2vpn object, database and pw classes
# set enable as "Empty" type
l2vpn_cfg = xr_l2vpn_cfg.L2vpn()
l2vpn_cfg.enable = Empty()
l2vpn_cfg.database = xr_l2vpn_cfg.L2vpn.Database()
l2vpn_cfg.database.pseudowire_classes = l2vpn_cfg.Database.PseudowireClasses(
)
test_class = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass(
)
test_class.name = "ELINE-PW"
test_class.enable = Empty()
test_class.mpls_encapsulation = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass(
).MplsEncapsulation()
test_class.mpls_encapsulation.enable = Empty()
test_class.mpls_encapsulation.control_word = xr_l2vpn_cfg.ControlWord.enable
flow_label = xr_l2vpn_cfg.FlowLabelLoadBalance()
# flow_label = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass.MplsEncapsulation.LoadBalanceGroup.FlowLabelLoadBalance()
test_class.mpls_encapsulation.load_balance_group = xr_l2vpn_cfg.L2vpn.Database.PseudowireClasses.PseudowireClass.MplsEncapsulation.LoadBalanceGroup(
)
test_class.mpls_encapsulation.load_balance_group.flow_label_load_balance.flow_label = flow_label.both
l2vpn_cfg.database.pseudowire_classes.pseudowire_class.append(test_class)
l2vpn_cfg.database.xconnect_groups = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups(
)
test_group = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup()
test_group.name = "ELINE-SVCS"
l2vpn_cfg.database.xconnect_groups.xconnect_group.append(test_group)
test_group.p2p_xconnects = l2vpn_cfg.Database.XconnectGroups.XconnectGroup.P2pXconnects(
)
test_xconnect = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect(
)
test_xconnect.name = request['vlan-id'] + "-" + request['pw-id']
test_group.p2p_xconnects.p2p_xconnect.append(test_xconnect)
test_xconnect.attachment_circuits = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.AttachmentCircuits(
)
test_ac = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.AttachmentCircuits.AttachmentCircuit(
)
test_ac.name = request['interface-name']
test_ac.enable = Empty()
test_xconnect.attachment_circuits.attachment_circuit.append(test_ac)
test_xconnect.pseudowires = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.Pseudowires(
)
test_pw = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.Pseudowires.Pseudowire(
)
test_pw.pseudowire_id = int(request['pw-id'])
test_neighbor = xr_l2vpn_cfg.L2vpn.Database.XconnectGroups.XconnectGroup.P2pXconnects.P2pXconnect.Pseudowires.Pseudowire.Neighbor(
)
test_neighbor.neighbor = request['neighbor-ip']
test_neighbor.class_ = "ELINE-PW"
test_pw.neighbor.append(test_neighbor)
test_xconnect.pseudowires.pseudowire.append(test_pw)
the_xml = codec.encode(codec_provider, l2vpn_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, l2vpn_cfg)
elif request['delete-config'] == 'on':
xc_group = l2vpn_cfg.database.xconnect_groups.xconnect_group.get(
"ELINE-SVCS")
xc = xc_group.p2p_xconnects.p2p_xconnect[test_xconnect.name]
xc.yfilter = YFilter.delete
# xc.attachment_circuits.yfilter = YFilter.delete
# xc.pseudowires.yfilter = YFilter.delete
crud.update(nc_provider, xc_group)
return
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()
ntp = xr_ip_ntp_cfg.Ntp() # create object
config_ntp(ntp) # add object configuration
# encode and print object
print(codec.encode(provider, ntp))
provider.close()
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
def create_l3_service(request, nc_provider):
# create CRUD service
crud = CRUDService()
# create codec provider
codec_provider = CodecServiceProvider(type="xml")
# create codec service
codec = CodecService()
# interface configuration
interface_name = request['interface-name']
# create ifmgr obj
if_cfg = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration()
if_cfg.active = "act"
if_cfg.interface_name = interface_name
if_cfg.interface_mode_non_physical = xr_ifmgr_cfg.InterfaceModeEnum.default
if_cfg.statistics = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Statistics(
)
if_cfg.statistics.load_interval = 30
if_cfg.ipv4_network = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
)
if_cfg.ipv4_network.addresses = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
).Addresses()
primary_address = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration.Ipv4Network(
).Addresses().Primary()
primary_address.address = request['intf-ip']
primary_address.netmask = "255.255.255.252"
if_cfg.ipv4_network.addresses.primary = primary_address
if_cfg.vlan_sub_configuration = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration(
).VlanSubConfiguration()
if_cfg.vlan_sub_configuration.vlan_identifier = xr_ifmgr_cfg.InterfaceConfigurations.InterfaceConfiguration(
).VlanSubConfiguration().VlanIdentifier()
if_cfg.vlan_sub_configuration.vlan_identifier.first_tag = int(
request['vlan-id'])
encap_type = xr_eth_infra_dt.Vlan.vlan_type_dot1q
if_cfg.vlan_sub_configuration.vlan_identifier.vlan_type = encap_type
the_xml = codec.encode(codec_provider, if_cfg)
# logging.info(the_xml)
# create the interface configurations add the if_cfg to it
if_cfgs = xr_ifmgr_cfg.InterfaceConfigurations()
if_cfgs.interface_configuration.append(if_cfg)
if request['delete-config'] == 'off':
crud.create(nc_provider, if_cfgs)
elif request['delete-config'] == 'on':
crud.delete(nc_provider, if_cfg)
# global configuration
bgp = xr_ipv4_bgp_cfg.Bgp()
instance = bgp.Instance()
instance.instance_name = "default"
instance_as = instance.InstanceAs()
instance_as.as_ = 0
four_byte_as = instance_as.FourByteAs()
four_byte_as.as_ = int(request['bgp-as'])
four_byte_as.bgp_running = Empty()
# global address family
global_af = four_byte_as.default_vrf.global_.global_afs.GlobalAf()
global_af.af_name = xr_ipv4_bgp_datatypes.BgpAddressFamily.ipv4_unicast
global_af.enable = Empty()
global_af.sourced_networks = four_byte_as.default_vrf.global_.global_afs.GlobalAf(
).SourcedNetworks()
network = four_byte_as.default_vrf.global_.global_afs.GlobalAf(
).SourcedNetworks().SourcedNetwork()
addr_parsed = request['intf-ip'].split('.')
addr = addr_parsed[0] + "." + addr_parsed[1] + "." + addr_parsed[2] + ".0"
network.network_addr = addr
network.network_prefix = int(request['mask'])
global_af.sourced_networks.sourced_network.append(network)
four_byte_as.default_vrf.global_.global_afs.global_af.append(global_af)
instance_as.four_byte_as.append(four_byte_as)
instance.instance_as.append(instance_as)
bgp.instance.append(instance)
the_xml = codec.encode(codec_provider, bgp)
logging.info(the_xml)
if request['delete-config'] == 'off':
crud.create(nc_provider, bgp)
elif request['delete-config'] == 'on':
bgp_instance = bgp.instance['default']
sourced = bgp.instance['default'].instance_as['0'].four_byte_as[
request['bgp-as']].default_vrf.global_.global_afs.global_af[
'ipv4-unicast'].sourced_networks
sn = sourced.sourced_network[addr, int(request['mask'])]
sn.yfilter = YFilter.delete
crud.update(nc_provider, bgp)
return
