P4 runtime example: dynamically change the transmission paths

[Topology]

Based on https://github.com/p4lang/tutorials/tree/master/exercises/p4runtime, I change the mycontroller.py to let the h1 to send packets via path s1-s2 to h2 and switch to path s1-s3-s2. Each three seconds, the path changes again. (If you want to run the code, please download the p4runtime3.tar.gzhttps://nqucsie.myqnapcloud.com/smallko/sdn/p4runtime3.tar.gz)

[what I has done]

1. Change the file p4runtime3\p4runtime\switch.py (see the code in red. I add DeleteTableEntry method. Because when I need to change the path, I need to delete all rules that are already in the switches.)

2. from abc import abstractmethod

3.

4. import grpc

5. from p4 import p4runtime_pb2

6. from p4.tmp import p4config_pb2

7.

8. class SwitchConnection(object):

9. def __init__(self, name, address='127.0.0.1:50051', device_id=0):

10. self.name = name

11. self.address = address

12. self.device_id = device_id

13. self.p4info = None

14. self.channel = grpc.insecure_channel(self.address)

15. self.client_stub = p4runtime_pb2.P4RuntimeStub(self.channel)

16.

17. self._reqs = []

18.

19. @abstractmethod

20. def buildDeviceConfig(self, **kwargs):

21. return p4config_pb2.P4DeviceConfig()

22.

23. def SetForwardingPipelineConfig(self, p4info, dry_run=False, **kwargs):

24. device_config = self.buildDeviceConfig(**kwargs)

25. request = p4runtime_pb2.SetForwardingPipelineConfigRequest()

26. request.device_id = self.device_id

27. config = request.config

28. config.p4info.CopyFrom(p4info)

29. config.p4_device_config = device_config.SerializeToString()

30. request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT

31. if dry_run:

32. print "P4 Runtime SetForwardingPipelineConfig:", request

33. else:

34. self.client_stub.SetForwardingPipelineConfig(request)

35.

36. def DeleteTableEntry(self, dry_run=False):

37. print "DeleteTableEntry() is called, device_id=", self.device_id

38. updates = []

39. for req in reversed(self._reqs):

40. for update in reversed(req.updates):

41. if update.type == p4runtime_pb2.Update.INSERT:

42. updates.append(update)

43. new_req = p4runtime_pb2.WriteRequest()

44. new_req.device_id = self.device_id

45. for update in updates:

46. update.type = p4runtime_pb2.Update.DELETE

47. new_req.updates.add().CopyFrom(update)

48. if dry_run:

49. print "P4 Runtime Write:", new_req

50. else:

51. self.client_stub.Write(new_req)

52.

53. def WriteTableEntry(self, table_entry, dry_run=False):

54. request = p4runtime_pb2.WriteRequest()

55. request.device_id = self.device_id

56. update = request.updates.add()

57. update.type = p4runtime_pb2.Update.INSERT

58. update.entity.table_entry.CopyFrom(table_entry)

59. if dry_run:

60. print "P4 Runtime Write:", request

61. else:

62. self.client_stub.Write(request)

63. self._reqs.append(request)

64.

65. def ReadTableEntries(self, table_id=None, dry_run=False):

66. request = p4runtime_pb2.ReadRequest()

67. request.device_id = self.device_id

68. entity = request.entities.add()

69. table_entry = entity.table_entry

70. if table_id is not None:

71. table_entry.table_id = table_id

72. else:

73. table_entry.table_id = 0

74. if dry_run:

75. print "P4 Runtime Read:", request

76. else:

77. for response in self.client_stub.Read(request):

78. #print "response=", response

79. yield response

80.

81. def ReadCounters(self, counter_id=None, index=None, dry_run=False):

82. request = p4runtime_pb2.ReadRequest()

83. request.device_id = self.device_id

84. entity = request.entities.add()

85. counter_entry = entity.counter_entry

86. if counter_id is not None:

87. counter_entry.counter_id = counter_id

88. else:

89. counter_entry.counter_id = 0

90. if index is not None:

91. counter_entry.index = index

92. if dry_run:

93. print "P4 Runtime Read:", request

94. else:

95. for response in self.client_stub.Read(request):

96. yield response

2. solution\mycontroller.py (add the code for path change)

#!/usr/bin/env python2

import argparse

import os

from time import sleep

# NOTE: Appending to the PYTHON_PATH is only required in the `solution` directory.

# It is not required for mycontroller.py in the top-level directory.

import sys

sys.path.append(os.path.join(os.path.dirname(__file__), '..'))

import p4runtime_lib.bmv2

import p4runtime_lib.helper

SWITCH_TO_HOST_PORT = 1

SWITCH_TO_SWITCH_PORT = 2

SWITCH_TO_SWITCH_PORTs1tos3 = 3

SWITCH_TO_SWITCH_PORTs3tos1 = 2

SWITCH_TO_SWITCH_PORTh1toh2vias3_link1 = 3

SWITCH_TO_SWITCH_PORTh1toh2vias3_link2 = 3

SWITCH_TO_SWITCH_PORTh2toh1vias3_link1 = 3

SWITCH_TO_SWITCH_PORTh2toh1vias3_link2 = 2

def clearTunnelRule(p4info_helper, mysw):

print "Clear rules on %s" % mysw.name

mysw.DeleteTableEntry()

def writeTunnelRules3(p4info_helper, ingress_sw, egress_sw, tunnel_id,

dst_eth_addr, dst_ip_addr, int_sw, myport1, myport2):

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.ipv4_lpm",

match_fields={

"hdr.ipv4.dstAddr": (dst_ip_addr, 32)

},

action_name="MyIngress.myTunnel_ingress",

action_params={

"dst_id": tunnel_id,

})

ingress_sw.WriteTableEntry(table_entry)

print "Installed ingress tunnel rule on %s" % ingress_sw.name

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_forward",

action_params={

"port": myport1

})

ingress_sw.WriteTableEntry(table_entry)

print "Installed transit tunnel rule on %s" % ingress_sw.name

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_forward",

action_params={

"port": myport2

})

int_sw.WriteTableEntry(table_entry)

print "Installed transit tunnel rule on %s" % int_sw.name

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_egress",

action_params={

"dstAddr": dst_eth_addr,

"port": SWITCH_TO_HOST_PORT

})

egress_sw.WriteTableEntry(table_entry)

print "Installed egress tunnel rule on %s" % egress_sw.name

def writeTunnelRules2(p4info_helper, ingress_sw, egress_sw, tunnel_id,

dst_eth_addr, dst_ip_addr, myport):

# 1) Tunnel Ingress Rule

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.ipv4_lpm",

match_fields={

"hdr.ipv4.dstAddr": (dst_ip_addr, 32)

},

action_name="MyIngress.myTunnel_ingress",

action_params={

"dst_id": tunnel_id,

})

ingress_sw.WriteTableEntry(table_entry)

print "Installed ingress tunnel rule on %s" % ingress_sw.name

# 2) Tunnel Transit Rule

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_forward",

action_params={

"port": myport

})

ingress_sw.WriteTableEntry(table_entry)

print "Installed transit tunnel rule on %s" % ingress_sw.name

# 3) Tunnel Egress Rule

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_egress",

action_params={

"dstAddr": dst_eth_addr,

"port": SWITCH_TO_HOST_PORT

})

egress_sw.WriteTableEntry(table_entry)

print "Installed egress tunnel rule on %s" % egress_sw.name

def writeTunnelRules(p4info_helper, ingress_sw, egress_sw, tunnel_id,

dst_eth_addr, dst_ip_addr):

'''

Installs three rules:

1) An tunnel ingress rule on the ingress switch in the ipv4_lpm table that

encapsulates traffic into a tunnel with the specified ID

2) A transit rule on the ingress switch that forwards traffic based on

the specified ID

3) An tunnel egress rule on the egress switch that decapsulates traffic

with the specified ID and sends it to the host

:param p4info_helper: the P4Info helper

:param ingress_sw: the ingress switch connection

:param egress_sw: the egress switch connection

:param tunnel_id: the specified tunnel ID

:param dst_eth_addr: the destination IP to match in the ingress rule

:param dst_ip_addr: the destination Ethernet address to write in the

egress rule

'''

# 1) Tunnel Ingress Rule

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.ipv4_lpm",

match_fields={

"hdr.ipv4.dstAddr": (dst_ip_addr, 32)

},

action_name="MyIngress.myTunnel_ingress",

action_params={

"dst_id": tunnel_id,

})

ingress_sw.WriteTableEntry(table_entry)

print "Installed ingress tunnel rule on %s" % ingress_sw.name

# 2) Tunnel Transit Rule

# The rule will need to be added to the myTunnel_exact table and match on

# the tunnel ID (hdr.myTunnel.dst_id). Traffic will need to be forwarded

# using the myTunnel_forward action on the port connected to the next switch.

#

# For our simple topology, switch 1 and switch 2 are connected using a

# link attached to port 2 on both switches. We have defined a variable at

# the top of the file, SWITCH_TO_SWITCH_PORT, that you can use as the output

# port for this action.

#

# We will only need a transit rule on the ingress switch because we are

# using a simple topology. In general, you'll need on transit rule for

# each switch in the path (except the last switch, which has the egress rule),

# and you will need to select the port dynamically for each switch based on

# your topology.

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_forward",

action_params={

"port": SWITCH_TO_SWITCH_PORT

})

ingress_sw.WriteTableEntry(table_entry)

print "Installed transit tunnel rule on %s" % ingress_sw.name

# 3) Tunnel Egress Rule

# For our simple topology, the host will always be located on the

# SWITCH_TO_HOST_PORT (port 1).

# In general, you will need to keep track of which port the host is

# connected to.

table_entry = p4info_helper.buildTableEntry(

table_name="MyIngress.myTunnel_exact",

match_fields={

"hdr.myTunnel.dst_id": tunnel_id

},

action_name="MyIngress.myTunnel_egress",

action_params={

"dstAddr": dst_eth_addr,

"port": SWITCH_TO_HOST_PORT

})

egress_sw.WriteTableEntry(table_entry)

print "Installed egress tunnel rule on %s" % egress_sw.name

def readTableRules(p4info_helper, sw):

'''

Reads the table entries from all tables on the switch.

:param p4info_helper: the P4Info helper

:param sw: the switch connection

'''

print '\n----- Reading tables rules for %s -----' % sw.name

for response in sw.ReadTableEntries():

for entity in response.entities:

entry = entity.table_entry

# TODO For extra credit, you can use the p4info_helper to translate

# the IDs the entry to names

table_name = p4info_helper.get_tables_name(entry.table_id)

print '%s: ' % table_name,

for m in entry.match:

print p4info_helper.get_match_field_name(table_name, m.field_id),

print '%r' % (p4info_helper.get_match_field_value(m),),

action = entry.action.action

action_name = p4info_helper.get_actions_name(action.action_id)

print '->', action_name,

for p in action.params:

print p4info_helper.get_action_param_name(action_name, p.param_id),

print '%r' % p.value,

print

def printCounter(p4info_helper, sw, counter_name, index):

'''

Reads the specified counter at the specified index from the switch. In our

program, the index is the tunnel ID. If the index is 0, it will return all

values from the counter.

:param p4info_helper: the P4Info helper

:param sw: the switch connection

:param counter_name: the name of the counter from the P4 program

:param index: the counter index (in our case, the tunnel ID)

'''

for response in sw.ReadCounters(p4info_helper.get_counters_id(counter_name), index):

for entity in response.entities:

counter = entity.counter_entry

print "%s %s %d: %d packets (%d bytes)" % (

sw.name, counter_name, index,

counter.data.packet_count, counter.data.byte_count

)

def main(p4info_file_path, bmv2_file_path):

# Instantiate a P4 Runtime helper from the p4info file

p4info_helper = p4runtime_lib.helper.P4InfoHelper(p4info_file_path)

# Create a switch connection object for s1 and s2;

# this is backed by a P4 Runtime gRPC connection

s1 = p4runtime_lib.bmv2.Bmv2SwitchConnection('s1',

address='127.0.0.1:50051',

device_id=0)

s2 = p4runtime_lib.bmv2.Bmv2SwitchConnection('s2',

address='127.0.0.1:50052',

device_id=1)

s3 = p4runtime_lib.bmv2.Bmv2SwitchConnection('s3',

address='127.0.0.1:50053',

device_id=2)

# Install the P4 program on the switches

s1.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,

bmv2_json_file_path=bmv2_file_path)

print "Installed P4 Program using SetForwardingPipelineConfig on %s" % s1.name

s2.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,

bmv2_json_file_path=bmv2_file_path)

print "Installed P4 Program using SetForwardingPipelineConfig on %s" % s2.name

s3.SetForwardingPipelineConfig(p4info=p4info_helper.p4info,

bmv2_json_file_path=bmv2_file_path)

print "Installed P4 Program using SetForwardingPipelineConfig on %s" % s3.name

# Write the rules that tunnel traffic from h1 to h2

#writeTunnelRules(p4info_helper, ingress_sw=s1, egress_sw=s2, tunnel_id=100,

# dst_eth_addr="00:00:00:00:02:02", dst_ip_addr="10.0.2.2")

# Write the rules that tunnel traffic from h2 to h1

#writeTunnelRules(p4info_helper, ingress_sw=s2, egress_sw=s1, tunnel_id=200,

# dst_eth_addr="00:00:00:00:01:01", dst_ip_addr="10.0.1.1")

# Write the rules that tunnel traffic from h1 to h3

writeTunnelRules2(p4info_helper, ingress_sw=s1, egress_sw=s3, tunnel_id=300,

dst_eth_addr="00:00:00:00:03:03", dst_ip_addr="10.0.3.3", myport=SWITCH_TO_SWITCH_PORTs1tos3 )

# Write the rules that tunnel traffic from h3 to h1

writeTunnelRules2(p4info_helper, ingress_sw=s3, egress_sw=s1, tunnel_id=400,

dst_eth_addr="00:00:00:00:01:01", dst_ip_addr="10.0.1.1", myport=SWITCH_TO_SWITCH_PORTs3tos1 )

#Write the rules that tunnel traffic from h1 to h2 via s1-s3-s2

writeTunnelRules3(p4info_helper, ingress_sw=s1, egress_sw=s2, tunnel_id=500,

dst_eth_addr="00:00:00:00:02:02", dst_ip_addr="10.0.2.2", int_sw=s3, myport1=3, myport2=3)

#Write the rules that tunnel traffic from h2 to h1 via s2-s3-s1

writeTunnelRules3(p4info_helper, ingress_sw=s2, egress_sw=s1, tunnel_id=600,

dst_eth_addr="00:00:00:00:01:01", dst_ip_addr="10.0.1.1", int_sw=s3, myport1=3, myport2=2)

# TODO Uncomment the following two lines to read table entries from s1 and s2

readTableRules(p4info_helper, s1)

readTableRules(p4info_helper, s2)

readTableRules(p4info_helper, s3)

i=1

try:

while True:

i=(i+1)%2

print "i=", i

if i==0:

clearTunnelRule(p4info_helper, mysw=s1)

clearTunnelRule(p4info_helper, mysw=s2)

clearTunnelRule(p4info_helper, mysw=s3)

print "h1 to h2 via s1-s2"

writeTunnelRules(p4info_helper, ingress_sw=s1, egress_sw=s2, tunnel_id=100,

dst_eth_addr="00:00:00:00:02:02", dst_ip_addr="10.0.2.2")

writeTunnelRules(p4info_helper, ingress_sw=s2, egress_sw=s1, tunnel_id=200,

dst_eth_addr="00:00:00:00:01:01", dst_ip_addr="10.0.1.1")

elif i==1:

clearTunnelRule(p4info_helper, mysw=s1)

clearTunnelRule(p4info_helper, mysw=s2)

clearTunnelRule(p4info_helper, mysw=s3)

print "h1 to h2 via s1-s3-s2"

writeTunnelRules3(p4info_helper, ingress_sw=s1, egress_sw=s2, tunnel_id=500,

dst_eth_addr="00:00:00:00:02:02", dst_ip_addr="10.0.2.2", int_sw=s3, myport1=3, myport2=3)

writeTunnelRules3(p4info_helper, ingress_sw=s2, egress_sw=s1, tunnel_id=600,

dst_eth_addr="00:00:00:00:01:01", dst_ip_addr="10.0.1.1", int_sw=s3, myport1=3, myport2=2)

sleep(3)

#print '\n----- Reading tunnel counters -----'

#printCounter(p4info_helper, s1, "MyIngress.ingressTunnelCounter", 100)

#printCounter(p4info_helper, s2, "MyIngress.egressTunnelCounter", 100)

#printCounter(p4info_helper, s2, "MyIngress.ingressTunnelCounter", 200)

#printCounter(p4info_helper, s1, "MyIngress.egressTunnelCounter", 200)

except KeyboardInterrupt:

print " Shutting down."

if __name__ == '__main__':

parser = argparse.ArgumentParser(description='P4Runtime Controller')

parser.add_argument('--p4info', help='p4info proto in text format from p4c',

type=str, action="store", required=False,

default='./build/advanced_tunnel.p4info')

parser.add_argument('--bmv2-json', help='BMv2 JSON file from p4c',

type=str, action="store", required=False,

default='./build/advanced_tunnel.json')

args = parser.parse_args()

if not os.path.exists(args.p4info):

parser.print_help()

print "\np4info file not found: %s\nHave you run 'make'?" % args.p4info

parser.exit(1)

if not os.path.exists(args.bmv2_json):

parser.print_help()

print "\nBMv2 JSON file not found: %s\nHave you run 'make'?" % args.bmv2_json

parser.exit(1)

main(args.p4info, args.bmv2_json)

[Execution]

Use “xterm h1 s1 s3” to open three terminals. H1 will send ping packets to H2. S1 will capture packets from s1-eth2 to see whether packets go through from s1 to s2. S3 will capture packets from s3-eth3 to see whether packets go through from s3 to s2.

H1 ping h2. It does not work. Because we don’t run the controller.

Start another terminal (not from mininet terminal).

Now we can see ping works.

We can also see that packets can be captured in s1-eth2 and s3-eth3. (via two different paths.)

[reference]

1. https://github.com/p4lang/PI/blob/master/proto/ptf/base_test.py

2. https://cs344-stanford.github.io/deliverables/p4-mininet/

3. https://github.com/p4lang/tutorials

Dr. Chih-Heng Ke (smallko@gmail.com)

Department of Computer Science and Information Engineering,

National Quemoy University, Kinmen, Taiwan.