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)