diff --git a/rw_core/flowdecomposition/flow_decomposer.go b/rw_core/flowdecomposition/flow_decomposer.go
index f16477f..439c64d 100644
--- a/rw_core/flowdecomposition/flow_decomposer.go
+++ b/rw_core/flowdecomposition/flow_decomposer.go
@@ -37,7 +37,7 @@
 }
 
 // NewFlowDecomposer creates flow decomposer instance
-func NewFlowDecomposer(deviceMgr coreif.DeviceManager) *FlowDecomposer {
+func NewFlowDecomposer(ctx context.Context, deviceMgr coreif.DeviceManager) *FlowDecomposer {
 	var decomposer FlowDecomposer
 	decomposer.deviceMgr = deviceMgr
 	return &decomposer
@@ -45,7 +45,7 @@
 
 //DecomposeRules decomposes per-device flows and flow-groups from the flows and groups defined on a logical device
 func (fd *FlowDecomposer) DecomposeRules(ctx context.Context, agent coreif.LogicalDeviceAgent, flows ofp.Flows, groups ofp.FlowGroups) (*fu.DeviceRules, error) {
-	deviceRules := *fu.NewDeviceRules()
+	deviceRules := *fu.NewDeviceRules(ctx)
 	devicesToUpdate := make(map[string]string)
 
 	groupMap := make(map[uint32]*ofp.OfpGroupEntry)
@@ -59,30 +59,30 @@
 			return nil, err
 		}
 		for deviceID, flowAndGroups := range decomposedRules.Rules {
-			deviceRules.CreateEntryIfNotExist(deviceID)
-			deviceRules.Rules[deviceID].AddFrom(flowAndGroups)
+			deviceRules.CreateEntryIfNotExist(ctx, deviceID)
+			deviceRules.Rules[deviceID].AddFrom(ctx, flowAndGroups)
 			devicesToUpdate[deviceID] = deviceID
 		}
 	}
-	return deviceRules.FilterRules(devicesToUpdate), nil
+	return deviceRules.FilterRules(ctx, devicesToUpdate), nil
 }
 
 // Handles special case of any controller-bound flow for a parent device
-func (fd *FlowDecomposer) updateOutputPortForControllerBoundFlowForParentDevide(flow *ofp.OfpFlowStats,
+func (fd *FlowDecomposer) updateOutputPortForControllerBoundFlowForParentDevide(ctx context.Context, flow *ofp.OfpFlowStats,
 	dr *fu.DeviceRules) (*fu.DeviceRules, error) {
-	EAPOL := fu.EthType(0x888e)
-	IGMP := fu.IpProto(2)
-	UDP := fu.IpProto(17)
+	EAPOL := fu.EthType(ctx, 0x888e)
+	IGMP := fu.IpProto(ctx, 2)
+	UDP := fu.IpProto(ctx, 17)
 
-	newDeviceRules := dr.Copy()
+	newDeviceRules := dr.Copy(ctx)
 	//	Check whether we are dealing with a parent device
-	for deviceID, fg := range dr.GetRules() {
-		if root, _ := fd.deviceMgr.IsRootDevice(deviceID); root {
-			newDeviceRules.ClearFlows(deviceID)
+	for deviceID, fg := range dr.GetRules(ctx) {
+		if root, _ := fd.deviceMgr.IsRootDevice(ctx, deviceID); root {
+			newDeviceRules.ClearFlows(ctx, deviceID)
 			for i := 0; i < fg.Flows.Len(); i++ {
-				f := fg.GetFlow(i)
+				f := fg.GetFlow(ctx, i)
 				UpdateOutPortNo := false
-				for _, field := range fu.GetOfbFields(f) {
+				for _, field := range fu.GetOfbFields(ctx, f) {
 					UpdateOutPortNo = (field.String() == EAPOL.String())
 					UpdateOutPortNo = UpdateOutPortNo || (field.String() == IGMP.String())
 					UpdateOutPortNo = UpdateOutPortNo || (field.String() == UDP.String())
@@ -91,7 +91,7 @@
 					}
 				}
 				if UpdateOutPortNo {
-					f = fu.UpdateOutputPortByActionType(f, uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS),
+					f = fu.UpdateOutputPortByActionType(ctx, f, uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS),
 						uint32(ofp.OfpPortNo_OFPP_CONTROLLER))
 				}
 				// Update flow Id as a change in the instruction field will result in a new flow ID
@@ -99,7 +99,7 @@
 				//if f.Id, err = fu.HashFlowStats(f); err != nil {
 				//return nil, err
 				//}
-				newDeviceRules.AddFlow(deviceID, (proto.Clone(f)).(*ofp.OfpFlowStats))
+				newDeviceRules.AddFlow(ctx, deviceID, (proto.Clone(f)).(*ofp.OfpFlowStats))
 			}
 		}
 	}
@@ -112,34 +112,34 @@
 	inPortNo uint32, outPortNo uint32, flow *ofp.OfpFlowStats) (*fu.DeviceRules, error) {
 
 	logger.Debugw("trap-flow", log.Fields{"inPortNo": inPortNo, "outPortNo": outPortNo, "flow": flow})
-	deviceRules := fu.NewDeviceRules()
-	meterID := fu.GetMeterIdFromFlow(flow)
-	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(flow)
+	deviceRules := fu.NewDeviceRules(ctx)
+	meterID := fu.GetMeterIdFromFlow(ctx, flow)
+	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(ctx, flow)
 
 	ingressHop := path[0]
 	egressHop := path[1]
 
 	//case of packet_in from NNI port rule
-	if agent.GetDeviceRoutes().IsRootPort(inPortNo) {
+	if agent.GetDeviceRoutes(ctx).IsRootPort(ctx, inPortNo) {
 		// Trap flow for NNI port
 		logger.Debug("trap-nni")
 
 		fa := &fu.FlowArgs{
 			KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie},
 			MatchFields: []*ofp.OfpOxmOfbField{
-				fu.InPort(egressHop.Egress),
+				fu.InPort(ctx, egressHop.Egress),
 			},
-			Actions: fu.GetActions(flow),
+			Actions: fu.GetActions(ctx, flow),
 		}
 		// Augment the matchfields with the ofpfields from the flow
-		fg := fu.NewFlowsAndGroups()
-		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
-		fs, err := fu.MkFlowStat(fa)
+		fg := fu.NewFlowsAndGroups(ctx)
+		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
+		fs, err := fu.MkFlowStat(ctx, fa)
 		if err != nil {
 			return nil, err
 		}
-		fg.AddFlow(fs)
-		deviceRules.AddFlowsAndGroup(egressHop.DeviceID, fg)
+		fg.AddFlow(ctx, fs)
+		deviceRules.AddFlowsAndGroup(ctx, egressHop.DeviceID, fg)
 	} else {
 		// Trap flow for UNI port
 		logger.Debug("trap-uni")
@@ -147,7 +147,7 @@
 		//inPortNo is 0 for wildcard input case, do not include upstream port for controller bound flow in input
 		var inPorts []uint32
 		if inPortNo == 0 {
-			inPorts = agent.GetWildcardInputPorts(egressHop.Egress) // exclude egress_hop.egress_port.port_no
+			inPorts = agent.GetWildcardInputPorts(ctx, egressHop.Egress) // exclude egress_hop.egress_port.port_no
 		} else {
 			inPorts = []uint32{inPortNo}
 		}
@@ -156,45 +156,45 @@
 			faParent := &fu.FlowArgs{
 				KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 				MatchFields: []*ofp.OfpOxmOfbField{
-					fu.InPort(egressHop.Ingress),
-					fu.TunnelId(uint64(inputPort)),
+					fu.InPort(ctx, egressHop.Ingress),
+					fu.TunnelId(ctx, uint64(inputPort)),
 				},
 				Actions: []*ofp.OfpAction{
-					fu.Output(egressHop.Egress),
+					fu.Output(ctx, egressHop.Egress),
 				},
 			}
 			// Augment the matchfields with the ofpfields from the flow
-			faParent.MatchFields = append(faParent.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
-			fgParent := fu.NewFlowsAndGroups()
-			fs, err := fu.MkFlowStat(faParent)
+			faParent.MatchFields = append(faParent.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
+			fgParent := fu.NewFlowsAndGroups(ctx)
+			fs, err := fu.MkFlowStat(ctx, faParent)
 			if err != nil {
 				return nil, err
 			}
-			fgParent.AddFlow(fs)
-			deviceRules.AddFlowsAndGroup(egressHop.DeviceID, fgParent)
+			fgParent.AddFlow(ctx, fs)
+			deviceRules.AddFlowsAndGroup(ctx, egressHop.DeviceID, fgParent)
 			logger.Debugw("parent-trap-flow-set", log.Fields{"flow": faParent})
 
 			// Upstream flow on child (onu) device
 			var actions []*ofp.OfpAction
-			setvid := fu.GetVlanVid(flow)
+			setvid := fu.GetVlanVid(ctx, flow)
 			if setvid != nil {
 				// have this child push the vlan the parent is matching/trapping on above
 				actions = []*ofp.OfpAction{
-					fu.PushVlan(0x8100),
-					fu.SetField(fu.VlanVid(*setvid)),
-					fu.Output(ingressHop.Egress),
+					fu.PushVlan(ctx, 0x8100),
+					fu.SetField(ctx, fu.VlanVid(ctx, *setvid)),
+					fu.Output(ctx, ingressHop.Egress),
 				}
 			} else {
 				// otherwise just set the egress port
 				actions = []*ofp.OfpAction{
-					fu.Output(ingressHop.Egress),
+					fu.Output(ctx, ingressHop.Egress),
 				}
 			}
 			faChild := &fu.FlowArgs{
 				KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 				MatchFields: []*ofp.OfpOxmOfbField{
-					fu.InPort(ingressHop.Ingress),
-					fu.TunnelId(uint64(inputPort)),
+					fu.InPort(ctx, ingressHop.Ingress),
+					fu.TunnelId(ctx, uint64(inputPort)),
 				},
 				Actions: actions,
 			}
@@ -202,17 +202,17 @@
 			// If the parent has a match vid and the child is setting that match vid exclude the the match vlan
 			// for the child given it will be setting that vlan and the parent will be matching on it
 			if setvid != nil {
-				faChild.MatchFields = append(faChild.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT, fu.VLAN_VID)...)
+				faChild.MatchFields = append(faChild.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT, fu.VLAN_VID)...)
 			} else {
-				faChild.MatchFields = append(faChild.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
+				faChild.MatchFields = append(faChild.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
 			}
-			fgChild := fu.NewFlowsAndGroups()
-			fs, err = fu.MkFlowStat(faChild)
+			fgChild := fu.NewFlowsAndGroups(ctx)
+			fs, err = fu.MkFlowStat(ctx, faChild)
 			if err != nil {
 				return nil, err
 			}
-			fgChild.AddFlow(fs)
-			deviceRules.AddFlowsAndGroup(ingressHop.DeviceID, fgChild)
+			fgChild.AddFlow(ctx, fs)
+			deviceRules.AddFlowsAndGroup(ctx, ingressHop.DeviceID, fgChild)
 			logger.Debugw("child-trap-flow-set", log.Fields{"flow": faChild})
 		}
 	}
@@ -228,15 +228,15 @@
 	path []route.Hop, inPortNo uint32, outPortNo uint32, flow *ofp.OfpFlowStats) (*fu.DeviceRules, error) {
 
 	logger.Debugw("upstream-non-controller-bound-flow", log.Fields{"inPortNo": inPortNo, "outPortNo": outPortNo})
-	deviceRules := fu.NewDeviceRules()
+	deviceRules := fu.NewDeviceRules(ctx)
 
-	meterID := fu.GetMeterIdFromFlow(flow)
-	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(flow)
+	meterID := fu.GetMeterIdFromFlow(ctx, flow)
+	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(ctx, flow)
 
 	ingressHop := path[0]
 	egressHop := path[1]
 
-	if flow.TableId == 0 && fu.HasNextTable(flow) {
+	if flow.TableId == 0 && fu.HasNextTable(ctx, flow) {
 		logger.Debugw("decomposing-onu-flow-in-upstream-has-next-table", log.Fields{"table_id": flow.TableId})
 		if outPortNo != 0 {
 			logger.Warnw("outPort-should-not-be-specified", log.Fields{"outPortNo": outPortNo})
@@ -245,48 +245,48 @@
 		fa := &fu.FlowArgs{
 			KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 			MatchFields: []*ofp.OfpOxmOfbField{
-				fu.InPort(ingressHop.Ingress),
-				fu.TunnelId(uint64(inPortNo)),
+				fu.InPort(ctx, ingressHop.Ingress),
+				fu.TunnelId(ctx, uint64(inPortNo)),
 			},
-			Actions: fu.GetActions(flow),
+			Actions: fu.GetActions(ctx, flow),
 		}
 		// Augment the matchfields with the ofpfields from the flow
-		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
+		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
 
 		// Augment the Actions
-		fa.Actions = append(fa.Actions, fu.Output(ingressHop.Egress))
+		fa.Actions = append(fa.Actions, fu.Output(ctx, ingressHop.Egress))
 
-		fg := fu.NewFlowsAndGroups()
-		fs, err := fu.MkFlowStat(fa)
+		fg := fu.NewFlowsAndGroups(ctx)
+		fs, err := fu.MkFlowStat(ctx, fa)
 		if err != nil {
 			return nil, err
 		}
-		fg.AddFlow(fs)
-		deviceRules.AddFlowsAndGroup(ingressHop.DeviceID, fg)
+		fg.AddFlow(ctx, fs)
+		deviceRules.AddFlowsAndGroup(ctx, ingressHop.DeviceID, fg)
 	} else if flow.TableId == 1 && outPortNo != 0 {
 		logger.Debugw("decomposing-olt-flow-in-upstream-has-next-table", log.Fields{"table_id": flow.TableId})
 		fa := &fu.FlowArgs{
 			KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 			MatchFields: []*ofp.OfpOxmOfbField{
-				fu.InPort(egressHop.Ingress),
-				fu.TunnelId(uint64(inPortNo)),
+				fu.InPort(ctx, egressHop.Ingress),
+				fu.TunnelId(ctx, uint64(inPortNo)),
 			},
 		}
 		// Augment the matchfields with the ofpfields from the flow
-		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
+		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
 
 		//Augment the actions
-		filteredAction := fu.GetActions(flow, fu.OUTPUT)
-		filteredAction = append(filteredAction, fu.Output(egressHop.Egress))
+		filteredAction := fu.GetActions(ctx, flow, fu.OUTPUT)
+		filteredAction = append(filteredAction, fu.Output(ctx, egressHop.Egress))
 		fa.Actions = filteredAction
 
-		fg := fu.NewFlowsAndGroups()
-		fs, err := fu.MkFlowStat(fa)
+		fg := fu.NewFlowsAndGroups(ctx)
+		fs, err := fu.MkFlowStat(ctx, fa)
 		if err != nil {
 			return nil, err
 		}
-		fg.AddFlow(fs)
-		deviceRules.AddFlowsAndGroup(egressHop.DeviceID, fg)
+		fg.AddFlow(ctx, fs)
+		deviceRules.AddFlowsAndGroup(ctx, egressHop.DeviceID, fg)
 	}
 	return deviceRules, nil
 }
@@ -295,9 +295,9 @@
 func (fd *FlowDecomposer) processDownstreamFlowWithNextTable(ctx context.Context, agent coreif.LogicalDeviceAgent, path []route.Hop,
 	inPortNo uint32, outPortNo uint32, flow *ofp.OfpFlowStats) (*fu.DeviceRules, error) {
 	logger.Debugw("decomposing-olt-flow-in-downstream-flow-with-next-table", log.Fields{"inPortNo": inPortNo, "outPortNo": outPortNo})
-	deviceRules := fu.NewDeviceRules()
-	meterID := fu.GetMeterIdFromFlow(flow)
-	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(flow)
+	deviceRules := fu.NewDeviceRules(ctx)
+	meterID := fu.GetMeterIdFromFlow(ctx, flow)
+	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(ctx, flow)
 
 	if outPortNo != 0 {
 		logger.Warnw("outPort-should-not-be-specified", log.Fields{"outPortNo": outPortNo})
@@ -313,7 +313,7 @@
 	egressHop := path[1]
 	if metadataFromwriteMetadata != 0 {
 		logger.Debugw("creating-metadata-flow", log.Fields{"flow": flow})
-		portNumber := fu.GetEgressPortNumberFromWriteMetadata(flow)
+		portNumber := fu.GetEgressPortNumberFromWriteMetadata(ctx, flow)
 		if portNumber != 0 {
 			recalculatedRoute, err := agent.GetRoute(ctx, inPortNo, portNumber)
 			if err != nil {
@@ -333,7 +333,7 @@
 			}
 			ingressHop = recalculatedRoute[0]
 		}
-		innerTag := fu.GetInnerTagFromMetaData(flow)
+		innerTag := fu.GetInnerTagFromMetaData(ctx, flow)
 		if innerTag == 0 {
 			logger.Errorw("no-inner-route-double-tag", log.Fields{"inPortNo": inPortNo, "outPortNo": portNumber, "comment": "deleting-flow", "metadata": metadataFromwriteMetadata})
 			//TODO: Delete flow
@@ -342,48 +342,48 @@
 		fa := &fu.FlowArgs{
 			KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 			MatchFields: []*ofp.OfpOxmOfbField{
-				fu.InPort(ingressHop.Ingress),
-				fu.Metadata_ofp(uint64(innerTag)),
-				fu.TunnelId(uint64(portNumber)),
+				fu.InPort(ctx, ingressHop.Ingress),
+				fu.Metadata_ofp(ctx, uint64(innerTag)),
+				fu.TunnelId(ctx, uint64(portNumber)),
 			},
-			Actions: fu.GetActions(flow),
+			Actions: fu.GetActions(ctx, flow),
 		}
 		// Augment the matchfields with the ofpfields from the flow
-		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT, fu.METADATA)...)
+		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT, fu.METADATA)...)
 
 		// Augment the Actions
-		fa.Actions = append(fa.Actions, fu.Output(ingressHop.Egress))
+		fa.Actions = append(fa.Actions, fu.Output(ctx, ingressHop.Egress))
 
-		fg := fu.NewFlowsAndGroups()
-		fs, err := fu.MkFlowStat(fa)
+		fg := fu.NewFlowsAndGroups(ctx)
+		fs, err := fu.MkFlowStat(ctx, fa)
 		if err != nil {
 			return nil, err
 		}
-		fg.AddFlow(fs)
-		deviceRules.AddFlowsAndGroup(ingressHop.DeviceID, fg)
+		fg.AddFlow(ctx, fs)
+		deviceRules.AddFlowsAndGroup(ctx, ingressHop.DeviceID, fg)
 	} else { // Create standard flow
 		logger.Debugw("creating-standard-flow", log.Fields{"flow": flow})
 		fa := &fu.FlowArgs{
 			KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 			MatchFields: []*ofp.OfpOxmOfbField{
-				fu.InPort(ingressHop.Ingress),
-				fu.TunnelId(uint64(inPortNo)),
+				fu.InPort(ctx, ingressHop.Ingress),
+				fu.TunnelId(ctx, uint64(inPortNo)),
 			},
-			Actions: fu.GetActions(flow),
+			Actions: fu.GetActions(ctx, flow),
 		}
 		// Augment the matchfields with the ofpfields from the flow
-		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
+		fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
 
 		// Augment the Actions
-		fa.Actions = append(fa.Actions, fu.Output(ingressHop.Egress))
+		fa.Actions = append(fa.Actions, fu.Output(ctx, ingressHop.Egress))
 
-		fg := fu.NewFlowsAndGroups()
-		fs, err := fu.MkFlowStat(fa)
+		fg := fu.NewFlowsAndGroups(ctx)
+		fs, err := fu.MkFlowStat(ctx, fa)
 		if err != nil {
 			return nil, err
 		}
-		fg.AddFlow(fs)
-		deviceRules.AddFlowsAndGroup(ingressHop.DeviceID, fg)
+		fg.AddFlow(ctx, fs)
+		deviceRules.AddFlowsAndGroup(ctx, ingressHop.DeviceID, fg)
 	}
 
 	return deviceRules, nil
@@ -394,33 +394,33 @@
 	inPortNo uint32, outPortNo uint32, flow *ofp.OfpFlowStats) (*fu.DeviceRules, error) {
 
 	logger.Debugw("decomposing-onu-flow-in-downstream-unicast-flow", log.Fields{"inPortNo": inPortNo, "outPortNo": outPortNo})
-	deviceRules := fu.NewDeviceRules()
+	deviceRules := fu.NewDeviceRules(ctx)
 
 	egressHop := path[1]
 
-	meterID := fu.GetMeterIdFromFlow(flow)
-	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(flow)
+	meterID := fu.GetMeterIdFromFlow(ctx, flow)
+	metadataFromwriteMetadata := fu.GetMetadataFromWriteMetadataAction(ctx, flow)
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": uint64(flow.Priority), "cookie": flow.Cookie, "meter_id": uint64(meterID), "write_metadata": metadataFromwriteMetadata},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(egressHop.Ingress),
+			fu.InPort(ctx, egressHop.Ingress),
 		},
 	}
 	// Augment the matchfields with the ofpfields from the flow
-	fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(flow, fu.IN_PORT)...)
+	fa.MatchFields = append(fa.MatchFields, fu.GetOfbFields(ctx, flow, fu.IN_PORT)...)
 
 	// Augment the Actions
-	filteredAction := fu.GetActions(flow, fu.OUTPUT)
-	filteredAction = append(filteredAction, fu.Output(egressHop.Egress))
+	filteredAction := fu.GetActions(ctx, flow, fu.OUTPUT)
+	filteredAction = append(filteredAction, fu.Output(ctx, egressHop.Egress))
 	fa.Actions = filteredAction
 
-	fg := fu.NewFlowsAndGroups()
-	fs, err := fu.MkFlowStat(fa)
+	fg := fu.NewFlowsAndGroups(ctx)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	if err != nil {
 		return nil, err
 	}
-	fg.AddFlow(fs)
-	deviceRules.AddFlowsAndGroup(egressHop.DeviceID, fg)
+	fg.AddFlow(ctx, fs)
+	deviceRules.AddFlowsAndGroup(ctx, egressHop.DeviceID, fg)
 	return deviceRules, nil
 }
 
@@ -430,7 +430,7 @@
 	groupMap map[uint32]*ofp.OfpGroupEntry) *fu.DeviceRules {
 
 	logger.Debugw("multicast-flow", log.Fields{"inPortNo": inPortNo, "outPortNo": outPortNo})
-	deviceRules := fu.NewDeviceRules()
+	deviceRules := fu.NewDeviceRules(ctx)
 
 	//having no Group yet is the same as having a Group with no buckets
 	var grp *ofp.OfpGroupEntry
@@ -444,11 +444,11 @@
 		return deviceRules
 	}
 
-	deviceRules.CreateEntryIfNotExist(path[0].DeviceID)
-	fg := fu.NewFlowsAndGroups()
-	fg.AddFlow(flow)
+	deviceRules.CreateEntryIfNotExist(ctx, path[0].DeviceID)
+	fg := fu.NewFlowsAndGroups(ctx)
+	fg.AddFlow(ctx, flow)
 	//return the multicast flow without decomposing it
-	deviceRules.AddFlowsAndGroup(path[0].DeviceID, fg)
+	deviceRules.AddFlowsAndGroup(ctx, path[0].DeviceID, fg)
 	return deviceRules
 }
 
@@ -456,18 +456,18 @@
 func (fd *FlowDecomposer) decomposeFlow(ctx context.Context, agent coreif.LogicalDeviceAgent, flow *ofp.OfpFlowStats,
 	groupMap map[uint32]*ofp.OfpGroupEntry) (*fu.DeviceRules, error) {
 
-	inPortNo := fu.GetInPort(flow)
-	if fu.HasGroup(flow) && inPortNo == 0 {
+	inPortNo := fu.GetInPort(ctx, flow)
+	if fu.HasGroup(ctx, flow) && inPortNo == 0 {
 		//if no in-port specified for a multicast flow, put NNI port as in-port
 		//so that a valid path can be found for the flow
-		nniPorts := agent.GetNNIPorts()
+		nniPorts := agent.GetNNIPorts(ctx)
 		if len(nniPorts) > 0 {
 			inPortNo = nniPorts[0]
 			logger.Debugw("assigning-nni-port-as-in-port-for-multicast-flow", log.Fields{"nni": nniPorts[0], "flow:": flow})
 		}
 	}
-	outPortNo := fu.GetOutPort(flow)
-	deviceRules := fu.NewDeviceRules()
+	outPortNo := fu.GetOutPort(ctx, flow)
+	deviceRules := fu.NewDeviceRules(ctx)
 	path, err := agent.GetRoute(ctx, inPortNo, outPortNo)
 	if err != nil {
 		return deviceRules, err
@@ -503,7 +503,7 @@
 			if err != nil {
 				return nil, err
 			}
-		} else if fu.HasNextTable(flow) && flow.TableId == 0 { // Unicast OLT flow DL
+		} else if fu.HasNextTable(ctx, flow) && flow.TableId == 0 { // Unicast OLT flow DL
 			logger.Debugw("process-olt-downstream-noncontrollerbound-flow-with-nexttable", log.Fields{"flows": flow})
 			deviceRules, err = fd.processDownstreamFlowWithNextTable(ctx, agent, path, inPortNo, outPortNo, flow)
 			if err != nil {
@@ -515,13 +515,13 @@
 			if err != nil {
 				return nil, err
 			}
-		} else if grpID := fu.GetGroup(flow); grpID != 0 && flow.TableId == 0 { //Multicast
+		} else if grpID := fu.GetGroup(ctx, flow); grpID != 0 && flow.TableId == 0 { //Multicast
 			logger.Debugw("process-multicast-flow", log.Fields{"flows": flow})
 			deviceRules = fd.processMulticastFlow(ctx, path, inPortNo, outPortNo, flow, grpID, groupMap)
 		} else {
 			return deviceRules, status.Errorf(codes.Aborted, "unknown downstream flow %v", *flow)
 		}
 	}
-	deviceRules, err = fd.updateOutputPortForControllerBoundFlowForParentDevide(flow, deviceRules)
+	deviceRules, err = fd.updateOutputPortForControllerBoundFlowForParentDevide(ctx, flow, deviceRules)
 	return deviceRules, err
 }
diff --git a/rw_core/flowdecomposition/flow_decomposer_test.go b/rw_core/flowdecomposition/flow_decomposer_test.go
index eb7ad75..211ffe6 100644
--- a/rw_core/flowdecomposition/flow_decomposer_test.go
+++ b/rw_core/flowdecomposition/flow_decomposer_test.go
@@ -92,7 +92,7 @@
 	}
 	return nil, errors.New("ABSENT")
 }
-func (tdm *testDeviceManager) IsRootDevice(deviceID string) (bool, error) {
+func (tdm *testDeviceManager) IsRootDevice(ctx context.Context, deviceID string) (bool, error) {
 	if d, ok := tdm.devices[deviceID]; ok {
 		return d.Root, nil
 	}
@@ -111,6 +111,7 @@
 
 func newTestFlowDecomposer(t *testing.T, deviceMgr *testDeviceManager) *testFlowDecomposer {
 	var tfd testFlowDecomposer
+	ctx := context.Background()
 	tfd.dMgr = deviceMgr
 
 	tfd.logicalPorts = make(map[uint32]*voltha.LogicalPort)
@@ -318,77 +319,77 @@
 
 	// DEFAULT RULES
 
-	tfd.defaultRules = fu.NewDeviceRules()
-	fg := fu.NewFlowsAndGroups()
+	tfd.defaultRules = fu.NewDeviceRules(ctx)
+	fg := fu.NewFlowsAndGroups(ctx)
 	fa := &fu.FlowArgs{
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0),
+			fu.InPort(ctx, 2),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
-			fu.Output(1),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101)),
+			fu.Output(ctx, 1),
 		},
 	}
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	fg.AddFlow(fs)
-	tfd.defaultRules.AddFlowsAndGroup("onu1", fg)
+	fg.AddFlow(ctx, fs)
+	tfd.defaultRules.AddFlowsAndGroup(ctx, "onu1", fg)
 
-	fg = fu.NewFlowsAndGroups()
+	fg = fu.NewFlowsAndGroups(ctx)
 	fa = &fu.FlowArgs{
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0),
+			fu.InPort(ctx, 2),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 102)),
-			fu.Output(1),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|102)),
+			fu.Output(ctx, 1),
 		},
 	}
-	fs, err = fu.MkFlowStat(fa)
+	fs, err = fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	fg.AddFlow(fs)
-	tfd.defaultRules.AddFlowsAndGroup("onu2", fg)
+	fg.AddFlow(ctx, fs)
+	tfd.defaultRules.AddFlowsAndGroup(ctx, "onu2", fg)
 
-	fg = fu.NewFlowsAndGroups()
+	fg = fu.NewFlowsAndGroups(ctx)
 	fa = &fu.FlowArgs{
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0),
+			fu.InPort(ctx, 2),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 103)),
-			fu.Output(1),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|103)),
+			fu.Output(ctx, 1),
 		},
 	}
-	fs, err = fu.MkFlowStat(fa)
+	fs, err = fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	fg.AddFlow(fs)
-	tfd.defaultRules.AddFlowsAndGroup("onu3", fg)
+	fg.AddFlow(ctx, fs)
+	tfd.defaultRules.AddFlowsAndGroup(ctx, "onu3", fg)
 
-	fg = fu.NewFlowsAndGroups()
+	fg = fu.NewFlowsAndGroups(ctx)
 	fa = &fu.FlowArgs{
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0),
+			fu.InPort(ctx, 2),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 104)),
-			fu.Output(1),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|104)),
+			fu.Output(ctx, 1),
 		},
 	}
-	fs, err = fu.MkFlowStat(fa)
+	fs, err = fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	fg.AddFlow(fs)
-	tfd.defaultRules.AddFlowsAndGroup("onu4", fg)
+	fg.AddFlow(ctx, fs)
+	tfd.defaultRules.AddFlowsAndGroup(ctx, "onu4", fg)
 
 	//Set up the device graph - flow decomposer uses it only to verify whether a port is a root port.
-	tfd.deviceRoutes = route.NewDeviceRoutes("ldid", tfd.getDeviceHelper)
+	tfd.deviceRoutes = route.NewDeviceRoutes(ctx, "ldid", tfd.getDeviceHelper)
 	tfd.deviceRoutes.RootPorts = make(map[uint32]uint32)
 	tfd.deviceRoutes.RootPorts[10] = 10
 
-	tfd.fd = NewFlowDecomposer(tfd.dMgr)
+	tfd.fd = NewFlowDecomposer(ctx, tfd.dMgr)
 
 	return &tfd
 }
@@ -405,7 +406,7 @@
 	return nil, nil
 }
 
-func (tfd *testFlowDecomposer) GetDeviceRoutes() *route.DeviceRoutes {
+func (tfd *testFlowDecomposer) GetDeviceRoutes(ctx context.Context) *route.DeviceRoutes {
 	return tfd.deviceRoutes
 }
 
@@ -413,7 +414,7 @@
 	return tfd.defaultRules
 }
 
-func (tfd *testFlowDecomposer) GetWildcardInputPorts(excludePort ...uint32) []uint32 {
+func (tfd *testFlowDecomposer) GetWildcardInputPorts(ctx context.Context, excludePort ...uint32) []uint32 {
 	lPorts := make([]uint32, 0)
 	var exclPort uint32
 	if len(excludePort) == 1 {
@@ -449,7 +450,7 @@
 	return nil, status.Errorf(codes.FailedPrecondition, "no route from:%d to:%d", ingressPortNo, egressPortNo)
 }
 
-func (tfd *testFlowDecomposer) GetNNIPorts() []uint32 {
+func (tfd *testFlowDecomposer) GetNNIPorts(ctx context.Context) []uint32 {
 	nniPorts := make([]uint32, 0)
 	for portNo, nni := range tfd.logicalPortsNo {
 		if nni {
@@ -460,27 +461,27 @@
 }
 
 func TestEapolReRouteRuleVlanDecomposition(t *testing.T) {
-
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.VlanVid(50),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 1),
+			fu.VlanVid(ctx, 50),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs}}
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -491,61 +492,61 @@
 	faParent := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.TunnelId(uint64(1)),
-			fu.VlanVid(50),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 1),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.VlanVid(ctx, 50),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(faParent)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, faParent)
 	assert.Nil(t, err)
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 
 	faChild := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.TunnelId(uint64(1)),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 2),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.PushVlan(0x8100),
-			fu.SetField(fu.VlanVid(50)),
-			fu.Output(1),
+			fu.PushVlan(ctx, 0x8100),
+			fu.SetField(ctx, fu.VlanVid(ctx, 50)),
+			fu.Output(ctx, 1),
 		},
 	}
-	expectedOnuFlow, err := fu.MkFlowStat(faChild)
+	expectedOnuFlow, err := fu.MkFlowStat(ctx, faChild)
 	assert.Nil(t, err)
-	derivedFlow = onu1FlowAndGroup.GetFlow(0)
+	derivedFlow = onu1FlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOnuFlow.String(), derivedFlow.String())
 }
 
 func TestEapolReRouteRuleZeroVlanDecomposition(t *testing.T) {
-
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.VlanVid(0),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 1),
+			fu.VlanVid(ctx, 0),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs}}
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -556,60 +557,60 @@
 	faParent := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.TunnelId(uint64(1)),
-			fu.VlanVid(0),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 1),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.VlanVid(ctx, 0),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(faParent)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, faParent)
 	assert.Nil(t, err)
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 
 	faChild := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.TunnelId(uint64(1)),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 2),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.PushVlan(0x8100),
-			fu.SetField(fu.VlanVid(0)),
-			fu.Output(1),
+			fu.PushVlan(ctx, 0x8100),
+			fu.SetField(ctx, fu.VlanVid(ctx, 0)),
+			fu.Output(ctx, 1),
 		},
 	}
-	expectedOnuFlow, err := fu.MkFlowStat(faChild)
+	expectedOnuFlow, err := fu.MkFlowStat(ctx, faChild)
 	assert.Nil(t, err)
-	derivedFlow = onu1FlowAndGroup.GetFlow(0)
+	derivedFlow = onu1FlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOnuFlow.String(), derivedFlow.String())
 }
 
 func TestEapolReRouteRuleNoVlanDecomposition(t *testing.T) {
-
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 1),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs}}
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -620,60 +621,60 @@
 	faParent := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.TunnelId(uint64(1)),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 1),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(faParent)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, faParent)
 	assert.Nil(t, err)
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 
 	faChild := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.TunnelId(uint64(1)),
-			fu.EthType(0x888e),
+			fu.InPort(ctx, 2),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.EthType(ctx, 0x888e),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(1),
+			fu.Output(ctx, 1),
 		},
 	}
-	expectedOnuFlow, err := fu.MkFlowStat(faChild)
+	expectedOnuFlow, err := fu.MkFlowStat(ctx, faChild)
 	assert.Nil(t, err)
-	derivedFlow = onu1FlowAndGroup.GetFlow(0)
+	derivedFlow = onu1FlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOnuFlow.String(), derivedFlow.String())
 }
 
 func TestDhcpReRouteRuleDecomposition(t *testing.T) {
-
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.EthType(0x0800),
-			fu.Ipv4Dst(0xffffffff),
-			fu.IpProto(17),
-			fu.UdpSrc(68),
-			fu.UdpDst(67),
+			fu.InPort(ctx, 1),
+			fu.EthType(ctx, 0x0800),
+			fu.Ipv4Dst(ctx, 0xffffffff),
+			fu.IpProto(ctx, 17),
+			fu.UdpSrc(ctx, 68),
+			fu.UdpDst(ctx, 67),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs}}
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -685,62 +686,63 @@
 	faParent := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.TunnelId(uint64(1)),
-			fu.EthType(0x0800),
-			fu.Ipv4Dst(0xffffffff),
-			fu.IpProto(17),
-			fu.UdpSrc(68),
-			fu.UdpDst(67),
+			fu.InPort(ctx, 1),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.EthType(ctx, 0x0800),
+			fu.Ipv4Dst(ctx, 0xffffffff),
+			fu.IpProto(ctx, 17),
+			fu.UdpSrc(ctx, 68),
+			fu.UdpDst(ctx, 67),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(faParent)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, faParent)
 	assert.Nil(t, err)
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 
 	faChild := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.TunnelId(uint64(1)),
-			fu.EthType(0x0800),
-			fu.Ipv4Dst(0xffffffff),
-			fu.IpProto(17),
-			fu.UdpSrc(68),
-			fu.UdpDst(67),
+			fu.InPort(ctx, 2),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.EthType(ctx, 0x0800),
+			fu.Ipv4Dst(ctx, 0xffffffff),
+			fu.IpProto(ctx, 17),
+			fu.UdpSrc(ctx, 68),
+			fu.UdpDst(ctx, 67),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(1),
+			fu.Output(ctx, 1),
 		},
 	}
-	expectedOnuFlow, err := fu.MkFlowStat(faChild)
+	expectedOnuFlow, err := fu.MkFlowStat(ctx, faChild)
 	assert.Nil(t, err)
-	derivedFlow = onu1FlowAndGroup.GetFlow(0)
+	derivedFlow = onu1FlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOnuFlow.String(), derivedFlow.String())
 }
 
 func TestLldpReRouteRuleDecomposition(t *testing.T) {
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(10),
-			fu.EthType(0x88CC),
+			fu.InPort(ctx, 10),
+			fu.EthType(ctx, 0x88CC),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs}}
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -751,50 +753,51 @@
 	fa = &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 1000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.EthType(0x88CC),
+			fu.InPort(ctx, 2),
+			fu.EthType(ctx, 0x88CC),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Output(uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
+			fu.Output(ctx, uint32(ofp.OfpPortNo_OFPP_CONTROLLER)),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(fa)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 }
 
 func TestUnicastUpstreamRuleDecomposition(t *testing.T) {
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 5000, "table_id": 0},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 1),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101)),
 		},
 	}
 
 	fa2 := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500, "table_id": 1},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 1),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.PushVlan(0x8100),
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 1000)),
-			fu.SetField(fu.VlanPcp(0)),
-			fu.Output(10),
+			fu.PushVlan(ctx, 0x8100),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|1000)),
+			fu.SetField(ctx, fu.VlanPcp(ctx, 0)),
+			fu.Output(ctx, 10),
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	fs2, err := fu.MkFlowStat(fa2)
+	fs2, err := fu.MkFlowStat(ctx, fa2)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs, fs2}}
 	flows.Items[0].Instructions = []*ofp.OfpInstruction{{
@@ -808,7 +811,7 @@
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -822,20 +825,20 @@
 	fa = &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 5000},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.TunnelId(uint64(1)),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 2),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101)),
-			fu.Output(1),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101)),
+			fu.Output(ctx, 1),
 		},
 	}
 
-	derivedFlow := onu1FlowAndGroup.GetFlow(0)
+	derivedFlow := onu1FlowAndGroup.GetFlow(ctx, 0)
 	// Form the expected flow
-	expectedOnu1Flow, err := fu.MkFlowStat(fa)
+	expectedOnu1Flow, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	expectedOnu1Flow.Instructions = []*ofp.OfpInstruction{{
 		Type: uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS),
@@ -856,54 +859,55 @@
 	fa = &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.TunnelId(uint64(1)),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 1),
+			fu.TunnelId(ctx, uint64(1)),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.PushVlan(0x8100),
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 1000)),
-			fu.SetField(fu.VlanPcp(0)),
-			fu.Output(2),
+			fu.PushVlan(ctx, 0x8100),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|1000)),
+			fu.SetField(ctx, fu.VlanPcp(ctx, 0)),
+			fu.Output(ctx, 2),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(fa)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	derivedFlow = oltFlowAndGroup.GetFlow(0)
+	derivedFlow = oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 }
 
 func TestUnicastDownstreamRuleDecomposition(t *testing.T) {
+	ctx := context.Background()
 	logger.Debugf("Starting Test Unicast Downstream")
 	fa1 := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500, "table_id": 0},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(10),
-			fu.Metadata_ofp((1000 << 32) | 1),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 10),
+			fu.Metadata_ofp(ctx, (1000<<32)|1),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.PopVlan(),
+			fu.PopVlan(ctx),
 		},
 	}
 
 	fa2 := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500, "table_id": 1},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(10),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 10),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0)),
-			fu.Output(1),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0)),
+			fu.Output(ctx, 1),
 		},
 	}
 
-	fs1, err := fu.MkFlowStat(fa1)
+	fs1, err := fu.MkFlowStat(ctx, fa1)
 	assert.Nil(t, err)
-	fs2, err := fu.MkFlowStat(fa2)
+	fs2, err := fu.MkFlowStat(ctx, fa2)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs1, fs2}}
 	flows.Items[0].Instructions = []*ofp.OfpInstruction{{
@@ -917,7 +921,7 @@
 	groups := ofp.FlowGroups{}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	onu1FlowAndGroup := deviceRules.Rules["onu1"]
 	oltFlowAndGroup := deviceRules.Rules["olt"]
@@ -929,19 +933,19 @@
 	fa1 = &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(2),
-			fu.TunnelId(uint64(10)),
-			fu.Metadata_ofp(4294967296001),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 2),
+			fu.TunnelId(ctx, uint64(10)),
+			fu.Metadata_ofp(ctx, 4294967296001),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.PopVlan(),
-			fu.Output(1),
+			fu.PopVlan(ctx),
+			fu.Output(ctx, 1),
 		},
 	}
 
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
-	expectedOltFlow, err := fu.MkFlowStat(fa1)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, fa1)
 	assert.Nil(t, err)
 	expectedOltFlow.Instructions = []*ofp.OfpInstruction{{
 		Type: uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS),
@@ -961,33 +965,34 @@
 	fa1 = &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(1),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 101),
-			fu.VlanPcp(0),
+			fu.InPort(ctx, 1),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|101),
+			fu.VlanPcp(ctx, 0),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.SetField(fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 0)),
-			fu.Output(2),
+			fu.SetField(ctx, fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|0)),
+			fu.Output(ctx, 2),
 		},
 	}
-	expectedOnu1Flow, err := fu.MkFlowStat(fa1)
+	expectedOnu1Flow, err := fu.MkFlowStat(ctx, fa1)
 	assert.Nil(t, err)
-	derivedFlow = onu1FlowAndGroup.GetFlow(0)
+	derivedFlow = onu1FlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOnu1Flow.String(), derivedFlow.String())
 }
 
 func TestMulticastDownstreamRuleDecomposition(t *testing.T) {
+	ctx := context.Background()
 	fa := &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(10),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 170),
-			fu.VlanPcp(0),
-			fu.EthType(0x800),
-			fu.Ipv4Dst(0xe00a0a0a),
+			fu.InPort(ctx, 10),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|170),
+			fu.VlanPcp(ctx, 0),
+			fu.EthType(ctx, 0x800),
+			fu.Ipv4Dst(ctx, 0xe00a0a0a),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Group(10),
+			fu.Group(ctx, 10),
 		},
 	}
 
@@ -995,20 +1000,20 @@
 		GroupId: 10,
 		Buckets: []*ofp.OfpBucket{
 			{Actions: []*ofp.OfpAction{
-				fu.PopVlan(),
-				fu.Output(1),
+				fu.PopVlan(ctx),
+				fu.Output(ctx, 1),
 			},
 			},
 		},
 	}
 
-	fs, err := fu.MkFlowStat(fa)
+	fs, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
 	flows := ofp.Flows{Items: []*ofp.OfpFlowStats{fs}}
-	groups := ofp.FlowGroups{Items: []*ofp.OfpGroupEntry{fu.MkGroupStat(ga)}}
+	groups := ofp.FlowGroups{Items: []*ofp.OfpGroupEntry{fu.MkGroupStat(ctx, ga)}}
 	tfd := newTestFlowDecomposer(t, newTestDeviceManager())
 
-	deviceRules, err := tfd.fd.DecomposeRules(context.Background(), tfd, flows, groups)
+	deviceRules, err := tfd.fd.DecomposeRules(ctx, tfd, flows, groups)
 	assert.Nil(t, err)
 	oltFlowAndGroup := deviceRules.Rules["olt"]
 	assert.Equal(t, 1, oltFlowAndGroup.Flows.Len())
@@ -1017,18 +1022,18 @@
 	fa = &fu.FlowArgs{
 		KV: fu.OfpFlowModArgs{"priority": 500},
 		MatchFields: []*ofp.OfpOxmOfbField{
-			fu.InPort(10),
-			fu.VlanVid(uint32(ofp.OfpVlanId_OFPVID_PRESENT) | 170),
-			fu.VlanPcp(0),
-			fu.EthType(0x800),
-			fu.Ipv4Dst(0xe00a0a0a),
+			fu.InPort(ctx, 10),
+			fu.VlanVid(ctx, uint32(ofp.OfpVlanId_OFPVID_PRESENT)|170),
+			fu.VlanPcp(ctx, 0),
+			fu.EthType(ctx, 0x800),
+			fu.Ipv4Dst(ctx, 0xe00a0a0a),
 		},
 		Actions: []*ofp.OfpAction{
-			fu.Group(10),
+			fu.Group(ctx, 10),
 		},
 	}
-	expectedOltFlow, err := fu.MkFlowStat(fa)
+	expectedOltFlow, err := fu.MkFlowStat(ctx, fa)
 	assert.Nil(t, err)
-	derivedFlow := oltFlowAndGroup.GetFlow(0)
+	derivedFlow := oltFlowAndGroup.GetFlow(ctx, 0)
 	assert.Equal(t, expectedOltFlow.String(), derivedFlow.String())
 }