def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'excluded_address')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs={}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['low_ipaddress'] = config.get_field_value('low_ipaddress')
inputdict['high_ipaddress'] = config.get_field_value('high_ipaddress')
inputdict['vrf_name'] = config.get_field_value('vrf_name')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath().split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(smodelctx, sdata, dev, id=id, device=dev, parentobj=parentobj, inputdict=inputdict, inputkeydict=inputkeydict, config=config, hopaque=opaque_args)
#Start of Device binding with python bindings
#dhcp_server_object = devices.device.dhcp_server.dhcp_server()
if util.isNotEmpty(inputdict.get('low_ipaddress')):
#dhcp_server_excluded_address_object = devices.device.dhcp_server.excluded_address.excluded_address()
dhcp_server_excluded_address_object = dhcp_server.excluded_address.excluded_address()
dhcp_server_excluded_address_object.low_ipaddress = inputdict.get('low_ipaddress')
dhcp_server_excluded_address_object.high_ipaddress = inputdict.get('high_ipaddress')
dhcp_server_excluded_address_object.vrf_name = inputdict.get('vrf_name')
#End of Device binding
devbindobjs['dhcp_server_excluded_address_object'] = dhcp_server_excluded_address_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(smodelctx, sdata, dev, id=id, device=dev, inputdict=inputdict, inputkeydict=inputkeydict, parentobj=parentobj, config=config, devbindobjs=devbindobjs, hopaque=opaque_args)
#for dev_iterator in dev:
#yang.Sdk.createData(dev_iterator.url,'<dhcp-server/>', sdata.getSession(), True)
dhcp_server_excluded_address_object_payload = dhcp_server_excluded_address_object.getxml(filter=True)
#log('dhcp_server_excluded_address_object_payload: %s' % (dhcp_server_excluded_address_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url+'/l3features:dhcp-server',dhcp_server_excluded_address_object_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'aaa_servers_private')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs={}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['aaa_server_ip'] = config.get_field_value('aaa_server_ip')
inputdict['privilege_level'] = config.get_field_value('privilege_level')
inputdict['privilege_key'] = config.get_field_value('privilege_key')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath().split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(smodelctx, sdata, dev, id=id, device=dev, parentobj=parentobj, inputdict=inputdict, inputkeydict=inputkeydict, config=config, hopaque=opaque_args)
#Start of Device binding with python bindings
#aaa_group_object = aaa_group.aaa_group()
if util.isNotEmpty(inputdict.get('aaa_server_ip')):
aaa_group_aaa_servers_private_object = aaa_group.aaa_servers_private.aaa_servers_private()
aaa_group_aaa_servers_private_object.aaa_server_private = inputdict.get('aaa_server_ip')
aaa_group_aaa_servers_private_object.privilege_level = inputdict.get('privilege_level')
aaa_group_aaa_servers_private_object.privilege_key = inputdict.get('privilege_key')
#End of Device binding
devbindobjs['aaa_group_aaa_servers_private_object'] = aaa_group_aaa_servers_private_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(smodelctx, sdata, dev, id=id, device=dev, inputdict=inputdict, inputkeydict=inputkeydict, parentobj=parentobj, config=config, devbindobjs=devbindobjs, hopaque=opaque_args)
aaa_group_aaa_servers_private_object_payload = aaa_group_aaa_servers_private_object.getxml(filter=True)
log('aaa_group_aaa_servers_private_object_payload: %s' % (aaa_group_aaa_servers_private_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url+'/aaa-group',aaa_group_aaa_servers_private_object_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'destinations')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs={}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['destination_ip_address'] = config.get_field_value('destination_ip_address')
inputdict['port'] = config.get_field_value('port')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath().split('/')[-3].split('=')[1]
#Start of Device binding with python bindings
#legacy_netflow_object = devices.device.legacy_netflow.legacy_netflow()
legacy_netflow_object = legacy_netflow.legacy_netflow()
if util.isNotEmpty(inputdict.get('destination_ip_address')):
#legacy_netflow_destinations_object = devices.device.legacy_netflow.destinations.destinations()
legacy_netflow_destinations_object = legacy_netflow.destinations.destinations()
legacy_netflow_destinations_object.destination_ip_address = inputdict.get('destination_ip_address')
legacy_netflow_destinations_object.port = inputdict.get('port')
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(smodelctx, sdata, dev, id=id, device=dev, parentobj=parentobj, inputdict=inputdict, inputkeydict=inputkeydict, config=config, hopaque=opaque_args)
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(smodelctx, sdata, dev, id=id, device=dev, inputdict=inputdict, inputkeydict=inputkeydict, parentobj=parentobj, config=config, devbindobjs=devbindobjs, hopaque=opaque_args)
legacy_netflow_destinations_object_payload = legacy_netflow_destinations_object.getxml(filter=True)
log('legacy_netflow_destinations_object_payload: %s' % (legacy_netflow_destinations_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url+'/legacy-netflow',legacy_netflow_destinations_object_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'transport_options')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['name'] = config.get_field_value('name')
inputdict['transport_option'] = config.get_field_value(
'transport_option')
inputdict['tcp_options'] = config.get_field_value('tcp_options')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict[
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'] = sdata.getRcPath(
).split('/')[-4].split('=')[1]
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-8].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
dev_pro_name = inputdict['name']
if util.isNotEmpty(inputdict['transport_option']):
if util.isNotEmpty(inputdict['tcp_options']):
dev_pro_name = "collect_transport_%s_%s" % (
inputdict['transport_option'], inputdict['tcp_options'])
else:
dev_pro_name = "collect_transport_%s" % (
inputdict['transport_option'])
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
netflow_object = devices.device.netflow.netflow()
netflow_flow_records_object = devices.device.netflow.flow_records.flow_records(
)
_Gen_obj = getLocalObject(sdata, 'flow-record')
inputdict[
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'] = _Gen_obj.flow_record.name
if util.isNotEmpty(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'
)):
netflow_flow_records_flow_record_object = devices.device.netflow.flow_records.flow_record.flow_record(
)
netflow_flow_records_flow_record_collect_object = devices.device.netflow.flow_records.flow_record.collect.collect(
)
netflow_flow_records_flow_record_collect_transport_object = devices.device.netflow.flow_records.flow_record.collect.transport.transport(
)
if util.isNotEmpty(inputdict.get('name')):
netflow_flow_records_flow_record_collect_transport_transport_options_object = devices.device.netflow.flow_records.flow_record.collect.transport.transport_options.transport_options(
)
netflow_flow_records_flow_record_collect_transport_transport_options_object.name = dev_pro_name
netflow_flow_records_flow_record_collect_transport_transport_options_object.transport_option = inputdict.get(
'transport_option')
netflow_flow_records_flow_record_collect_transport_transport_options_object.tcp_options = inputdict.get(
'tcp_options')
#End of Device binding
devbindobjs[
'netflow_flow_records_flow_record_collect_transport_transport_options_object'] = netflow_flow_records_flow_record_collect_transport_transport_options_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
for dev_iterator in dev:
if not yang.Sdk.dataExists(
dev_iterator.url +
'/l3features:netflow/flow-records/flow-record=%s/collect' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'
)))):
yang.Sdk.createData(
dev_iterator.url +
'/l3features:netflow/flow-records/flow-record=%s' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'
))), '<collect/>', sdata.getSession(), False)
if not yang.Sdk.dataExists(
dev_iterator.url +
'/l3features:netflow/flow-records/flow-record=%s/collect/transport'
%
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'
)))):
yang.Sdk.createData(
dev_iterator.url +
'/l3features:netflow/flow-records/flow-record=%s/collect' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'
))), '<transport/>', sdata.getSession(), False)
netflow_flow_records_flow_record_collect_transport_transport_options_object_payload = netflow_flow_records_flow_record_collect_transport_transport_options_object.getxml(
filter=True)
log('netflow_flow_records_flow_record_collect_transport_transport_options_object_payload: %s'
%
(netflow_flow_records_flow_record_collect_transport_transport_options_object_payload
))
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url +
'/netflow/flow-records/flow-record=%s/collect/transport' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_records_flow_record_name'
))),
netflow_flow_records_flow_record_collect_transport_transport_options_object_payload,
sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'ntp_server')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
#parentobj = None
dev = []
inputkeydict = {}
devbindobjs={}
inputdict = {}
opaque_args = self.opaque_args
vrf = None
rcpath = util.get_parent_rcpath(sdata.getRcPath(),level=2)
xml_output = yang.Sdk.getData(rcpath, '', sdata.getTaskId())
parentobj = util.parseXmlString(xml_output)
if hasattr(parentobj.day1service,'vrf'):
vrf = parentobj.day1service.vrf
# START OF FETCHING THE LEAF PARAMETERS
inputdict['ntp_server_ip'] = config.get_field_value('ntp_server_ip')
inputdict['vrf_name'] = vrf
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath().split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(smodelctx, sdata, dev, id=id, device=dev, parentobj=parentobj, inputdict=inputdict, inputkeydict=inputkeydict, config=config, hopaque=opaque_args)
#Start of Device binding with python bindings
#ntp_object = devices.device.ntp.ntp()
ntp_object = ntp.ntp()
if util.isNotEmpty(inputdict.get('ntp_server_ip')):
#ntp_ntp_server_object = devices.device.ntp.ntp_server.ntp_server()
ntp_ntp_server_object = ntp.ntp_server.ntp_server()
ntp_ntp_server_object.ntp_server_address = inputdict.get('ntp_server_ip')
ntp_ntp_server_object.vrf = inputdict.get('vrf_name')
#End of Device binding
devbindobjs['ntp_ntp_server_object'] = ntp_ntp_server_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(smodelctx, sdata, dev, id=id, device=dev, inputdict=inputdict, inputkeydict=inputkeydict, parentobj=parentobj, config=config, devbindobjs=devbindobjs, hopaque=opaque_args)
ntp_ntp_server_object_payload = ntp_ntp_server_object.getxml(filter=True)
#log('ntp_ntp_server_object_payload: %s' % (ntp_ntp_server_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url+'/basicDeviceConfigs:ntp',ntp_ntp_server_object_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'match_condition')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs={}
inputdict = {}
opaque_args = self.opaque_args
if config.get_field_value('cidr') == "true":
prefix_in = config.get_field_value('cidr_value')
prefix = util.IPPrefix(prefix_in)
ip_address = prefix.address
wildcard = prefix.wildcard
source_ipv4_address = ip_address
source_ipv4_mask = wildcard
else:
source_ipv4_address = config.get_field_value('source_ipv4_address')
source_ipv4_mask = config.get_field_value('source_ipv4_address_mask')
if config.get_field_value('cidr') == "true" and config.get_field_value('cidr_destination_value') !=None:
prefix_in = config.get_field_value('cidr_destination_value')
prefix = util.IPPrefix(prefix_in)
ip_address = prefix.address
wildcard = prefix.wildcard
destination_ipv4_address = ip_address
destination_ipv4_mask = wildcard
else:
destination_ipv4_address = config.get_field_value('destination_ipv4_address')
destination_ipv4_mask = config.get_field_value('destination_ipv4_address_mask')
# START OF FETCHING THE LEAF PARAMETERS
inputdict['sequence_number'] = config.get_field_value('sequence_number')
inputdict['match_condition_name'] = config.get_field_value('match_condition_name')
inputdict['match_packets'] = config.get_field_value('match_packets')
inputdict['source_condition_type'] = config.get_field_value('source_condition_type')
inputdict['source_ipv4_address'] = source_ipv4_address
inputdict['source_ipv4_address_mask'] = source_ipv4_mask
'''
if config.get_field_value('dest_condition_type') is None:
if inputdict['source_condition_type'] == 'host':
inputdict['dest_condition_type'] = 'host'
if inputdict['source_condition_type'] == 'cidr':
inputdict['dest_condition_type'] = 'cidr'
if inputdict['source_condition_type'] == 'any':
inputdict['dest_condition_type'] = None
else:
inputdict['dest_condition_type'] = config.get_field_value('dest_condition_type')
inputdict['cidr_destination_value'] = config.get_field_value('cidr_destination_value')
inputdict['destination_ipv4_address'] = destination_ipv4_address
inputdict['destination_ipv4_address_mask'] = destination_ipv4_mask
'''
inputdict['action'] = config.get_field_value('action')
acl_name = inputdict['action']
if inputdict['source_condition_type'] == 'host':
acl_name = acl_name + ' ' + 'host' + ' '+ inputdict['source_ipv4_address']
if inputdict['source_condition_type'] == "cidr":
acl_name = acl_name + ' ' + inputdict['source_ipv4_address'] + ' ' + inputdict['source_ipv4_address_mask']
if inputdict['source_condition_type'] == "any":
acl_name = acl_name + ' ' + 'any'
#if inputdict['dest_condition_type'] == "host" and inputdict['destination_ipv4_address'] != None:
#acl_name = acl_name + ' ' + 'host' + ' ' + inputdict['destination_ipv4_address']
#if inputdict['destination_ipv4_address'] != None and inputdict['destination_ipv4_address_mask'] !=None:
#acl_name = acl_name + ' ' + inputdict['destination_ipv4_address'] + ' ' + inputdict['destination_ipv4_address_mask']
if inputdict['match_packets']!= None:
acl_name = acl_name + ' ' + inputdict['match_packets']
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_named_access_lists_acl_acl_name'] = sdata.getRcPath().split('/')[-2].split('=')[1]
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath().split('/')[-4].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(smodelctx, sdata, dev, id=id, device=dev, parentobj=parentobj, inputdict=inputdict, inputkeydict=inputkeydict, config=config, hopaque=opaque_args)
#Start of Device binding with python bindings
#access_lists_object = devices.device.access_lists.access_lists()
_Gen_obj = getLocalObject(sdata, 'acl')
inputdict['day1services_day1service_named_access_lists_acl_acl_name'] = _Gen_obj.acl.acl_name
if util.isNotEmpty(inputdict.get('day1services_day1service_named_access_lists_acl_acl_name')):
#access_lists_access_list_object = devices.device.access_lists.access_list.access_list()
#access_lists_access_list_acl_rules_object = devices.device.access_lists.access_list.acl_rules.acl_rules()
if util.isNotEmpty(inputdict.get('match_condition_name')):
#access_lists_access_list_acl_rules_acl_rule_object = devices.device.access_lists.access_list.acl_rules.acl_rule.acl_rule()
access_lists_access_list_acl_rules_acl_rule_object = access_lists.access_list.acl_rules.acl_rule.acl_rule()
#access_lists_access_list_acl_rules_acl_rule_object.name = inputdict.get('match_condition_name')
access_lists_access_list_acl_rules_acl_rule_object.name = acl_name
access_lists_access_list_acl_rules_acl_rule_object.linenumber = inputdict.get('sequence_number')
access_lists_access_list_acl_rules_acl_rule_object.action = inputdict.get('action')
access_lists_access_list_acl_rules_acl_rule_object.source_condition_type = inputdict.get('source_condition_type')
access_lists_access_list_acl_rules_acl_rule_object.source_ip = inputdict.get('source_ipv4_address')
access_lists_access_list_acl_rules_acl_rule_object.source_mask = inputdict.get('source_ipv4_address_mask')
#access_lists_access_list_acl_rules_acl_rule_object.dest_condition_type = inputdict.get('dest_condition_type')
#access_lists_access_list_acl_rules_acl_rule_object.dest_ip = inputdict.get('destination_ipv4_address')
#access_lists_access_list_acl_rules_acl_rule_object.dest_mask = inputdict.get('destination_ipv4_address_mask')
if inputdict.get('match_packets') != "log":
access_lists_access_list_acl_rules_acl_rule_object.match_packets = inputdict.get('match_packets')
else:
access_lists_access_list_acl_rules_acl_rule_object.extra_options = "log"
#End of Device binding
devbindobjs['access_lists_access_list_acl_rules_acl_rule_object'] = access_lists_access_list_acl_rules_acl_rule_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(smodelctx, sdata, dev, id=id, device=dev, inputdict=inputdict, inputkeydict=inputkeydict, parentobj=parentobj, config=config, devbindobjs=devbindobjs, hopaque=opaque_args)
#for dev_iterator in dev:
#yang.Sdk.createData(dev_iterator.url+'/access-lists/access-list=%s'%(util.make_interfacename(inputdict.get('day1services_day1service_named_access_lists_acl_acl_name'))),'<acl-rules/>', sdata.getSession(), True)
access_lists_access_list_acl_rules_acl_rule_object_payload = access_lists_access_list_acl_rules_acl_rule_object.getxml(filter=True)
#log('access_lists_access_list_acl_rules_acl_rule_object_payload: %s' % (access_lists_access_list_acl_rules_acl_rule_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url+'/acl:access-lists/access-list=%s/acl-rules'%(util.make_interfacename(inputdict.get('day1services_day1service_named_access_lists_acl_acl_name'))),access_lists_access_list_acl_rules_acl_rule_object_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'interface')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['if_tag'] = config.get_field_value('if_tag')
inputdict['interface_name'] = config.get_field_value('interface_name')
inputdict['correlate'] = config.get_field_value('correlate')
if inputdict.get('correlate') is None:
inputdict['correlate'] = 'event if_1'
inputdict['variable1'] = config.get_field_value('variable1')
if inputdict.get('variable1') is None:
inputdict['variable1'] = '$_interface_name'
inputdict['variable2'] = config.get_field_value('variable2')
if inputdict.get('variable2') is None:
inputdict['variable2'] = '$_interface_delta_value'
inputdict['variable3'] = config.get_field_value('variable3')
if inputdict.get('variable3') is None:
inputdict['variable3'] = '$_interface_value'
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-5].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#eem_script_object = devices.device.eem_script.eem_script()
eem_script_object = eem_script.eem_script()
#eem_script_eem_if_errors_object = devices.device.eem_script.eem_if_errors.eem_if_errors()
eem_script_eem_if_errors_object = eem_script.eem_if_errors.eem_if_errors(
)
if util.isNotEmpty(inputdict.get('if_tag')):
#eem_script_eem_if_errors_interface_object = devices.device.eem_script.eem_if_errors.interface.interface()
eem_script_eem_if_errors_interface_object = eem_script.eem_if_errors.interface.interface(
)
eem_script_eem_if_errors_interface_object.if_tag = inputdict.get(
'if_tag')
eem_script_eem_if_errors_interface_object.interface_name = inputdict.get(
'interface_name')
eem_script_eem_if_errors_interface_object.correlate = inputdict.get(
'correlate')
eem_script_eem_if_errors_interface_object.variable1 = inputdict.get(
'variable1')
eem_script_eem_if_errors_interface_object.variable2 = inputdict.get(
'variable2')
eem_script_eem_if_errors_interface_object.variable3 = inputdict.get(
'variable3')
#End of Device binding
devbindobjs[
'eem_script_eem_if_errors_interface_object'] = eem_script_eem_if_errors_interface_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
for dev_iterator in dev:
if not yang.Sdk.dataExists(dev_iterator.url +
'/l3features:eem-script'):
yang.Sdk.createData(dev_iterator.url, '<eem-script/>',
sdata.getSession(), False)
#for dev_iterator in dev:
#yang.Sdk.createData(dev_iterator.url+'/eem-script','<eem-if-errors/>', sdata.getSession(), True)
eem_script_eem_if_errors_interface_object_payload = eem_script_eem_if_errors_interface_object.getxml(
filter=True)
#log('eem_script_eem_if_errors_interface_object_payload: %s' % (eem_script_eem_if_errors_interface_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url + '/l3features:eem-script/eem-if-errors',
eem_script_eem_if_errors_interface_object_payload,
sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'acl')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['acl_name'] = config.get_field_value('acl_name')
inputdict['acl_type'] = config.get_field_value('acl_type')
inputdict['remark'] = config.get_field_value('remark')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#access_lists_object = devices.device.access_lists.access_lists()
if util.isNotEmpty(inputdict.get('acl_name')):
#access_lists_access_list_object = devices.device.access_lists.access_list.access_list()
access_lists_access_list_object = access_lists.access_list.access_list(
)
access_lists_access_list_object.name = inputdict.get('acl_name')
access_lists_access_list_object.start_remark = inputdict.get(
'remark')
access_lists_access_list_object.acl_type = inputdict.get(
'acl_type')
#End of Device binding
devbindobjs[
'access_lists_access_list_object'] = access_lists_access_list_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
"""
for dev_iterator in dev:
acl_obj = yang.Sdk.getData(dev_iterator.url,'', sdata.getTaskId())
acl_obj = util.parseXmlString(acl_obj)
print "the acl_rules_obj is: %s"%(acl_obj)
if not hasattr(acl_obj.device, 'access_lists'):
yang.Sdk.createData(dev_iterator.url,'<access-lists/>', sdata.getSession(), True)
"""
access_lists_access_list_object_payload = access_lists_access_list_object.getxml(
filter=True)
#log('access_lists_access_list_object_payload: %s' % (access_lists_access_list_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url + '/acl:access-lists',
access_lists_access_list_object_payload,
sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'local_credential')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['name'] = config.get_field_value('name')
inputdict['password'] = config.get_field_value('password')
inputdict['password_level'] = config.get_field_value('password_level')
inputdict['enable_privilege'] = config.get_field_value(
'enable_privilege')
inputdict['privilege_level'] = config.get_field_value(
'privilege_level')
inputdict['privilege_secret'] = config.get_field_value(
'privilege_secret')
inputdict['secret_level'] = config.get_field_value('secret_level')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#local_credentials_object = devices.device.local_credentials.local_credentials()
local_credentials_object = local_credentials.local_credentials()
if util.isNotEmpty(inputdict.get('name')):
#local_credentials_local_credential_object = devices.device.local_credentials.local_credential.local_credential()
local_credentials_local_credential_object = local_credentials.local_credential.local_credential(
)
local_credentials_local_credential_object.name = inputdict.get(
'name')
local_credentials_local_credential_object.password = inputdict.get(
'password')
local_credentials_local_credential_object.enable_privilege = inputdict.get(
'enable_privilege')
local_credentials_local_credential_object.privilege_level = inputdict.get(
'privilege_level')
if util.isNotEmpty(
local_credentials_local_credential_object.password):
if util.isNotEmpty(inputdict.get('password_level')):
local_credentials_local_credential_object.password_level = inputdict.get(
'password_level')
local_credentials_local_credential_object.secret_password = inputdict.get(
'privilege_secret')
if util.isNotEmpty(
local_credentials_local_credential_object.secret_password):
local_credentials_local_credential_object.enable_secret = True
if util.isNotEmpty(inputdict.get('secret_level')):
local_credentials_local_credential_object.secret_level = inputdict.get(
'secret_level')
#End of Device binding
devbindobjs[
'local_credentials_local_credential_object'] = local_credentials_local_credential_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
#for dev_iterator in dev:
#yang.Sdk.createData(dev_iterator.url,'<local-credentials/>', sdata.getSession(), True)
local_credentials_local_credential_object_payload = local_credentials_local_credential_object.getxml(
filter=True)
#log('local_credentials_local_credential_object_payload: %s' % (local_credentials_local_credential_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url + '/basicDeviceConfigs:local-credentials',
local_credentials_local_credential_object_payload,
sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'snmp_community')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['community_string'] = config.get_field_value(
'community_string')
inputdict['permision_type'] = config.get_field_value('permision_type')
inputdict['acl_name'] = config.get_field_value('acl_name')
inputdict['add_monolith_snmpv3'] = config.get_field_value(
'add_monolith_snmpv3')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#snmp_object = devices.device.snmp.snmp()
snmp_object = snmp.snmp()
if util.isNotEmpty(inputdict.get('community_string')):
#snmp_snmp_community_list_object = devices.device.snmp.snmp_community_list.snmp_community_list()
snmp_snmp_community_list_object = snmp.snmp_community_list.snmp_community_list(
)
snmp_snmp_community_list_object.snmp_string = inputdict.get(
'community_string')
snmp_snmp_community_list_object.permission_type = inputdict.get(
'permision_type')
snmp_snmp_community_list_object.acl = inputdict.get('acl_name')
#End of Device binding
devbindobjs[
'snmp_snmp_community_list_object'] = snmp_snmp_community_list_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
snmp_snmp_community_list_object_payload = snmp_snmp_community_list_object.getxml(
filter=True)
log('snmp_snmp_community_list_object_payload: %s' %
(snmp_snmp_community_list_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url + '/basicDeviceConfigs:snmp',
snmp_snmp_community_list_object_payload,
sdata.getSession(), True)
if util.isNotEmpty(inputdict.get('add_monolith_snmpv3')):
snmpv3_group_monolith_payload = '''
<snmp-groups xmlns="http://anutanetworks.com/basicDeviceConfigs">
<group-name>TATA_SNMP</group-name>
<snmp-versions>
<group-auth-type>priv</group-auth-type>
<snmp-version>v3</snmp-version>
<view-name>TATA-MONITORING-SNMP</view-name>
<group-priviledge>access</group-priviledge>
</snmp-versions>
</snmp-groups>
'''
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url + '/basicDeviceConfigs:snmp',
snmpv3_group_monolith_payload, sdata.getSession(), True)
snmpv3_user_monolith_payload = '''
<snmp-users>
<user>Tcl@M0nolith</user>
<group-name>TATA_SNMP</group-name>
<snmp-version>v3</snmp-version>
<v3-auth-type>md5</v3-auth-type>
<v3-auth-paswd>Tcl4M0nolith</v3-auth-paswd>
<encrpt-type>des</encrpt-type>
<encrpt-paswd>Tcl4M0nolith</encrpt-paswd>
</snmp-users>
'''
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url + '/basicDeviceConfigs:snmp',
snmpv3_user_monolith_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'vty')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
#parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
vrf = None
rcpath = util.get_parent_rcpath(sdata.getRcPath(), level=2)
xml_output = yang.Sdk.getData(rcpath, '', sdata.getTaskId())
parentobj = util.parseXmlString(xml_output)
if hasattr(parentobj.day1service, 'vrf'):
vrf = parentobj.day1service.vrf
# START OF FETCHING THE LEAF PARAMETERS
inputdict['name'] = config.get_field_value('name')
inputdict['timeout_in_sec'] = config.get_field_value('timeout_in_sec')
if inputdict.get('timeout_in_sec') is None:
inputdict['timeout_in_sec'] = '0'
inputdict['timeout_in_min'] = config.get_field_value('timeout_in_min')
if inputdict.get('timeout_in_min') is None:
inputdict['timeout_in_min'] = '30'
inputdict['min_vty'] = config.get_field_value('min_vty')
if inputdict.get('min_vty') is None:
inputdict['min_vty'] = '0'
inputdict['max_vty'] = config.get_field_value('max_vty')
if inputdict.get('max_vty') is None:
inputdict['max_vty'] = '4'
inputdict['transport_type'] = config.get_field_value('transport_type')
if inputdict['transport_type'] is None:
inputdict['transport_type'] = 'telnet ssh'
inputdict['acl'] = config.get_field_value('acl')
inputdict['logging_synchronous'] = config.get_field_value(
'logging_synchronous')
if inputdict.get('logging_synchronous') is None:
inputdict['logging_synchronous'] = 'False'
inputdict['history_size'] = config.get_field_value('history_size')
inputdict['no_privilege_level'] = config.get_field_value(
'no_privilege_level')
inputdict['no_password'] = config.get_field_value('no_password')
inputdict['auth_type'] = config.get_field_value('auth_type')
inputdict['vrf_also'] = config.get_field_value('vrf_also')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#vty_configs_object = devices.device.vty_configs.vty_configs()
vty_configs_object = vty_configs.vty_configs()
if util.isNotEmpty(inputdict.get('name')):
#vty_configs_vty_config_object = devices.device.vty_configs.vty_config.vty_config()
vty_configs_vty_config_object = vty_configs.vty_config.vty_config()
vty_configs_vty_config_object.name = "line vty " + inputdict.get(
'min_vty') + " " + inputdict.get('max_vty')
vty_configs_vty_config_object.min_vty = inputdict.get('min_vty')
vty_configs_vty_config_object.max_vty = inputdict.get('max_vty')
vty_configs_vty_config_object.acl_rule_number = inputdict.get(
'acl')
vty_configs_vty_config_object.timeout = inputdict.get(
'timeout_in_min')
vty_configs_vty_config_object.transport_types_in = inputdict.get(
'transport_type')
vty_configs_vty_config_object.logging_synchronous = inputdict.get(
'logging_synchronous')
vty_configs_vty_config_object.history_size = inputdict.get(
'history_size')
vty_configs_vty_config_object.no_privilege_level = inputdict.get(
'no_privilege_level')
if util.isNotEmpty(inputdict['no_privilege_level']):
vty_configs_vty_config_object.privilege_level._empty_tag = True
vty_configs_vty_config_object.no_password = inputdict.get(
'no_password')
if inputdict.get('vrf_also') == 'true':
vty_configs_vty_config_object.vrf = 'vrf-also'
vty_configs_vty_config_object.auth_type = inputdict.get(
'auth_type')
#End of Device binding
devbindobjs[
'vty_configs_vty_config_object'] = vty_configs_vty_config_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
#for dev_iterator in dev:
#yang.Sdk.createData(dev_iterator.url,'<vty-configs/>', sdata.getSession(), True)
vty_configs_vty_config_object_payload = vty_configs_vty_config_object.getxml(
filter=True)
#log('vty_configs_vty_config_object_payload: %s' % (vty_configs_vty_config_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url + '/basicDeviceConfigs:vty-configs',
vty_configs_vty_config_object_payload, sdata.getSession(),
True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'options')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
rcpath = util.get_parent_rcpath(sdata.getRcPath(), level=1)
xml_output = yang.Sdk.getData(rcpath, '', sdata.getTaskId())
parentobj = util.parseXmlString(xml_output)
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['option'] = config.get_field_value('option')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
if hasattr(parentobj.flow_export, 'name'):
inputdict[
'netflow_flow_exports_flow_export_name'] = parentobj.flow_export.name
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict[
'day1services_day1service_netflow_netflow_flow_exports_flow_export_name'] = sdata.getRcPath(
).split('/')[-2].split('=')[1]
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-6].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#netflow_object = devices.device.netflow.netflow()
netflow_object = netflow.netflow()
#netflow_flow_exports_object = devices.device.netflow.flow_exports.flow_exports()
netflow_flow_exports_object = netflow.flow_exports.flow_exports()
if util.isNotEmpty(
inputdict.get('netflow_flow_exports_flow_export_name')):
#netflow_flow_exports_flow_export_object = devices.device.netflow.flow_exports.flow_export.flow_export()
netflow_flow_exports_flow_export_object = netflow.flow_exports.flow_export.flow_export(
)
if util.isNotEmpty(inputdict.get('option')):
#netflow_flow_exports_flow_export_options_object = devices.device.netflow.flow_exports.flow_export.options.options()
netflow_flow_exports_flow_export_options_object = netflow.flow_exports.flow_export.options.options(
)
netflow_flow_exports_flow_export_options_object.option = inputdict.get(
'option')
#End of Device binding
devbindobjs[
'netflow_flow_exports_flow_export_options_object'] = netflow_flow_exports_flow_export_options_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
netflow_flow_exports_flow_export_options_object_payload = netflow_flow_exports_flow_export_options_object.getxml(
filter=True)
log('netflow_flow_exports_flow_export_options_object_payload: %s' %
(netflow_flow_exports_flow_export_options_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url +
'/l3features:netflow/flow-exports/flow-export=%s' %
(util.make_interfacename(
inputdict.get('netflow_flow_exports_flow_export_name'))),
netflow_flow_exports_flow_export_options_object_payload,
sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'class_map')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['name'] = config.get_field_value('name')
inputdict['description'] = config.get_field_value('description')
inputdict['match_type'] = config.get_field_value('match_type')
# END OF FETCHING THE LEAF PARAMETERS
class_name = inputdict['name']
description = inputdict['description']
match_type = inputdict['match_type']
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
cls_map_obj = class_maps.class_map.class_map()
cls_map_obj.name = class_name
if util.isNotEmpty(description):
cls_map_obj.description = description
if util.isNotEmpty(match_type):
cls_map_obj.match_type = match_type
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url + "/class-maps",
cls_map_obj.getxml(filter=True),
sdata.getSession())
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'snmp_mib')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['mib-persistence'] = config.get_field_value(
'mib_persistence')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#snmp_object = devices.device.snmp.snmp()
snmp_object = snmp.snmp()
if util.isNotEmpty(inputdict.get('mib-persistence')):
#snmp_snmp_mib_object = devices.device.snmp.snmp_mib.snmp_mib()
snmp_snmp_mib_object = snmp.snmp_mib.snmp_mib()
snmp_snmp_mib_object.mib_persistence = inputdict.get(
'mib-persistence')
#End of Device binding
devbindobjs['snmp_snmp_mib_object'] = snmp_snmp_mib_object
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Use the custom method to process/create payload
snmp_snmp_mib_object_payload = snmp_snmp_mib_object.getxml(filter=True)
log('snmp_snmp_traps_object_payload: %s' %
(snmp_snmp_mib_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url + '/basicDeviceConfigs:snmp',
snmp_snmp_mib_object_payload,
sdata.getSession(), True)
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'flow_record')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs={}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['name'] = config.get_field_value('name')
inputdict['record_type'] = config.get_field_value('record_type')
inputdict['description'] = config.get_field_value('description')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath().split('/')[-5].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(smodelctx, sdata, dev, id=id, device=dev, parentobj=parentobj, inputdict=inputdict, inputkeydict=inputkeydict, config=config, hopaque=opaque_args)
#Start of Device binding with python bindings
#netflow_object = devices.device.netflow.netflow()
netflow_object = netflow.netflow()
#netflow_flow_records_object = devices.device.netflow.flow_records.flow_records()
netflow_flow_records_object = netflow.flow_records.flow_records()
if util.isNotEmpty(inputdict.get('name')):
#netflow_flow_records_flow_record_object = devices.device.netflow.flow_records.flow_record.flow_record()
netflow_flow_records_flow_record_object = netflow.flow_records.flow_record.flow_record()
netflow_flow_records_flow_record_object.name = inputdict.get('name')
netflow_flow_records_flow_record_object.description = inputdict.get('description')
netflow_flow_records_flow_record_object.record_type = inputdict.get('record_type')
#End of Device binding
devbindobjs['netflow_flow_records_flow_record_object'] = netflow_flow_records_flow_record_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(smodelctx, sdata, dev, id=id, device=dev, inputdict=inputdict, inputkeydict=inputkeydict, parentobj=parentobj, config=config, devbindobjs=devbindobjs, hopaque=opaque_args)
for dev_iterator in dev:
if dev_iterator.device.get_field_value('netflow') == None:
yang.Sdk.createData(dev_iterator.url,'<netflow/>', sdata.getSession(), True)
if not yang.Sdk.dataExists(dev_iterator.url+'/l3features:netflow/flow-records'):
yang.Sdk.createData(dev_iterator.url+'/l3features:netflow','<flow-records/>', sdata.getSession(), False)
netflow_flow_records_flow_record_object_payload = netflow_flow_records_flow_record_object.getxml(filter=True)
log('netflow_flow_records_flow_record_object_payload: %s' % (netflow_flow_records_flow_record_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url+'/l3features:netflow/flow-records',netflow_flow_records_flow_record_object_payload, sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'timeout')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['timeout_type'] = config.get_field_value('timeout_type')
inputdict['timeout_value'] = config.get_field_value('timeout_value')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict[
'day1services_day1service_netflow_netflow_flow_monitors_flow_monitor_name'] = sdata.getRcPath(
).split('/')[-3].split('=')[1]
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-7].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
netflow_object = devices.device.netflow.netflow()
netflow_flow_monitors_object = devices.device.netflow.flow_monitors.flow_monitors(
)
_Gen_obj = getLocalObject(sdata, 'flow-monitor')
inputdict[
'day1services_day1service_netflow_netflow_flow_monitors_flow_monitor_name'] = _Gen_obj.flow_monitor.name
if util.isNotEmpty(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_monitors_flow_monitor_name'
)):
netflow_flow_monitors_flow_monitor_object = devices.device.netflow.flow_monitors.flow_monitor.flow_monitor(
)
netflow_flow_monitors_flow_monitor_cache_object = devices.device.netflow.flow_monitors.flow_monitor.cache.cache(
)
if util.isNotEmpty(inputdict.get('timeout_type')):
netflow_flow_monitors_flow_monitor_cache_timeout_object = devices.device.netflow.flow_monitors.flow_monitor.cache.timeout.timeout(
)
netflow_flow_monitors_flow_monitor_cache_timeout_object.timeout_type = inputdict.get(
'timeout_type')
netflow_flow_monitors_flow_monitor_cache_timeout_object.timeout_value = inputdict.get(
'timeout_value')
#End of Device binding
devbindobjs[
'netflow_flow_monitors_flow_monitor_cache_timeout_object'] = netflow_flow_monitors_flow_monitor_cache_timeout_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
for dev_iterator in dev:
if not yang.Sdk.dataExists(
dev_iterator.url +
'/l3features:netflow/flow-monitors/flow-monitor=%s' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_monitors_flow_monitor_name'
)))):
yang.Sdk.createData(
dev_iterator.url +
'/l3features:netflow/flow-monitors/flow-monitor=%s' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_monitors_flow_monitor_name'
))), '<cache/>', sdata.getSession(), False)
netflow_flow_monitors_flow_monitor_cache_timeout_object_payload = netflow_flow_monitors_flow_monitor_cache_timeout_object.getxml(
filter=True)
log('netflow_flow_monitors_flow_monitor_cache_timeout_object_payload: %s'
%
(netflow_flow_monitors_flow_monitor_cache_timeout_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(
dev_iterator.url +
'/l3features:netflow/flow-monitors/flow-monitor=%s/cache' %
(util.make_interfacename(
inputdict.get(
'day1services_day1service_netflow_netflow_flow_monitors_flow_monitor_name'
))),
netflow_flow_monitors_flow_monitor_cache_timeout_object_payload,
sdata.getSession(), True)
def create(self, id, sdata):
sdata.getSession().addYangSessionPreReserveProcessor(
self.create_pre_processor)
#Fetch Local Config Object
config = getCurrentObjectConfig(id, sdata, 'clock')
#Fetch Service Model Context Object
smodelctx = None
#Fetch Parent Object
parentobj = None
dev = []
inputkeydict = {}
devbindobjs = {}
inputdict = {}
opaque_args = self.opaque_args
# START OF FETCHING THE LEAF PARAMETERS
inputdict['clock_time_zone'] = config.get_field_value(
'clock_time_zone')
inputdict['hours'] = config.get_field_value('hours')
inputdict['minutes'] = config.get_field_value('minutes')
# END OF FETCHING THE LEAF PARAMETERS
_Gen_obj = getLocalObject(sdata, 'day1service')
device_mgmt_ip_address = _Gen_obj.day1service.device_ip
#Fetch Device Object
dev = getDeviceObject(device_mgmt_ip_address, sdata)
# START OF FETCHING THE PARENT KEY LEAF PARAMETERS
inputkeydict['day1services_day1service_device_ip'] = sdata.getRcPath(
).split('/')[-2].split('=')[1]
# END OF FETCHING THE PARENT KEY LEAF PARAMETERS
#Use the custom methods to process the data
service_customization.ServiceDataCustomization.process_service_create_data(
smodelctx,
sdata,
dev,
id=id,
device=dev,
parentobj=parentobj,
inputdict=inputdict,
inputkeydict=inputkeydict,
config=config,
hopaque=opaque_args)
#Start of Device binding with python bindings
#clock_object = devices.device.clock.clock()
clock_object = clock.clock()
#Handle UTC 0 0 Timezone
timezone_list = inputdict.get('clock_time_zone').split(' ')
if len(timezone_list) == 3:
clock_timezone = timezone_list[0]
clock_hours = timezone_list[1]
clock_minutes = timezone_list[2]
clock_object.timezone = clock_timezone
clock_object.hours = clock_hours
clock_object.minutes = clock_minutes
else:
if util.isNotEmpty(inputdict.get('clock_time_zone')):
clock_object.timezone = inputdict.get('clock_time_zone')
if util.isNotEmpty(inputdict.get('hours')):
clock_object.hours = inputdict.get('hours')
if util.isNotEmpty(inputdict.get('minutes')):
clock_object.hours = inputdict.get('minutes')
#End of Device binding
devbindobjs['clock_object'] = clock_object
#Use the custom method to process/create payload
service_customization.ServiceDataCustomization.process_service_device_bindings(
smodelctx,
sdata,
dev,
id=id,
device=dev,
inputdict=inputdict,
inputkeydict=inputkeydict,
parentobj=parentobj,
config=config,
devbindobjs=devbindobjs,
hopaque=opaque_args)
clock_object_payload = clock_object.getxml(filter=True)
#log('clock_object_payload: %s' % (clock_object_payload))
for dev_iterator in dev:
yang.Sdk.createData(dev_iterator.url + '', clock_object_payload,
sdata.getSession(), True)
