diff --git a/internal/pkg/of/flows.go b/internal/pkg/of/flows.go
new file mode 100644
index 0000000..2cc84ac
--- /dev/null
+++ b/internal/pkg/of/flows.go
@@ -0,0 +1,1016 @@
+/*
+* Copyright 2022-present Open Networking Foundation
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package of
+
+import (
+	"context"
+	"net"
+	"strconv"
+
+	"github.com/google/gopacket/layers"
+
+	"github.com/opencord/voltha-lib-go/v7/pkg/flows"
+	"github.com/opencord/voltha-lib-go/v7/pkg/log"
+	ofp "github.com/opencord/voltha-protos/v5/go/openflow_13"
+	//"github.com/opencord/voltha-protos/v5/go/voltha"
+)
+
+// PbitType type
+type PbitType uint16
+
+// TODO: Port related constants - OF specifies a different value
+// for controller. Need to make sure this is correct
+const (
+	ControllerPort uint32   = 0xfffffffd
+	PbitMatchNone  PbitType = 8
+	PbitMatchAll   PbitType = 0xFF
+)
+
+var logger log.CLogger
+
+var ctx = context.TODO()
+
+// ----------------------------------------------------------
+// Cookie related specifications and utilities
+// ----------------------------------------------------------
+// Though the openflow does not utilize cookies as unique identities of
+// flows, we use cookies as identities in the application. The same
+// may also be used in the VOLTHA if so desired to reduce the complexity
+// of management of flows. In terms of how the cookie is set and is
+// ensured to be unique is:
+// Cookie is a 64 bit value. The first 32 bits are set to the port-id
+// All rules set at the device level are associated with NNI. All other
+// flows, both ingress and egress are associated with the access port.
+// The last 32 bits are used to uniquely identifies flows of a port.
+const (
+	// The flow masks are used to set the MSB of the lower
+	// 32 bits of cookie
+
+	// UsFlowMask constant
+	UsFlowMask uint64 = 0x8000
+	// DsFlowMask constant
+	DsFlowMask uint64 = 0x0000
+
+	// Flow types used to divide the available cookie value range
+	// Each type is allocated 256 flow identities which are plenty
+	// for the known use cases.
+
+	// DhcpArpFlowMask constant
+	DhcpArpFlowMask uint64 = 0x0100
+	// PppoeFlowMask constant
+	PppoeFlowMask uint64 = 0x0100
+	// HsiaFlowMask constant
+	HsiaFlowMask uint64 = 0x0200
+	// DsArpFlowMask constant
+	DsArpFlowMask uint64 = 0x0300
+	// IgmpFlowMask constant
+	IgmpFlowMask uint64 = 0x0400
+	// Dhcpv6FlowMask constant
+	Dhcpv6FlowMask uint64 = 0x0800
+
+	// Flow priorities - Higher the value, higher the priority
+
+	// DhcpFlowPriority constant
+	DhcpFlowPriority uint32 = 5000
+	// ArpFlowPriority constant
+	ArpFlowPriority uint32 = 5000
+	// IgmpFlowPriority constant
+	IgmpFlowPriority uint32 = 5000
+	// McFlowPriority constant
+	McFlowPriority uint32 = 5000
+	// PppoeFlowPriority constant
+	PppoeFlowPriority uint32 = 5000
+	// HsiaFlowPriority constant
+	HsiaFlowPriority uint32 = 100
+)
+
+// CookieSetPort to set port
+func CookieSetPort(cookie uint64, port uint32) uint64 {
+	return cookie | (uint64(port) << 32)
+}
+
+// CookieGetPort to get port
+func CookieGetPort(cookie uint64) uint32 {
+	return uint32(cookie >> 32)
+}
+
+// -------------------------------------------------------
+// The flow match and action related definitions follow
+// -------------------------------------------------------
+// The Ethernet types listed below serve our requirement. We may extend
+// the list as we identify more use cases to be supported.
+
+// EtherType type
+type EtherType uint16
+
+const (
+	// EtherTypeAny constant
+	EtherTypeAny EtherType = 0x0000 // Needs assertion
+	// EtherTypeIpv4 constant
+	EtherTypeIpv4 EtherType = 0x0800
+	// EtherTypeIpv6 constant
+	EtherTypeIpv6 EtherType = 0x86DD
+	// EtherTypePppoeDiscovery constant
+	EtherTypePppoeDiscovery EtherType = 0x8863
+	// EtherTypePppoeSession constant
+	EtherTypePppoeSession EtherType = 0x8864
+	// EtherTypeArp constant
+	EtherTypeArp EtherType = 0x0806
+)
+
+// VLAN related definitions
+// VLANs can take a value between 1 and 4095. VLAN 0 is used to set just
+// the PCP bytes. VLAN 4097 is being used to represent "no VLAN"
+// 4096 is being used to represent "any vlan"
+
+// VlanType type
+type VlanType uint16
+
+const (
+	// VlanAny constant
+	VlanAny VlanType = 0x1000
+	// VlanNone constant
+	VlanNone VlanType = 0x1001
+)
+
+func (vlan *VlanType) String() string {
+	return strconv.Itoa(int(*vlan))
+}
+
+// IP Protocol defintions
+// IP protocol 0xff is reserved and we are using the reserved value to
+// represent that match is not needed.
+
+// IPProtocol type
+type IPProtocol uint8
+
+const (
+	// IPProtocolIgnore constant
+	IPProtocolIgnore IPProtocol = 0xff
+	// IPProtocolTCP constant
+	IPProtocolTCP IPProtocol = 0x06
+	// IPProtocolUDP constant
+	IPProtocolUDP IPProtocol = 0x11
+	// IPProtocolIgmp constant
+	IPProtocolIgmp IPProtocol = 0x02
+	// IPProtocolIcmpv6 constant
+	IPProtocolIcmpv6 IPProtocol = 0x3A
+)
+
+// The following structure is included in each flow which further is
+// used to create a flow. The match structure is used to specify the
+// match rules encoded into the flow.
+
+// Match structure
+type Match struct {
+	InPort        uint32
+	MatchVlan     VlanType
+	SrcMacMatch   bool
+	SrcMacAddr    net.HardwareAddr
+	SrcMacMask    net.HardwareAddr
+	DstMacMatch   bool
+	DstMacAddr    net.HardwareAddr
+	DstMacMask    net.HardwareAddr
+	MatchPbits    bool
+	Pbits         PbitType
+	L3Protocol    EtherType
+	SrcIpv4Match  bool
+	SrcIpv4Addr   net.IP
+	DstIpv4Match  bool
+	DstIpv4Addr   net.IP
+	L4Protocol    IPProtocol
+	SrcPort       uint16
+	DstPort       uint16
+	TableMetadata uint64
+}
+
+// Reset to be used when a Match is created. It sets the values to
+// defaults which results is no match rules at all and thus when
+// applied on a port, match all packets. The match rules must be
+// set before use.
+func (m *Match) Reset() {
+	m.MatchVlan = VlanNone
+	m.SrcMacMatch = false
+	m.DstMacMatch = false
+	m.MatchPbits = false
+	m.L3Protocol = EtherTypeAny
+	m.L4Protocol = IPProtocolIgnore
+	m.SrcPort = 0
+	m.DstPort = 0
+	m.TableMetadata = 0
+}
+
+// SetInPort to set in port
+func (m *Match) SetInPort(port uint32) {
+	m.InPort = port
+}
+
+// SetMatchVlan to set match vlan
+func (m *Match) SetMatchVlan(vlan VlanType) {
+	m.MatchVlan = vlan
+}
+
+// SetPppoeDiscoveryMatch to set L3 protocol
+func (m *Match) SetPppoeDiscoveryMatch() {
+	m.L3Protocol = EtherTypePppoeDiscovery
+}
+
+// SetTableMetadata to set table metadata
+func (m *Match) SetTableMetadata(metadata uint64) {
+	m.TableMetadata = metadata
+}
+
+// SetMatchSrcMac to set source mac address
+func (m *Match) SetMatchSrcMac(mac net.HardwareAddr) {
+	m.SrcMacMatch = true
+	m.SrcMacAddr = mac
+}
+
+// SetMatchDstMac to set destination mac address
+func (m *Match) SetMatchDstMac(mac net.HardwareAddr) {
+	m.DstMacMatch = true
+	m.DstMacAddr = mac
+}
+
+// SetMatchPbit to set pbits
+func (m *Match) SetMatchPbit(pbit PbitType) {
+	m.MatchPbits = true
+	m.Pbits = pbit
+}
+
+// SetMatchSrcIpv4 to set source ipv4 address
+func (m *Match) SetMatchSrcIpv4(ip net.IP) {
+	m.SrcIpv4Match = true
+	m.SrcIpv4Addr = ip
+}
+
+// SetMatchDstIpv4 to set destination ipv4 address
+func (m *Match) SetMatchDstIpv4(ip net.IP) {
+	m.DstIpv4Match = true
+	m.DstIpv4Addr = ip
+}
+
+// SetArpMatch to set L3 protocol as Arp
+func (m *Match) SetArpMatch() {
+	m.L3Protocol = EtherTypeArp
+}
+
+// SetICMPv6Match to set L3 and L4 protocol as IPV6 and ICMPv6
+func (m *Match) SetICMPv6Match() {
+	m.L3Protocol = EtherTypeIpv6
+	m.L4Protocol = IPProtocolIcmpv6
+}
+
+// SetUdpv4Match to set L3 and L4 protocol as IPv4 and UDP
+func (m *Match) SetUdpv4Match() {
+	m.L3Protocol = EtherTypeIpv4
+	m.L4Protocol = IPProtocolUDP
+}
+
+// SetIgmpMatch to set L3 and L4 protocol as IPv4 and Igmp
+func (m *Match) SetIgmpMatch() {
+	m.L3Protocol = EtherTypeIpv4
+	m.L4Protocol = IPProtocolIgmp
+}
+
+// SetUdpv6Match to set L3 and L4 protocol as IPv6 and UDP
+func (m *Match) SetUdpv6Match() {
+	m.L3Protocol = EtherTypeIpv6
+	m.L4Protocol = IPProtocolUDP
+}
+
+// SetIpv4Match to set L3 as IPv4
+func (m *Match) SetIpv4Match() {
+	m.L3Protocol = EtherTypeIpv4
+}
+
+// OutputType type
+type OutputType uint8
+
+const (
+	// OutputTypeDrop constant
+	OutputTypeDrop OutputType = 1
+	// OutputTypeToController constant
+	OutputTypeToController OutputType = 2
+	// OutputTypeToNetwork constant
+	OutputTypeToNetwork OutputType = 3
+	// OutputTypeGoToTable constant
+	OutputTypeGoToTable OutputType = 4
+	// OutputTypeToGroup constant
+	OutputTypeToGroup OutputType = 5
+)
+
+const (
+	// FlowAddSuccess constant
+	FlowAddSuccess = 0
+	// FlowAddFailure constant
+	FlowAddFailure = 1
+	// FlowAddPending constant
+	FlowAddPending = 2
+	// FlowDelPending constant
+	FlowDelPending = 3
+	// FlowDelFailure constant
+	FlowDelFailure = 4
+)
+
+// Action structure
+type Action struct {
+	Output      OutputType
+	PushVlan    []VlanType
+	EtherType   layers.EthernetType
+	SetVlan     VlanType
+	RemoveVlan  int
+	OutPort     uint32
+	GoToTableID uint32
+	Metadata    uint64
+	MeterID     uint32
+	Pcp         PbitType
+}
+
+const (
+	// PbitNone constant
+	PbitNone PbitType = 8
+)
+
+// Reset the action structure
+func (a *Action) Reset() {
+	a.Output = OutputTypeDrop
+	a.PushVlan = make([]VlanType, 0)
+	a.SetVlan = VlanNone
+	a.RemoveVlan = 0
+	a.Metadata = 0
+	a.MeterID = 0
+	a.Pcp = PbitNone
+}
+
+// SetReportToController for set action to report to controller
+func (a *Action) SetReportToController() {
+	a.Output = OutputTypeToController
+	a.OutPort = ControllerPort
+}
+
+// SetPushVlan for set action to push to vlan
+func (a *Action) SetPushVlan(vlan VlanType, etherType layers.EthernetType) {
+	a.PushVlan = append(a.PushVlan, vlan)
+	a.EtherType = etherType
+}
+
+// SetSetVlan to set SetVlan
+func (a *Action) SetSetVlan(vlan VlanType) {
+	a.SetVlan = vlan
+}
+
+// SetPopVlan to set remove vlan counter
+func (a *Action) SetPopVlan() {
+	a.RemoveVlan++
+}
+
+// SetMeterID to set meter id
+func (a *Action) SetMeterID(meterID uint32) {
+	a.MeterID = meterID
+}
+
+// SetWriteMetadata to set metadata
+func (a *Action) SetWriteMetadata(metadata uint64) {
+	a.Metadata = metadata
+}
+
+// SetPcp to set pcp
+func (a *Action) SetPcp(pcp PbitType) {
+	a.Pcp = pcp
+}
+
+// GetWriteMetadata returns metadata
+func (a *Action) GetWriteMetadata() uint64 {
+	return a.Metadata
+}
+
+// SetOutPort to set output port
+func (a *Action) SetOutPort(port uint32) {
+	a.Output = OutputTypeToNetwork
+	a.OutPort = port
+}
+
+// SetOutGroup to set output group
+func (a *Action) SetOutGroup(group uint32) {
+	a.Output = OutputTypeToGroup
+	a.OutPort = group
+}
+
+// SetGoToTable to set GoToTableID
+func (a *Action) SetGoToTable(table uint32) {
+	a.Output = OutputTypeGoToTable
+	a.GoToTableID = table
+}
+
+// VoltSubFlow structure
+type VoltSubFlow struct {
+	Cookie     uint64
+	CookieMask uint64
+	// OldCookie is used in vgc upgrade when there is cookie generation logic change.
+	OldCookie   uint64
+	TableID     uint32
+	Priority    uint32
+	State       uint8
+	ErrorReason string
+	Match
+	Action
+}
+
+// NewVoltSubFlow is constructor for VoltSubFlow
+func NewVoltSubFlow() *VoltSubFlow {
+	var sf VoltSubFlow
+	sf.Match.Reset()
+	sf.Action.Reset()
+	return &sf
+}
+
+// SetTableID to set table id
+func (sf *VoltSubFlow) SetTableID(tableID uint32) {
+	sf.TableID = tableID
+}
+
+// Command type
+type Command uint8
+
+const (
+	// CommandAdd constant
+	CommandAdd Command = 0
+	// CommandDel constant
+	CommandDel Command = 1
+)
+
+// VoltFlow : Definition of a flow
+type VoltFlow struct {
+	Command       Command
+	SubFlows      map[uint64]*VoltSubFlow
+	ForceAction   bool
+	MigrateCookie bool
+	// PortName and PortID to be used for validation of port before flow pushing
+	PortName string
+	PortID   uint32
+}
+
+const (
+	// PrevBwInfo indicates the string returned by core for bandwidth consumed before creating scheduler
+	PrevBwInfo string = "prevBW"
+	// PresentBwInfo indicates the string returned by core for bandwidth consumed after creating scheduler
+	PresentBwInfo string = "presentBW"
+)
+
+// BwAvailDetails consists of bw consumtion details at olt
+type BwAvailDetails struct {
+	PrevBw    string
+	PresentBw string
+}
+
+// -------------------------------------------------------------------
+// OPENFLOW Implementation of flows
+//
+// The flows constructed using the above structures is translated to
+// the VOLTHA OpenFlow GRPC structures. The code below is used to
+// construct the VOLTHA OF GRPC structures.
+const (
+	// DefaultMeterID constant
+	DefaultMeterID uint32 = 0x1
+	// DefaultBufferID constant
+	DefaultBufferID uint32 = 0xffffffff
+	// DefaultOutPort constant
+	DefaultOutPort uint32 = 0xffffffff
+	// DefaultOutGroup constant
+	DefaultOutGroup uint32 = 0xffffffff
+	// DefaultFlags constant
+	DefaultFlags uint32 = 0x1
+)
+
+// NewInportMatch for inport info
+func NewInportMatch(port uint32) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_IN_PORT
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_Port{Port: port}
+	return &entry
+}
+
+// NewTableMetadataMatch for table metadata
+func NewTableMetadataMatch(metadata uint64) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_METADATA
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_TableMetadata{TableMetadata: metadata}
+	return &entry
+}
+
+// NewSrcMacAddrMatch for source mac address info
+func NewSrcMacAddrMatch(addr []byte) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_ETH_SRC
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_EthSrc{EthSrc: addr}
+	return &entry
+}
+
+// NewDstMacAddrMatch for destination mac address info
+func NewDstMacAddrMatch(addr []byte) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_ETH_DST
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_EthDst{EthDst: addr}
+	return &entry
+}
+
+// NewVlanMatch for vlan info
+func NewVlanMatch(vlan uint16) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_VlanVid{VlanVid: uint32(vlan&0x0fff + 0x1000)}
+	mf.Mask = &ofp.OfpOxmOfbField_VlanVidMask{VlanVidMask: uint32(0x1000)}
+	return &entry
+}
+
+// NewPcpMatch for pcp info
+func NewPcpMatch(pbits PbitType) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_VlanPcp{VlanPcp: uint32(pbits)}
+	return &entry
+}
+
+// NewEthTypeMatch for eth type info
+func NewEthTypeMatch(l3proto uint16) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_ETH_TYPE
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_EthType{EthType: uint32(l3proto)}
+	return &entry
+}
+
+// ipv4ToUint to convert ipv4 to uint
+func ipv4ToUint(ip net.IP) uint32 {
+	result := uint32(0)
+	addr := ip.To4()
+	if addr == nil {
+		logger.Warnw(ctx, "Invalid Group Addr", log.Fields{"IP": ip})
+		return 0
+	}
+	result = result + uint32(addr[0])<<24
+	result = result + uint32(addr[1])<<16
+	result = result + uint32(addr[2])<<8
+	result = result + uint32(addr[3])
+	return result
+}
+
+// NewIpv4SrcMatch for ipv4 source address
+func NewIpv4SrcMatch(ip net.IP) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_SRC
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_Ipv4Src{Ipv4Src: ipv4ToUint(ip)}
+	return &entry
+}
+
+// NewIpv4DstMatch for ipv4 destination address
+func NewIpv4DstMatch(ip net.IP) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_IPV4_DST
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_Ipv4Dst{Ipv4Dst: ipv4ToUint(ip)}
+	return &entry
+}
+
+// NewIPProtoMatch for ip proto info
+func NewIPProtoMatch(l4proto uint16) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_IP_PROTO
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_IpProto{IpProto: uint32(l4proto)}
+	return &entry
+}
+
+// NewUDPSrcMatch for source udp info
+func NewUDPSrcMatch(port uint16) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_UDP_SRC
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_UdpSrc{UdpSrc: uint32(port)}
+	return &entry
+}
+
+// NewUDPDstMatch for destination udp info
+func NewUDPDstMatch(port uint16) *ofp.OfpOxmField {
+	var entry ofp.OfpOxmField
+	var mf ofp.OfpOxmOfbField
+	entry.OxmClass = ofp.OfpOxmClass_OFPXMC_OPENFLOW_BASIC
+	entry.Field = &ofp.OfpOxmField_OfbField{OfbField: &mf}
+	mf.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_UDP_DST
+	mf.HasMask = false
+	mf.Value = &ofp.OfpOxmOfbField_UdpDst{UdpDst: uint32(port)}
+	return &entry
+}
+
+// NewMeterIDInstruction for meter id instructions
+func NewMeterIDInstruction(meterID uint32) *ofp.OfpInstruction {
+	var meter ofp.OfpInstruction
+	meter.Type = uint32(ofp.OfpInstructionType_OFPIT_METER)
+	meter.Data = &ofp.OfpInstruction_Meter{
+		Meter: &ofp.OfpInstructionMeter{
+			MeterId: meterID,
+		},
+	}
+	return &meter
+}
+
+// NewGoToTableInstruction for go to table instructions
+func NewGoToTableInstruction(table uint32) *ofp.OfpInstruction {
+	var gotoTable ofp.OfpInstruction
+	gotoTable.Type = uint32(ofp.OfpInstructionType_OFPIT_GOTO_TABLE)
+	gotoTable.Data = &ofp.OfpInstruction_GotoTable{
+		GotoTable: &ofp.OfpInstructionGotoTable{
+			TableId: table,
+		},
+	}
+	return &gotoTable
+}
+
+// NewPopVlanInstruction for pop vlan instructions
+func NewPopVlanInstruction() *ofp.OfpInstruction {
+	var removeTag ofp.OfpInstruction
+	var actions ofp.OfpInstructionActions
+	removeTag.Type = uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+	removeTag.Data = &ofp.OfpInstruction_Actions{
+		Actions: &actions,
+	}
+	action := flows.PopVlan()
+	actions.Actions = append(actions.Actions, action)
+	return &removeTag
+}
+
+// NewWriteMetadataInstruction for write metadata instructions
+func NewWriteMetadataInstruction(metadata uint64) *ofp.OfpInstruction {
+	var md ofp.OfpInstruction
+	md.Type = uint32(ofp.OfpInstructionType_OFPIT_WRITE_METADATA)
+	md.Data = &ofp.OfpInstruction_WriteMetadata{WriteMetadata: &ofp.OfpInstructionWriteMetadata{Metadata: metadata}}
+	return &md
+}
+
+// NewPopVlanAction for pop vlan action
+func NewPopVlanAction() *ofp.OfpAction {
+	return flows.PopVlan()
+}
+
+// NewPushVlanInstruction for push vlan instructions
+func NewPushVlanInstruction(vlan uint16, etherType uint32) *ofp.OfpInstruction {
+	var addTag ofp.OfpInstruction
+	var actions ofp.OfpInstructionActions
+	addTag.Type = uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+	addTag.Data = &ofp.OfpInstruction_Actions{
+		Actions: &actions,
+	}
+	pushAction := flows.PushVlan(etherType)
+	actions.Actions = append(actions.Actions, pushAction)
+	var setField ofp.OfpOxmOfbField
+	setField.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID
+	setField.HasMask = false
+	setField.Value = &ofp.OfpOxmOfbField_VlanVid{
+		VlanVid: uint32(vlan&0x0fff + 0x1000),
+	}
+	setAction := flows.SetField(&setField)
+	actions.Actions = append(actions.Actions, setAction)
+	return &addTag
+}
+
+// NewPushVlanAction for push vlan action
+func NewPushVlanAction(etherType uint32) *ofp.OfpAction {
+	pushAction := flows.PushVlan(etherType)
+	return pushAction
+}
+
+// NewSetVlanAction for set vlan action
+func NewSetVlanAction(vlan uint16) *ofp.OfpAction {
+	var setField ofp.OfpOxmOfbField
+	setField.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_VID
+	setField.HasMask = false
+	and := (vlan & 0xfff)
+	or := and + 0x1000
+	v := uint32(vlan&0x0fff + 0x1000)
+	logger.Infow(ctx, "Vlan Construction", log.Fields{"Vlan": vlan, "vlan&0x0fff": and, "OR": or, "final": v})
+	setField.Value = &ofp.OfpOxmOfbField_VlanVid{
+		VlanVid: uint32(vlan&0x0fff + 0x1000),
+	}
+	setAction := flows.SetField(&setField)
+	return setAction
+}
+
+// NewSetPcpAction for set pcap action
+func NewSetPcpAction(pbits PbitType) *ofp.OfpAction {
+	var setField ofp.OfpOxmOfbField
+	setField.Type = ofp.OxmOfbFieldTypes_OFPXMT_OFB_VLAN_PCP
+	setField.HasMask = false
+	setField.Value = &ofp.OfpOxmOfbField_VlanPcp{VlanPcp: uint32(pbits)}
+	setAction := flows.SetField(&setField)
+	return setAction
+}
+
+// NewOutputInstruction for output instructions
+func NewOutputInstruction(port uint32) *ofp.OfpInstruction {
+	var outport ofp.OfpInstruction
+	var actions ofp.OfpInstructionActions
+	outport.Type = uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+	outport.Data = &ofp.OfpInstruction_Actions{
+		Actions: &actions,
+	}
+	action := flows.Output(port, 65535)
+	actions.Actions = append(actions.Actions, action)
+	return &outport
+}
+
+// NewOutputAction for output action
+func NewOutputAction(port uint32) *ofp.OfpAction {
+	return flows.Output(port, 65535)
+}
+
+// NewGroupOutputInstruction for group output instructions
+func NewGroupOutputInstruction(group uint32) *ofp.OfpInstruction {
+	var outgroup ofp.OfpInstruction
+	var actions ofp.OfpInstructionActions
+	outgroup.Type = uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+	outgroup.Data = &ofp.OfpInstruction_Actions{
+		Actions: &actions,
+	}
+	action := flows.Group(group)
+	actions.Actions = append(actions.Actions, action)
+	return &outgroup
+}
+
+// NewGroupAction for group action
+func NewGroupAction(group uint32) *ofp.OfpAction {
+	return flows.Group(group)
+}
+
+// CreateMatchAndActions to create match list and action
+func CreateMatchAndActions(f *VoltSubFlow) ([]*ofp.OfpOxmField, []*ofp.OfpInstruction) {
+	logger.Debug(ctx, "Create Match and Action called")
+
+	// Return values declared here
+	var matchList []*ofp.OfpOxmField
+	var instructions []*ofp.OfpInstruction
+
+	// Construct the match rules
+	// Add match in port
+	if f.Match.InPort != 0 {
+		entry := NewInportMatch(uint32(f.Match.InPort))
+		matchList = append(matchList, entry)
+	}
+
+	// Add table metadata match
+	if f.Match.TableMetadata != 0 {
+		entry := NewTableMetadataMatch(uint64(f.Match.TableMetadata))
+		matchList = append(matchList, entry)
+	}
+
+	// Add Src MAC address match
+	if f.SrcMacMatch {
+		entry := NewSrcMacAddrMatch(f.SrcMacAddr)
+		matchList = append(matchList, entry)
+	}
+
+	// Add Src MAC address match
+	if f.DstMacMatch {
+		entry := NewDstMacAddrMatch(f.DstMacAddr)
+		matchList = append(matchList, entry)
+	}
+
+	// Add VLAN tag match
+	if f.MatchVlan != VlanNone {
+		entry := NewVlanMatch(uint16(f.MatchVlan))
+		matchList = append(matchList, entry)
+	}
+
+	if f.MatchPbits {
+		entry := NewPcpMatch(f.Pbits)
+		matchList = append(matchList, entry)
+	}
+
+	// Add EtherType match
+	if f.L3Protocol != EtherTypeAny {
+		entry := NewEthTypeMatch(uint16(f.L3Protocol))
+		matchList = append(matchList, entry)
+	}
+
+	// Add the Src IPv4 addr match
+	if f.SrcIpv4Match {
+		entry := NewIpv4SrcMatch(f.SrcIpv4Addr)
+		matchList = append(matchList, entry)
+	}
+
+	// Add the Dst IPv4 addr match
+	if f.DstIpv4Match {
+		entry := NewIpv4DstMatch(f.DstIpv4Addr)
+		matchList = append(matchList, entry)
+	}
+
+	// Add IP protocol match
+	if f.L4Protocol != IPProtocolIgnore {
+		entry := NewIPProtoMatch(uint16(f.L4Protocol))
+		matchList = append(matchList, entry)
+	}
+
+	// Add UDP Source port match
+	if f.SrcPort != 0 {
+		entry := NewUDPSrcMatch(uint16(f.SrcPort))
+		matchList = append(matchList, entry)
+	}
+
+	// Add UDP Dest port match
+	if f.DstPort != 0 {
+		entry := NewUDPDstMatch(uint16(f.DstPort))
+		matchList = append(matchList, entry)
+	}
+
+	// Construct the instructions
+	// Add a GOTO table action
+	if f.Output == OutputTypeGoToTable {
+		instruction := NewGoToTableInstruction(f.GoToTableID)
+		instructions = append(instructions, instruction)
+	}
+
+	// Add the meter instruction
+	if f.MeterID != 0 {
+		instruction := NewMeterIDInstruction(f.MeterID)
+		instructions = append(instructions, instruction)
+	}
+
+	// Add the metadata instruction
+	if f.Metadata != 0 {
+		instruction := NewWriteMetadataInstruction(f.Metadata)
+		instructions = append(instructions, instruction)
+	}
+
+	// The below are all apply actions. All of these could be combined into
+	// a single instruction.
+	{
+		var instruction ofp.OfpInstruction
+		var actions ofp.OfpInstructionActions
+		instruction.Type = uint32(ofp.OfpInstructionType_OFPIT_APPLY_ACTIONS)
+		instruction.Data = &ofp.OfpInstruction_Actions{
+			Actions: &actions,
+		}
+
+		// Apply action of popping the VLAN
+		if f.RemoveVlan != 0 {
+			for i := 0; i < f.RemoveVlan; i++ {
+				action := NewPopVlanAction()
+				actions.Actions = append(actions.Actions, action)
+			}
+		}
+
+		if f.SetVlan != VlanNone {
+			action := NewSetVlanAction(uint16(f.SetVlan))
+			actions.Actions = append(actions.Actions, action)
+		}
+
+		if f.Pcp != PbitNone {
+			action := NewSetPcpAction(f.Pcp)
+			actions.Actions = append(actions.Actions, action)
+		}
+
+		// Add the VLAN PUSH
+		if len(f.PushVlan) != 0 {
+			action := NewPushVlanAction(uint32(f.EtherType))
+			actions.Actions = append(actions.Actions, action)
+			for _, vlan := range f.PushVlan {
+				action = NewSetVlanAction(uint16(vlan))
+				actions.Actions = append(actions.Actions, action)
+			}
+		}
+
+		if f.Action.Output == OutputTypeToController {
+			action := NewOutputAction(0xfffffffd)
+			actions.Actions = append(actions.Actions, action)
+		} else if f.Action.Output == OutputTypeToNetwork {
+			action := NewOutputAction(f.OutPort)
+			actions.Actions = append(actions.Actions, action)
+		} else if f.Action.Output == OutputTypeToGroup {
+			action := NewGroupAction(f.OutPort)
+			actions.Actions = append(actions.Actions, action)
+		}
+		instructions = append(instructions, &instruction)
+	}
+
+	return matchList, instructions
+}
+
+// CreateFlow to create flow
+func CreateFlow(device string, command ofp.OfpFlowModCommand, matches []*ofp.OfpOxmField,
+	instructions []*ofp.OfpInstruction, sf *VoltSubFlow) *ofp.FlowTableUpdate {
+	flowUpdate := ofp.FlowTableUpdate{
+		Id: device,
+		FlowMod: &ofp.OfpFlowMod{
+			Cookie:      sf.Cookie,
+			CookieMask:  sf.CookieMask,
+			TableId:     sf.TableID,
+			Command:     command,
+			IdleTimeout: uint32(0),
+			HardTimeout: uint32(0),
+			Priority:    sf.Priority,
+			BufferId:    DefaultBufferID,
+			OutPort:     DefaultOutPort,
+			OutGroup:    DefaultOutGroup,
+			Flags:       DefaultFlags,
+			Match: &ofp.OfpMatch{
+				Type:      ofp.OfpMatchType_OFPMT_OXM,
+				OxmFields: matches,
+			},
+
+			Instructions: instructions,
+		},
+	}
+	return &flowUpdate
+}
+
+// Processing logic for the VOLT flows. The VOLT flows are different from
+// the normal openflows. Each VOLT flow may break into multiple flows.
+// The order of processing:
+// 1. If the flow has to match more than one VLAN tag, it is broken into
+//    more than one flow.
+// 2. When more than one flow is creatd, the higher layer processing is
+//    broken into the second flow. The first flow includes only the
+//    the processing of first VLAN tag.
+// 3. The a sinle flow is created, the first flow has all the match criteria
+//    and action.
+
+// ProcessVoltFlow to process volt flow
+func ProcessVoltFlow(device string, operation Command, subFlow map[uint64]*VoltSubFlow) []*ofp.FlowTableUpdate {
+	var flows []*ofp.FlowTableUpdate
+	var command ofp.OfpFlowModCommand
+	if operation == CommandAdd {
+		command = ofp.OfpFlowModCommand_OFPFC_ADD
+	} else {
+		command = ofp.OfpFlowModCommand_OFPFC_DELETE_STRICT
+	}
+	for _, sf := range subFlow {
+		logger.Debugw(ctx, "Flow Construction for", log.Fields{"Flow": sf})
+		match, instruction := CreateMatchAndActions(sf)
+		flow := CreateFlow(device, command, match, instruction, sf)
+		logger.Debugw(ctx, "Flow Constructed", log.Fields{"Flow": flow})
+		flows = append(flows, flow)
+	}
+	return flows
+}
+
+func init() {
+	// Setup this package so that it's log level can be modified at run time
+	var err error
+	logger, err = log.RegisterPackage(log.JSON, log.ErrorLevel, log.Fields{})
+	if err != nil {
+		panic(err)
+	}
+}