transformer

var DbToYang_intf_admin_status_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_admin_status_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_intf_admin_status_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}
	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_intf_admin_status_xfmr Interface not found : ", inParams.key)
		return result, errors.New("Interface not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	adminStatus, ok := prtInst.Field[PORT_ADMIN_STATUS]
	var status ocbinds.E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus
	if ok {
		if adminStatus == "up" {
			status = ocbinds.OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UP
		} else {
			status = ocbinds.OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_DOWN
		}
		result["admin-status"] = ocbinds.E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus.ΛMap(status)["E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus"][int64(status)].Name
	} else {
		log.Info("Admin status field not found in DB")
	}

	return result, err
}

var DbToYang_intf_enabled_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_enabled_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}

	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_intf_enabled_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}

	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_intf_enabled_xfmr Interface not found : ", inParams.key)
		return result, errors.New("Interface not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	adminStatus, ok := prtInst.Field[PORT_ADMIN_STATUS]
	if ok {
		if adminStatus == "up" {
			result["enabled"] = true
		} else {
			result["enabled"] = false
		}
	} else {
		log.Info("Admin status field not found in DB")
	}
	return result, err
}

var DbToYang_intf_eth_auto_neg_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_eth_auto_neg_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}
	if IntfTypeEthernet != intfType {
		return result, nil
	}
	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	pTbl := data[tblName]
	prtInst := pTbl[inParams.key]
	autoNeg, ok := prtInst.Field[PORT_AUTONEG]
	if ok {
		if autoNeg == "on" || autoNeg == "true" {
			result["auto-negotiate"] = true
		} else {
			result["auto-negotiate"] = false
		}
	} else {
		log.Info("auto-negotiate field not found in DB")
	}
	return result, err
}

var DbToYang_intf_eth_port_speed_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]
	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_eth_port_speed_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}

	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	pTbl := data[tblName]
	prtInst := pTbl[inParams.key]
	speed, ok := prtInst.Field[PORT_SPEED]
	portSpeed := ocbinds.OpenconfigIfEthernet_ETHERNET_SPEED_UNSET
	if ok {
		portSpeed, err = getDbToYangSpeed(speed)
		result["port-speed"] = ocbinds.E_OpenconfigIfEthernet_ETHERNET_SPEED.ΛMap(portSpeed)["E_OpenconfigIfEthernet_ETHERNET_SPEED"][int64(portSpeed)].Name
	} else {
		log.Info("Speed field not found in DB")
	}

	return result, err
}

var DbToYang_intf_mtu_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	var err error
	result := make(map[string]interface{})

	data := (*inParams.dbDataMap)[inParams.curDb]

	intfType, _, ierr := getIntfTypeByName(inParams.key)
	if intfType == IntfTypeUnset || ierr != nil {
		log.Info("DbToYang_intf_mtu_xfmr - Invalid interface type IntfTypeUnset")
		return result, errors.New("Invalid interface type IntfTypeUnset")
	}

	intTbl := IntfTypeTblMap[intfType]

	tblName, _ := getPortTableNameByDBId(intTbl, inParams.curDb)
	if _, ok := data[tblName]; !ok {
		log.Info("DbToYang_intf_mtu_xfmr table not found : ", tblName)
		return result, errors.New("table not found : " + tblName)
	}

	pTbl := data[tblName]
	if _, ok := pTbl[inParams.key]; !ok {
		log.Info("DbToYang_intf_mtu_xfmr Interface not found : ", inParams.key)
		return result, errors.New("Interface not found : " + inParams.key)
	}
	prtInst := pTbl[inParams.key]
	mtuStr, ok := prtInst.Field["mtu"]
	if ok {
		mtuVal, err := strconv.ParseUint(mtuStr, 10, 16)
		if err != nil {
			return result, err
		}
		result["mtu"] = mtuVal
	}
	return result, err
}

var DbToYang_ipv6_enabled_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	if log.V(3) {
		log.Info("Entering DbToYang_ipv6_enabled_xfmr")
	}
	res_map := make(map[string]interface{})

	if log.V(3) {
		log.Info("DbToYang_ipv6_enabled_xfmr, inParams.key ", inParams.key)
	}
	pathInfo := NewPathInfo(inParams.uri)
	ifName := pathInfo.Var("name")

	ifUIName := &ifName
	log.Info("Interface Name = ", *ifUIName)

	intfType, _, _ := getIntfTypeByName(inParams.key)

	intTbl := IntfTypeTblMap[intfType]
	tblName, _ := getIntfTableNameByDBId(intTbl, inParams.curDb)

	data := (*inParams.dbDataMap)[inParams.curDb]

	res_map["enabled"] = false
	ipv6_status, ok := data[tblName][inParams.key].Field["ipv6_use_link_local_only"]

	if ok && ipv6_status == "enable" {
		res_map["enabled"] = true
	}
	return res_map, nil
}

var DbToYang_subif_index_xfmr FieldXfmrDbtoYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	res_map := make(map[string]interface{})

	pathInfo := NewPathInfo(inParams.uri)
	id := pathInfo.Var("index")
	log.Info("DbToYang_subif_index_xfmr: Sub-interface Index = ", id)
	i64, _ := strconv.ParseUint(id, 10, 32)
	i32 := uint32(i64)
	if i32 != 0 {
		err_str := "Subinterfaces not supported"
		return res_map, tlerr.NotSupported(err_str)
	}
	res_map["index"] = i64
	return res_map, nil
}

var YangToDb_intf_enabled_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	intfsObj := getIntfsRoot(inParams.ygRoot)
	if intfsObj == nil || len(intfsObj.Interface) < 1 {
		return res_map, nil
	}

	enabled, _ := inParams.param.(*bool)
	var enStr string
	if *enabled {
		enStr = "up"
	} else {
		enStr = "down"
	}
	res_map[PORT_ADMIN_STATUS] = enStr

	return res_map, nil
}

var YangToDb_intf_mtu_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var ifName string
	intfsObj := getIntfsRoot(inParams.ygRoot)
	if intfsObj == nil || len(intfsObj.Interface) < 1 {
		return res_map, nil
	} else {
		for infK := range intfsObj.Interface {
			ifName = infK
		}
	}
	intfType, _, _ := getIntfTypeByName(ifName)

	if inParams.oper == DELETE {
		log.Infof("Updating the Interface: %s with default MTU", ifName)

		err := updateDefaultMtu(&inParams, &ifName, intfType, res_map)
		if err != nil {
			log.Errorf("Updating Default MTU for Interface: %s failed", ifName)
			return res_map, err
		}
		return res_map, nil
	}

	intfTypeVal, _ := inParams.param.(*uint16)
	intTypeValStr := strconv.FormatUint(uint64(*intfTypeVal), 10)

	res_map["mtu"] = intTypeValStr
	return res_map, nil
}

var YangToDb_ipv6_enabled_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	if log.V(3) {
		log.Info("Entering YangToDb_ipv6_enabled_xfmr")
	}
	var err error
	res_map := make(map[string]string)
	pathInfo := NewPathInfo(inParams.uri)
	ifUIName := pathInfo.Var("name")

	intfType, _, ierr := getIntfTypeByName(ifUIName)
	if ierr != nil || intfType == IntfTypeUnset {
		return res_map, errors.New("YangToDb_ipv6_enabled_xfmr, Error: Unsupported Interface: " + ifUIName)
	}

	if ifUIName == "" {
		errStr := "Interface KEY not present"
		log.Info("YangToDb_ipv6_enabled_xfmr: " + errStr)
		return res_map, errors.New(errStr)
	}

	if inParams.param == nil {
		return res_map, err
	}

	if len(pathInfo.Vars) < 2 {
		return res_map, errors.New("YangToDb_ipv6_enabled_xfmr, Error: Invalid Key length")
	}

	if log.V(3) {
		log.Info("YangToDb_ipv6_enabled_xfmr, inParams.key: ", inParams.key)
	}

	ifName := &ifUIName

	intTbl := IntfTypeTblMap[intfType]
	tblName := intTbl.cfgDb.intfTN
	ipMap, _ := getIntfIpByName(inParams.d, tblName, *ifName, true, true, "")
	var enStr string
	subOpMap := make(map[db.DBNum]map[string]map[string]db.Value)
	subOpTblMap := make(map[string]map[string]db.Value)
	field_map := make(map[string]db.Value)
	res_values := db.Value{Field: map[string]string{}}
	IntfMap := make(map[string]string)

	enabled, _ := inParams.param.(*bool)
	if *enabled {
		enStr = "enable"
	} else {
		enStr = "disable"
	}

	IntfMapObj, err := inParams.d.GetEntry(&db.TableSpec{Name: tblName}, db.Key{Comp: []string{*ifName}})
	if err == nil || IntfMapObj.IsPopulated() {
		IntfMap = IntfMapObj.Field
	}
	val, fieldExists := IntfMap["ipv6_use_link_local_only"]
	if fieldExists && val == enStr {

		log.Info("IPv6 is already %s.", enStr)
		return nil, nil
	}

	res_map["ipv6_use_link_local_only"] = enStr
	if log.V(3) {
		log.Info("YangToDb_ipv6_enabled_xfmr, res_map: ", res_map)
	}

	if enStr == "disable" {

		if len(IntfMap) == 0 {
			return nil, nil
		}

		keys := make([]string, 0, len(IntfMap))
		for k := range IntfMap {
			keys = append(keys, k)
		}
		check_keys := []string{"NULL", "ipv6_use_link_local_only"}
		sort.Strings(keys)

		if !((reflect.DeepEqual(keys, check_keys) || reflect.DeepEqual(keys, check_keys[1:])) && len(ipMap) == 0) {

			if !fieldExists {

				return nil, nil
			}
			log.Info("YangToDb_ipv6_enabled_xfmr, deleting ipv6_use_link_local_only field")

			(&res_values).Set("ipv6_use_link_local_only", enStr)
		}
		field_map[*ifName] = res_values
		subOpTblMap[tblName] = field_map
		subOpMap[db.ConfigDB] = subOpTblMap
		inParams.subOpDataMap[DELETE] = &subOpMap
		if log.V(3) {
			log.Info("YangToDb_ipv6_enabled_xfmr, subOpMap: ", subOpMap)
		}
		return nil, nil
	}
	return res_map, nil
}

var YangToDb_subif_index_xfmr FieldXfmrYangToDb = func(inParams XfmrParams) (map[string]string, error) {
	res_map := make(map[string]string)
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	uriIfName := pathInfo.Var("name")
	log.Info(uriIfName)
	ifName := uriIfName

	res_map["parent"] = ifName

	log.Info("YangToDb_subif_index_xfmr: res_map:", res_map)
	return res_map, err
}

var DbToYang_intf_subintfs_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	if log.V(3) {
		log.Info("Entering DbToYang_intf_subintfs_xfmr")
	}
	var idx string

	idx = inParams.key
	var i32 uint32
	i32 = 0

	rmap := make(map[string]interface{})
	var err error
	i64, _ := strconv.ParseUint(idx, 10, 32)
	i32 = uint32(i64)
	if i32 != 0 {
		log.Info("DbToYang_intf_subintfs_xfmr - rmap ", rmap)
		err_str := "Subinterfaces not supported"
		return rmap, tlerr.NotSupported(err_str)
	}
	rmap["index"] = i64
	log.Info("DbToYang_intf_subintfs_xfmr rmap ", rmap)
	return rmap, err
}

var DbToYang_intf_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {

	if log.V(3) {
		log.Info("Entering DbToYang_intf_tbl_key_xfmr")
	}
	res_map := make(map[string]interface{})

	pathInfo := NewPathInfo(inParams.uri)
	reqpathInfo := NewPathInfo(inParams.requestUri)
	requestUriPath := reqpathInfo.YangPath

	log.Infof("DbToYang_intf_tbl_key_xfmr: inParams.uri: %s, pathInfo: %s, inParams.requestUri: %s", inParams.uri, pathInfo, requestUriPath)
	idx := reqpathInfo.Var("index")
	var i32 uint32
	i32 = 0

	if idx != "" {
		i64, _ := strconv.ParseUint(idx, 10, 32)
		i32 = uint32(i64)
	}

	log.Infof("DbToYang_intf_tbl_key_xfmr: i32: %s", i32)

	if i32 != 0 {
		err_str := "Subinterfaces not supported"
		return res_map, tlerr.NotSupported(err_str)
	}
	log.Info("DbToYang_intf_tbl_key_xfmr: Interface Name = ", inParams.key)
	res_map["name"] = inParams.key

	return res_map, nil
}

var DbToYang_subintf_ip_addr_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	if log.V(3) {
		log.Info("Entering DbToYang_subintf_ip_addr_key_xfmr")
	}
	rmap := make(map[string]interface{})
	return rmap, nil
}

var DbToYang_subintf_ipv6_tbl_key_xfmr KeyXfmrDbToYang = func(inParams XfmrParams) (map[string]interface{}, error) {
	if log.V(3) {
		log.Info("Entering DbToYang_subintf_ipv6_tbl_key_xfmr")
	}

	rmap := make(map[string]interface{})
	return rmap, nil
}

var YangToDb_intf_subintfs_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var subintf_key string
	var err error
	var i32 uint32
	i32 = 0

	log.Info("YangToDb_intf_subintfs_xfmr - inParams.uri ", inParams.uri)

	pathInfo := NewPathInfo(inParams.uri)
	ifName := pathInfo.Var("name")
	if ifName == "*" {
		return ifName, nil
	}

	intfType, _, ierr := getIntfTypeByName(ifName)
	if intfType == IntfTypeUnset || ierr != nil {
		return ifName, errors.New("Invalid interface type IntfTypeUnset")
	}

	idx := pathInfo.Var("index")

	if idx != "" {
		i64, _ := strconv.ParseUint(idx, 10, 32)
		i32 = uint32(i64)
	}

	log.Info("YangToDb_intf_subintfs_xfmr: i32: %s", i32)

	if i32 != 0 {
		err_str := "Subinterfaces not supported"
		return subintf_key, tlerr.NotSupported(err_str)
	}
	subintf_key = idx

	log.Info("YangToDb_intf_subintfs_xfmr - return subintf_key ", subintf_key)
	return subintf_key, err
}

var YangToDb_intf_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	var err error

	pathInfo := NewPathInfo(inParams.uri)
	reqpathInfo := NewPathInfo(inParams.requestUri)
	requestUriPath := reqpathInfo.YangPath

	log.Infof("YangToDb_intf_tbl_key_xfmr: inParams.uri: %s, pathInfo: %s, inParams.requestUri: %s", inParams.uri, pathInfo, requestUriPath)

	ifName := pathInfo.Var("name")
	idx := reqpathInfo.Var("index")
	var i32 uint32
	i32 = 0

	if idx != "" {
		i64, _ := strconv.ParseUint(idx, 10, 32)
		i32 = uint32(i64)
	}

	log.Infof("YangToDb_intf_tbl_key_xfmr: i32: %s", i32)

	if i32 != 0 {
		err_str := "Subinterfaces not supported"
		return ifName, tlerr.NotSupported(err_str)
	}

	if ifName == "*" {
		return ifName, nil
	}

	if ifName != "" {
		log.Info("YangToDb_intf_tbl_key_xfmr: ifName: ", ifName)
		intfType, _, ierr := getIntfTypeByName(ifName)
		if ierr != nil {
			log.Errorf("Extracting Interface type for Interface: %s failed!", ifName)
			return "", tlerr.New(ierr.Error())
		}
		err = performIfNameKeyXfmrOp(&inParams, &requestUriPath, &ifName, intfType, i32)
		if err != nil {
			return "", tlerr.InvalidArgsError{Format: err.Error()}
		}
	}
	return ifName, err
}

var YangToDb_subintf_ip_addr_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	if log.V(3) {
		log.Info("Entering YangToDb_subintf_ip_addr_key_xfmr")
	}
	var err error
	var inst_key string
	pathInfo := NewPathInfo(inParams.uri)
	inst_key = pathInfo.Var("ip")
	log.Infof("URI:%v Interface IP:%v", inParams.uri, inst_key)
	return inst_key, err
}

var YangToDb_subintf_ipv6_tbl_key_xfmr KeyXfmrYangToDb = func(inParams XfmrParams) (string, error) {
	if log.V(3) {
		log.Info("Entering YangToDb_subintf_ipv6_tbl_key_xfmr")
	}

	var err error
	var inst_key string
	pathInfo := NewPathInfo(inParams.uri)
	ifName := pathInfo.Var("name")

	if log.V(3) {
		log.Info("inParams.requestUri: ", inParams.requestUri)
	}
	inst_key = ifName
	log.Info("Exiting YangToDb_subintf_ipv6_tbl_key_xfmr, key ", inst_key)
	return inst_key, err
}

var DbToYangPath_sflow_collector_path_xfmr PathXfmrDbToYangFunc = func(params XfmrDbToYgPathParams) error {
	log.V(3).Info("DbToYangPath_sflow_collector fmr: tbl:", params.tblName)
	sflowCollRoot := "/openconfig-sampling-sflow:sampling/sflow/collectors/collector"

	if params.tblName != SFLOW_COL_TBL {
		oper_err := errors.New("wrong config DB table sent")
		log.Errorf("Sflow collector Path-xfmr: table name %s not in sflow view", params.tblName)
		return oper_err
	} else {
		if len(params.tblKeyComp) > 0 {
			key_parts := strings.Split(params.tblKeyComp[0], "_")
			if len(key_parts) != 3 {
				oper_err := errors.New("Invalid key " + params.tblKeyComp[0])
				log.Errorf("sflow_collector_path_xfmr: Invalid Key  %s", params.tblKeyComp[0])
				return oper_err
			}
			params.ygPathKeys[sflowCollRoot+"/address"] = key_parts[0]
			params.ygPathKeys[sflowCollRoot+"/port"] = key_parts[1]
			params.ygPathKeys[sflowCollRoot+"/network-instance"] = key_parts[2]
		} else {
			oper_err := errors.New("Missing DB key.")
			log.Errorf("Missing DB Key")
			return oper_err
		}
	}
	log.V(3).Info("DbToYangPath sflow_collector  ygPathKeys: ", params.ygPathKeys)

	return nil
}

var DbToYangPath_sflow_interface_path_xfmr PathXfmrDbToYangFunc = func(params XfmrDbToYgPathParams) error {
	log.V(3).Info("DbToYangPath_sflow_interface fmr: tbl:", params.tblName)
	sflowCollRoot := "/openconfig-sampling-sflow:sampling/sflow/interfaces/interface"

	if params.tblName != SFLOW_SESS_TBL {
		oper_err := errors.New("wrong config DB table sent")
		log.Errorf("Sflow interface Path-xfmr: table name %s not in sflow view", params.tblName)
		return oper_err
	} else {
		if len(params.tblKeyComp) > 0 {
			params.ygPathKeys[sflowCollRoot+"/name"] = params.tblKeyComp[0]
		} else {
			oper_err := errors.New("Missing DB key.")
			log.Errorf("Missing DB Key")
			return oper_err
		}
	}
	log.V(3).Info("DbToYangPath sflow_interface  ygPathKeys: ", params.ygPathKeys)

	return nil
}

var DbToYang_intf_eth_port_config_xfmr SubTreeXfmrDbToYang = func(inParams XfmrParams) error {
	var err error
	intfsObj := getIntfsRoot(inParams.ygRoot)
	pathInfo := NewPathInfo(inParams.uri)
	uriIfName := pathInfo.Var("name")
	ifName := uriIfName

	intfType, _, err := getIntfTypeByName(ifName)
	if err != nil {
		errStr := "Invalid Interface"
		err = tlerr.InvalidArgsError{Format: errStr}
		return err
	}
	intTbl := IntfTypeTblMap[intfType]
	tblName := intTbl.cfgDb.portTN
	entry, dbErr := inParams.dbs[db.ConfigDB].GetEntry(&db.TableSpec{Name: tblName}, db.Key{Comp: []string{ifName}})
	if dbErr != nil {
		errStr := "Invalid Interface"
		err = tlerr.InvalidArgsError{Format: errStr}
		return err
	}
	targetUriPath := pathInfo.YangPath
	if strings.HasPrefix(targetUriPath, "/openconfig-interfaces:interfaces/interface/openconfig-if-ethernet:ethernet/config") {
		get_cfg_obj := false
		var intfObj *ocbinds.OpenconfigInterfaces_Interfaces_Interface
		if intfsObj != nil && intfsObj.Interface != nil && len(intfsObj.Interface) > 0 {
			var ok bool = false
			if intfObj, ok = intfsObj.Interface[uriIfName]; !ok {
				intfObj, _ = intfsObj.NewInterface(uriIfName)
			}
			ygot.BuildEmptyTree(intfObj)
		} else {
			ygot.BuildEmptyTree(intfsObj)
			intfObj, _ = intfsObj.NewInterface(uriIfName)
			ygot.BuildEmptyTree(intfObj)
		}
		ygot.BuildEmptyTree(intfObj.Ethernet)
		ygot.BuildEmptyTree(intfObj.Ethernet.Config)

		if targetUriPath == "/openconfig-interfaces:interfaces/interface/openconfig-if-ethernet:ethernet/config" {
			get_cfg_obj = true
		}
		var errStr string

		if entry.IsPopulated() {
			if get_cfg_obj || targetUriPath == "/openconfig-interfaces:interfaces/interface/openconfig-if-ethernet:ethernet/config/auto-negotiate" {
				autoNeg, ok := entry.Field[PORT_AUTONEG]
				if ok {
					var oc_auto_neg bool
					if autoNeg == "on" || autoNeg == "true" {
						oc_auto_neg = true
					} else {
						oc_auto_neg = false
					}
					intfObj.Ethernet.Config.AutoNegotiate = &oc_auto_neg
				} else {
					errStr = "auto-negotiate not set"
				}
			}
			if get_cfg_obj || targetUriPath == "/openconfig-interfaces:interfaces/interface/openconfig-if-ethernet:ethernet/config/port-speed" {
				speed, ok := entry.Field[PORT_SPEED]
				portSpeed := ocbinds.OpenconfigIfEthernet_ETHERNET_SPEED_UNSET
				if ok {
					portSpeed, err = getDbToYangSpeed(speed)
					intfObj.Ethernet.Config.PortSpeed = portSpeed
				} else {
					errStr = "port-speed not set"
				}
			}

		} else {
			errStr = "Attribute not set"
		}
		if !get_cfg_obj && errStr != "" {
			err = tlerr.InvalidArgsError{Format: errStr}
		}
	}

	return err
}

var DbToYang_intf_ip_addr_xfmr SubTreeXfmrDbToYang = func(inParams XfmrParams) error {
	var err error
	intfsObj := getIntfsRoot(inParams.ygRoot)
	pathInfo := NewPathInfo(inParams.uri)
	uriIfName := pathInfo.Var("name")
	ifName := uriIfName

	targetUriPath := pathInfo.YangPath
	log.Infof("DbToYang_intf_ip_addr_xfmr: uri:%v path:%v", inParams.uri, targetUriPath)

	reqPathInfo := NewPathInfo(inParams.requestUri)
	requestUriPath := reqPathInfo.YangPath
	var reqUriIfName string = reqPathInfo.Var("name")

	if (inParams.oper == GET) &&
		((requestUriPath == "/openconfig-interfaces:interfaces" || requestUriPath == "/openconfig-interfaces:interfaces/interface") && reqUriIfName == "") {
		_, present := inParams.txCache.Load("interface_subinterface_ip_read_once")
		if present {
			log.Info("DbToYang_intf_ip_addr_xfmr, top level GET, interface_subinterface_ip_read_once already cached")
			return nil
		}

		intfTypeList := [1]E_InterfaceType{IntfTypeEthernet}

		for i := 0; i < len(intfTypeList); i++ {
			intfTbl := IntfTypeTblMap[intfTypeList[i]]

			handleAllIntfIPGetForTable(inParams, intfTbl.cfgDb.intfTN, false)
		}

		handleAllIntfIPGetForTable(inParams, "INTF_TABLE", true)

		inParams.txCache.Store("interface_subinterface_ip_read_once", true)
		return nil
	} else {
		// Handle GET requests for given interface
		var intfObj *ocbinds.OpenconfigInterfaces_Interfaces_Interface
		ifName = *(&uriIfName)

		if strings.HasPrefix(targetUriPath, "/openconfig-interfaces:interfaces/interface/subinterfaces") {
			if intfsObj != nil && intfsObj.Interface != nil && len(intfsObj.Interface) > 0 {
				var ok bool = false
				if intfObj, ok = intfsObj.Interface[uriIfName]; !ok {
					intfObj, _ = intfsObj.NewInterface(uriIfName)
				}
				ygot.BuildEmptyTree(intfObj)
				if intfObj.Subinterfaces == nil {
					ygot.BuildEmptyTree(intfObj.Subinterfaces)
				}
			} else {
				ygot.BuildEmptyTree(intfsObj)
				intfObj, _ = intfsObj.NewInterface(uriIfName)
				ygot.BuildEmptyTree(intfObj)
			}

			err = handleIntfIPGetByTargetURI(inParams, targetUriPath, ifName, intfObj)
			if err != nil {
				return err
			}

		} else {
			err = errors.New("Invalid URI : " + targetUriPath)
		}
	}

	return err
}

var DbToYang_sflow_collector_xfmr SubTreeXfmrDbToYang = func(inParams XfmrParams) error {
	pathInfo := NewPathInfo(inParams.uri)
	log.V(3).Infof("Received GET for sFlow Collector path: %s, vars: %v", pathInfo.Path, pathInfo.Vars)
	log.V(3).Info("inParams.Uri:", inParams.requestUri)
	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.requestUri)
	return getSflowCol(getSflowRootObject(inParams.ygRoot), targetUriPath, inParams.uri, inParams.dbs[db.ConfigDB])
}

var DbToYang_sflow_interface_xfmr SubTreeXfmrDbToYang = func(inParams XfmrParams) error {
	pathInfo := NewPathInfo(inParams.uri)
	log.V(3).Infof("Received GET for sFlow Interface path: %s, vars: %v", pathInfo.Path, pathInfo.Vars)
	log.V(3).Info("inParams.Uri:", inParams.requestUri)
	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.requestUri)
	return getSflowIntf(getSflowRootObject(inParams.ygRoot), targetUriPath, inParams.uri, inParams.dbs[db.ApplDB])
}

var DbToYang_sflow_xfmr SubTreeXfmrDbToYang = func(inParams XfmrParams) error {
	pathInfo := NewPathInfo(inParams.uri)
	log.V(3).Infof("Received GET for sFlow path: %s, vars: %v", pathInfo.Path, pathInfo.Vars)

	log.V(3).Info("inParams.Uri:", inParams.requestUri)
	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.requestUri)
	return getSflow(getSflowRootObject(inParams.ygRoot), targetUriPath, inParams.uri, inParams.dbs[:])
}

var Subscribe_sflow_collector_xfmr SubTreeXfmrSubscribe = func(inParams XfmrSubscInParams) (XfmrSubscOutParams, error) {

	var err error
	var result XfmrSubscOutParams
	result.dbDataMap = make(RedisDbSubscribeMap)

	pathInfo := NewPathInfo(inParams.uri)
	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.uri)

	log.V(3).Infof("Subscribe_sflow_collector_xfmr: pathInfo %v targetUri %v ", pathInfo, targetUriPath)

	ip := pathInfo.Var("address")
	if ip == "" {
		ip = "*"
	}

	port := pathInfo.Var("port")
	if port == "" {
		port = "*"
	}
	vrf := pathInfo.Var("network-instance")
	if vrf == "" {
		vrf = "*"
	}
	var name string
	if ip == "*" && port == "*" && vrf == "*" {
		name = "*"
	} else {
		name = ip + "_" + port + "_" + vrf
	}
	log.V(3).Infof("Subscribe_sflow_collector_xfmr: key %s", name)
	result.dbDataMap = RedisDbSubscribeMap{db.ConfigDB: {SFLOW_COL_TBL: {name: {
		"collector_ip": "address", "collector_port": "port", "collector_vrf": "network-instance"}}}}

	return result, err
}

var Subscribe_sflow_interface_xfmr SubTreeXfmrSubscribe = func(inParams XfmrSubscInParams) (XfmrSubscOutParams, error) {
	var err error
	var result XfmrSubscOutParams
	result.dbDataMap = make(RedisDbSubscribeMap)
	key := NewPathInfo(inParams.uri).Var("name")

	if key == "" {
		key = "*"
	}
	log.V(3).Infof("XfmrSubscribe_sflow_interface_xfmr key %s ", key)
	result.dbDataMap = RedisDbSubscribeMap{db.ApplDB: {SFLOW_SESS_TBL: {key: {
		"ifname": "name", "admin_state": "enabled", "sample_rate": "sampling-rate"}}}}

	return result, err
}

var Subscribe_sflow_xfmr SubTreeXfmrSubscribe = func(inParams XfmrSubscInParams) (XfmrSubscOutParams, error) {
	var err error
	var result XfmrSubscOutParams
	if inParams.subscProc != TRANSLATE_SUBSCRIBE {
		result.isVirtualTbl = true
		log.V(3).Info("Subscribe_sflow_xfmr :- result.  isVirtualTbl: ", result.isVirtualTbl)
		return result, nil
	}
	result.dbDataMap = make(RedisDbSubscribeMap)

	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.uri)

	log.V(3).Infof("Subscribe_sflow_xfmr: targetUri %v ", targetUriPath)

	if targetUriPath == SAMPLING_SFLOW || targetUriPath == SAMPLING_SFLOW_CONFIG ||
		targetUriPath == SAMPLING_SFLOW_STATE {
		result.dbDataMap = RedisDbSubscribeMap{db.ConfigDB: {SFLOW_GLOBAL_TBL: {
			SFLOW_GLOBAL_KEY: {"admin_state": "enabled", "polling_interval": "polling-interval", "agent_id": "agent"}}}}
		result.onChange = OnchangeEnable
		result.nOpts = &notificationOpts{}
		result.nOpts.pType = OnChange
		result.isVirtualTbl = false
	}
	return result, err
}

var YangToDb_intf_eth_port_config_xfmr SubTreeXfmrYangToDb = func(inParams XfmrParams) (map[string]map[string]db.Value, error) {
	var err error
	memMap := make(map[string]map[string]db.Value)

	pathInfo := NewPathInfo(inParams.uri)
	requestUriPath := (NewPathInfo(inParams.requestUri)).YangPath
	uriIfName := pathInfo.Var("name")
	ifName := uriIfName

	intfType, _, err := getIntfTypeByName(ifName)
	if err != nil {
		errStr := "Invalid Interface"
		err = tlerr.InvalidArgsError{Format: errStr}
		return nil, err
	}

	intfsObj := getIntfsRoot(inParams.ygRoot)
	intfObj := intfsObj.Interface[uriIfName]

	if inParams.oper == DELETE {

		if intfObj.Ethernet == nil ||

			intfObj.Ethernet.Config == nil ||

			(intfObj.Ethernet.Config != nil && requestUriPath == "/openconfig-interfaces:interfaces/interface/openconfig-if-ethernet:ethernet/config") {
			return memMap, err
		}
	}

	if intfObj.Ethernet.Config.PortSpeed != 0 {
		res_map := make(map[string]string)
		value := db.Value{Field: res_map}
		intTbl := IntfTypeTblMap[intfType]

		portSpeed := intfObj.Ethernet.Config.PortSpeed
		val, ok := intfOCToSpeedMap[portSpeed]
		if ok {
			err = nil
			res_map[PORT_SPEED] = val
			res_map[PORT_AUTONEG] = "off"
		} else {
			err = tlerr.InvalidArgs("Invalid speed %s", val)
		}

		if err == nil {
			if _, ok := memMap[intTbl.cfgDb.portTN]; !ok {
				memMap[intTbl.cfgDb.portTN] = make(map[string]db.Value)
			}
			memMap[intTbl.cfgDb.portTN][ifName] = value
		}
	} else if requestUriPath == "/openconfig-interfaces:interfaces/interface/openconfig-if-ethernet:ethernet/config/port-speed" {
		if inParams.oper == DELETE {
			err_str := "DELETE request not allowed for port-speed"
			return nil, tlerr.NotSupported(err_str)
		} else {
			log.Error("Unexpected oper ", inParams.oper)
		}
	}

	res_map := make(map[string]string)
	value := db.Value{Field: res_map}

	if intfObj.Ethernet.Config.AutoNegotiate != nil {
		if intfType == IntfTypeEthernet {
			intTbl := IntfTypeTblMap[intfType]
			autoNeg := intfObj.Ethernet.Config.AutoNegotiate
			var enStr string
			if *autoNeg {
				enStr = "on"
			} else {
				enStr = "off"
			}
			res_map[PORT_AUTONEG] = enStr

			if _, ok := memMap[intTbl.cfgDb.portTN]; !ok {
				memMap[intTbl.cfgDb.portTN] = make(map[string]db.Value)
			}
			memMap[intTbl.cfgDb.portTN][ifName] = value
		} else {
			return nil, errors.New("AutoNegotiate config not supported for given Interface type")
		}
	}

	return memMap, err
}

var YangToDb_intf_ip_addr_xfmr SubTreeXfmrYangToDb = func(inParams XfmrParams) (map[string]map[string]db.Value, error) {
	var err, oerr error
	subOpMap := make(map[db.DBNum]map[string]map[string]db.Value)
	subIntfmap := make(map[string]map[string]db.Value)
	subIntfmap_del := make(map[string]map[string]db.Value)
	var value db.Value
	var overlapIP string

	pathInfo := NewPathInfo(inParams.uri)
	uriIfName := pathInfo.Var("name")
	idx := pathInfo.Var("index")
	i64, err := strconv.ParseUint(idx, 10, 32)
	i32 := uint32(i64)
	ifName := uriIfName

	sonicIfName := &uriIfName

	log.Infof("YangToDb_intf_ip_addr_xfmr: Interface name retrieved from alias : %s is %s", ifName, *sonicIfName)
	ifName = *sonicIfName
	intfType, _, ierr := getIntfTypeByName(ifName)

	intfsObj := getIntfsRoot(inParams.ygRoot)
	if intfsObj == nil || len(intfsObj.Interface) < 1 {
		log.Info("YangToDb_intf_subintf_ip_xfmr : IntfsObj/interface list is empty.")
		return subIntfmap, errors.New("IntfsObj/Interface is not specified")
	}

	if ifName == "" {
		errStr := "Interface KEY not present"
		log.Info("YangToDb_intf_subintf_ip_xfmr : " + errStr)
		return subIntfmap, errors.New(errStr)
	}

	if intfType == IntfTypeUnset || ierr != nil {
		errStr := "Invalid interface type IntfTypeUnset"
		log.Info("YangToDb_intf_subintf_ip_xfmr : " + errStr)
		return subIntfmap, errors.New(errStr)
	}

	if inParams.invokeCRUSubtreeOnce != nil {
		*inParams.invokeCRUSubtreeOnce = true
	}

	prefixType := ""
	if strings.Contains(inParams.uri, "ipv4") {
		prefixType = "ipv4"
	} else if strings.Contains(inParams.uri, "ipv6") {
		prefixType = "ipv6"
	}

	if inParams.oper == DELETE {
		dhcpProv, _ := ValidateIntfProvisionedForRelay(inParams.d, ifName, prefixType, nil)
		if dhcpProv {
			errStr := "IP address cannot be deleted. DHCP Relay is configured on the interface."
			return subIntfmap, tlerr.InvalidArgsError{Format: errStr}
		}
	}

	if _, ok := intfsObj.Interface[uriIfName]; !ok {
		errStr := "Interface entry not found in Ygot tree, ifname: " + ifName
		log.Info("YangToDb_intf_subintf_ip_xfmr : " + errStr)
		return subIntfmap, errors.New(errStr)
	}

	intTbl := IntfTypeTblMap[intfType]
	tblName, _ := getIntfTableNameByDBId(intTbl, inParams.curDb)
	intfObj := intfsObj.Interface[uriIfName]

	if intfObj.Subinterfaces == nil || len(intfObj.Subinterfaces.Subinterface) < 1 {

		if inParams.oper == DELETE {
			log.Info("Top level Interface instance delete or subinterfaces container delete for Interface: ", ifName)
			return intf_ip_addr_del(inParams.d, ifName, tblName, nil)
		}
		errStr := "SubInterface node doesn't exist"
		log.Info("YangToDb_intf_subintf_ip_xfmr : " + errStr)
		err = tlerr.InvalidArgsError{Format: errStr}
		return subIntfmap, err
	}
	if _, ok := intfObj.Subinterfaces.Subinterface[i32]; !ok {
		log.Info("YangToDb_intf_subintf_ip_xfmr : No IP address handling required")
		errStr := "SubInterface index 0 doesn't exist"
		err = tlerr.InvalidArgsError{Format: errStr}
		return subIntfmap, err
	}

	subIntfObj := intfObj.Subinterfaces.Subinterface[i32]
	if inParams.oper == DELETE {
		return intf_ip_addr_del(inParams.d, ifName, tblName, subIntfObj)
	}

	entry, dbErr := inParams.d.GetEntry(&db.TableSpec{Name: intTbl.cfgDb.intfTN}, db.Key{Comp: []string{ifName}})
	if dbErr != nil || !entry.IsPopulated() {
		ifdb := make(map[string]string)
		ifdb["NULL"] = "NULL"
		value := db.Value{Field: ifdb}
		if _, ok := subIntfmap[tblName]; !ok {
			subIntfmap[tblName] = make(map[string]db.Value)
		}
		subIntfmap[tblName][ifName] = value

	}
	if subIntfObj.Ipv4 != nil && subIntfObj.Ipv4.Addresses != nil {
		for ip := range subIntfObj.Ipv4.Addresses.Address {
			addr := subIntfObj.Ipv4.Addresses.Address[ip]
			if addr.Config != nil {
				if addr.Config.Ip == nil {
					addr.Config.Ip = new(string)
					*addr.Config.Ip = ip
				}
				log.Info("Ip:=", *addr.Config.Ip)
				if addr.Config.PrefixLength == nil {
					log.Error("Prefix Length empty!")
					errStr := "Prefix Length not present"
					err = tlerr.InvalidArgsError{Format: errStr}
					return subIntfmap, err
				}
				log.Info("prefix:=", *addr.Config.PrefixLength)

				ipPref := *addr.Config.Ip + "/" + strconv.Itoa(int(*addr.Config.PrefixLength))

				overlapIP, oerr = validateIpOverlap(inParams.d, ifName, ipPref, tblName, true)

				ipEntry, _ := inParams.d.GetEntry(&db.TableSpec{Name: intTbl.cfgDb.intfTN}, db.Key{Comp: []string{ifName, ipPref}})
				ipMap, _ := getIntfIpByName(inParams.d, intTbl.cfgDb.intfTN, ifName, true, false, "")

				m := make(map[string]string)
				alrdyCfgredIP, primaryIpAlrdyCfgred, err := utlValidateIpTypeForCfgredDiffIp(m, ipMap, &ipEntry, &ipPref, &ifName)
				if err != nil {
					return nil, err
				}

				if primaryIpAlrdyCfgred && len(alrdyCfgredIP) != 0 && alrdyCfgredIP != ipPref {
					subIntfmap_del[tblName] = make(map[string]db.Value)
					key := ifName + "|" + alrdyCfgredIP
					subIntfmap_del[tblName][key] = value
					subOpMap[db.ConfigDB] = subIntfmap_del
					log.Info("subOpMap: ", subOpMap)
					inParams.subOpDataMap[DELETE] = &subOpMap
				}

				intf_key := intf_intf_tbl_key_gen(ifName, *addr.Config.Ip, int(*addr.Config.PrefixLength), "|")
				m["family"] = "IPv4"

				value := db.Value{Field: m}
				if _, ok := subIntfmap[tblName]; !ok {
					subIntfmap[tblName] = make(map[string]db.Value)
				}
				subIntfmap[tblName][intf_key] = value
				if log.V(3) {
					log.Info("tblName :", tblName, " intf_key: ", intf_key, " data : ", value)
				}
			}
		}
	}
	if subIntfObj.Ipv6 != nil && subIntfObj.Ipv6.Addresses != nil {
		for ip := range subIntfObj.Ipv6.Addresses.Address {
			addr := subIntfObj.Ipv6.Addresses.Address[ip]
			if addr.Config != nil {
				if addr.Config.Ip == nil {
					addr.Config.Ip = new(string)
					*addr.Config.Ip = ip
				}
				log.Info("Ipv6 IP:=", *addr.Config.Ip)
				if addr.Config.PrefixLength == nil {
					log.Error("Prefix Length empty!")
					errStr := "Prefix Length not present"
					err = tlerr.InvalidArgsError{Format: errStr}
					return subIntfmap, err
				}
				log.Info("Ipv6 prefix:=", *addr.Config.PrefixLength)

				ipPref := *addr.Config.Ip + "/" + strconv.Itoa(int(*addr.Config.PrefixLength))
				overlapIP, oerr = validateIpOverlap(inParams.d, ifName, ipPref, tblName, true)

				m := make(map[string]string)

				intf_key := intf_intf_tbl_key_gen(ifName, *addr.Config.Ip, int(*addr.Config.PrefixLength), "|")

				m["family"] = "IPv6"

				value := db.Value{Field: m}
				if _, ok := subIntfmap[tblName]; !ok {
					subIntfmap[tblName] = make(map[string]db.Value)
				}
				subIntfmap[tblName][intf_key] = value
				log.Info("tblName :", tblName, "intf_key: ", intf_key, "data : ", value)
			}
		}
	}

	if oerr != nil {
		if overlapIP == "" {
			log.Error(oerr)
			return nil, tlerr.InvalidArgsError{Format: oerr.Error()}
		} else {
			subIntfmap_del[tblName] = make(map[string]db.Value)
			key := ifName + "|" + overlapIP
			subIntfmap_del[tblName][key] = value
			subOpMap[db.ConfigDB] = subIntfmap_del
			log.Info("subOpMap: ", subOpMap)
			inParams.subOpDataMap[DELETE] = &subOpMap
		}
	}

	log.Info("YangToDb_intf_subintf_ip_xfmr : subIntfmap : ", subIntfmap)
	return subIntfmap, err
}

var YangToDb_sflow_collector_xfmr SubTreeXfmrYangToDb = func(inParams XfmrParams) (map[string]map[string]db.Value, error) {
	var err error
	res_map := make(map[string]map[string]db.Value)

	log.V(3).Info("sFlow Collector YangToDBSubTreeXfmr: ", inParams.uri)
	col_map := make(map[string]db.Value)
	sflowObj := getSflowRootObject(inParams.ygRoot)

	key := makeColKey(inParams.uri)
	if inParams.oper == DELETE {
		if key != "" {
			col_map[key] = db.Value{Field: make(map[string]string)}
		}
		res_map[SFLOW_COL_TBL] = col_map
		return res_map, err
	}

	if key != "" {
		ip := NewPathInfo(inParams.uri).Var("address")
		port := NewPathInfo(inParams.uri).Var("port")
		vrf := NewPathInfo(inParams.uri).Var("network-instance")
		col_map[key] = db.Value{Field: make(map[string]string)}
		col_map[key].Field[SFLOW_COL_IP_KEY] = ip
		col_map[key].Field[SFLOW_COL_PORT_KEY] = port
		col_map[key].Field[SFLOW_COL_VRF_KEY] = vrf
	} else {
		for col := range sflowObj.Sflow.Collectors.Collector {
			port := strconv.FormatUint(uint64(col.Port), 10)
			key = col.Address + "_" + port + "_" + col.NetworkInstance
			col_map[key] = db.Value{Field: make(map[string]string)}
			col_map[key].Field[SFLOW_COL_IP_KEY] = col.Address
			col_map[key].Field[SFLOW_COL_PORT_KEY] = port
			col_map[key].Field[SFLOW_COL_VRF_KEY] = col.NetworkInstance
		}
	}

	res_map[SFLOW_COL_TBL] = col_map
	return res_map, err
}

var YangToDb_sflow_interface_xfmr SubTreeXfmrYangToDb = func(inParams XfmrParams) (map[string]map[string]db.Value, error) {
	var err error
	res_map := make(map[string]map[string]db.Value)

	log.V(3).Info("sFlow Interface YangToDBSubTreeXfmr: ", inParams.uri)
	intf_map := make(map[string]db.Value)
	sflowObj := getSflowRootObject(inParams.ygRoot)
	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.requestUri)
	log.V(3).Infof("Subscribe_sflow_xfmr: targetUri %v ", targetUriPath)

	if inParams.oper == DELETE {
		if !strings.Contains(targetUriPath, SAMPLING_SFLOW_INTFS_INTF) {
			return res_map, tlerr.NotSupportedError{Format: "DELETE not supported", Path: targetUriPath}
		}

		name := NewPathInfo(inParams.uri).Var("name")
		if name == "" {
			return res_map, tlerr.InvalidArgs("Missing interface name")
		}

		intf_map[name] = db.Value{Field: make(map[string]string)}
		switch targetUriPath {
		case SAMPLING_SFLOW_INTFS_INTF_CONFIG_SAMPL_RATE:
			intf_map[name].Field[SFLOW_SAMPL_RATE_KEY] = ""
		case SAMPLING_SFLOW_INTFS_INTF_CONFIG_ENABLED:
			intf_map[name].Field[SFLOW_ADMIN_KEY] = ""
		case SAMPLING_SFLOW_INTFS_INTF:

		default:
			return res_map, errors.New("DELETE not supported on attribute or container")
		}
	} else {
		for _, intf := range sflowObj.Sflow.Interfaces.Interface {

			if intf.Name == nil {
				return res_map, errors.New("sFlow Interface: No interface name")
			}

			if intf.Config == nil {
				log.V(3).Infof("sFlow Inteface: No configuration")
				continue
			}

			name := *(intf.Name)
			intf_map[name] = db.Value{Field: make(map[string]string)}

			if intf.Config.Enabled != nil {
				if *(intf.Config.Enabled) {
					intf_map[name].Field[SFLOW_ADMIN_KEY] = "up"
				} else {
					intf_map[name].Field[SFLOW_ADMIN_KEY] = "down"
				}
			}

			if intf.Config.SamplingRate != nil {
				intf_map[name].Field[SFLOW_SAMPL_RATE_KEY] =
					strconv.FormatUint(uint64(*(intf.Config.SamplingRate)), 10)
			}
		}
	}

	res_map[SFLOW_INTF_TBL] = intf_map
	return res_map, err
}

var YangToDb_sflow_xfmr SubTreeXfmrYangToDb = func(inParams XfmrParams) (map[string]map[string]db.Value, error) {
	var err error
	res_map := make(map[string]map[string]db.Value)

	log.V(3).Info("sFlow SubTreeXfmr: ", inParams.uri)
	global_map := make(map[string]db.Value)
	sflowObj := getSflowRootObject(inParams.ygRoot)
	targetUriPath, _, _ := XfmrRemoveXPATHPredicates(inParams.requestUri)

	global_map[SFLOW_GLOBAL_KEY] = db.Value{Field: make(map[string]string)}

	if inParams.oper == DELETE {
		switch targetUriPath {
		case SAMPLING_SFLOW_CONFIG_AGENT:
			global_map[SFLOW_GLOBAL_KEY].Field[SFLOW_AGENT_KEY] = ""
		case SAMPLING_SFLOW_CONFIG_POLLING_INT:
			global_map[SFLOW_GLOBAL_KEY].Field[SFLOW_POLLING_INT_KEY] = ""
		default:
			return res_map, errors.New("DELETE not supported on attribute")
		}

		res_map[SFLOW_GLOBAL_TBL] = global_map
		return res_map, err
	}

	if sflowObj.Sflow.Config.Enabled != nil {
		if *(sflowObj.Sflow.Config.Enabled) {
			global_map[SFLOW_GLOBAL_KEY].Field[SFLOW_ADMIN_KEY] = "up"
		} else {
			global_map[SFLOW_GLOBAL_KEY].Field[SFLOW_ADMIN_KEY] = "down"
		}
	}

	if sflowObj.Sflow.Config.PollingInterval != nil {
		global_map[SFLOW_GLOBAL_KEY].Field[SFLOW_POLLING_INT_KEY] =
			strconv.FormatUint(uint64(*(sflowObj.Sflow.Config.PollingInterval)), 10)
	}

	if sflowObj.Sflow.Config.Agent != nil {
		global_map[SFLOW_GLOBAL_KEY].Field[SFLOW_AGENT_KEY] = *(sflowObj.Sflow.Config.Agent)
	}

	res_map[SFLOW_GLOBAL_TBL] = global_map
	return res_map, err
}