def of_demo_40():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 40 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Modify IP packet example1"
priority = 900
cookie = 1300
match_in_port = 10
match_eth_type = ETH_TYPE_IPv4
match_ip_proto = IP_PROTO_TCP
match_ipv4_src_addr = "192.1.2.0/24"
match_ipv4_dst_addr = "173.194.123.40/32"
match_tcp_dst_port = 8080
act_mod_ipv4_src_addr = "212.16.1.8/32"
act_mod_ipv4_dst_addr = "52.87.12.11/32"
act_mod_tcp_src_port = 8888
act_mod_tcp_dst_port = 9999
act_out_port = 119
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IP Protocol (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" TCP Destination Port (%s)" %
(match_in_port,
hex(match_eth_type),
match_ip_proto,
match_ipv4_src_addr,
match_ipv4_dst_addr,
match_tcp_dst_port))
print (" Actions: Modify IPv4 Source Address (%s)\n"
" Modify IPv4 Destination Address (%s)\n"
" Modify TCP Source Port (%s)\n"
" Modify TCP Destination Port (%s)\n"
" Output (%s)" %
(act_mod_ipv4_src_addr,
act_mod_ipv4_dst_addr,
act_mod_tcp_src_port,
act_mod_tcp_dst_port,
act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetNwSrcAction(action_order)
action.set_nw_src(act_mod_ipv4_src_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetNwDstAction(action_order)
action.set_nw_dst(act_mod_ipv4_dst_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetTpSrcAction(action_order)
action.set_tp_src(act_mod_tcp_src_port)
instruction.add_apply_action(action)
action_order += 1
action = SetTpDstAction(action_order)
action.set_tp_dst(act_mod_tcp_dst_port)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ip_proto(match_ip_proto)
match.set_ipv4_src(match_ipv4_src_addr)
match.set_ipv4_dst(match_ipv4_dst_addr)
match.set_tcp_dst_port(match_tcp_dst_port)
flow_entry1.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Modify IP packet example2"
priority = 900
cookie = 1300
match_in_port = 110
match_eth_type = ETH_TYPE_IPv4
match_ip_proto = IP_PROTO_UDP
match_ipv4_src_addr = "10.1.0.0/16"
match_ipv4_dst_addr = "168.1.1.101/32"
match_udp_dst_port = 1812
act_mod_ipv4_src_addr = "172.101.1.9/32"
act_mod_ipv4_dst_addr = "172.101.1.1/32"
act_mod_udp_src_port = 5555
act_mod_udp_dst_port = 7777
act_out_port = 120
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IP Protocol (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" UDP Destination Port (%s)" %
(match_in_port,
hex(match_eth_type),
match_ip_proto,
match_ipv4_src_addr,
match_ipv4_dst_addr,
match_udp_dst_port))
print (" Actions: Set Field (IPv4 Source Address %s)\n"
" Set Field (IPv4 Destination Address %s)\n"
" Set Field (UDP Source Port %s)\n"
" Set Field (UDP Destination Port %s)\n"
" Output (%s)" %
(act_mod_ipv4_src_addr,
act_mod_ipv4_dst_addr,
act_mod_udp_src_port,
act_mod_udp_dst_port,
act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetFieldAction(action_order)
action.set_ipv4_src(act_mod_ipv4_src_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_ipv4_dst(act_mod_ipv4_dst_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_udp_src_port(act_mod_udp_src_port)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_udp_dst_port(act_mod_udp_dst_port)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ip_proto(match_ip_proto)
match.set_ipv4_src(match_ipv4_src_addr)
match.set_ipv4_dst(match_ipv4_dst_addr)
match.set_udp_dst_port(match_udp_dst_port)
flow_entry2.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print ("\n")
print ("<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_11():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 11 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# ICMPv4 Type
# ICMPv4 Code
# IP DSCP
# IP ECN
# Input Port
# NOTE: Ethernet type MUST be 2048 (0x800) -> IPv4 protocol
# IP Protocol Type MUST be 1 -> ICMP
eth_type = ETH_TYPE_IPv4
eth_src = "00:00:00:11:23:ae"
eth_dst = "00:ff:20:01:1a:3d"
ipv4_src = "17.1.2.3/8"
ipv4_dst = "172.168.5.6/18"
ip_proto = IP_PROTO_ICMP
ip_dscp = IP_DSCP_CS2 # 'Class Selector' = 'Immediate'
ip_ecn = IP_ECN_CE # Congestion Encountered
icmpv4_type = 6 # Alternate Host Address
icmpv4_code = 3 # Alternate Address for Host
input_port = 10
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" IP Protocol Number (%s)\n"
" IP DSCP (%s)\n"
" IP ECN (%s)\n"
" ICMPv4 Type (%s)\n"
" ICMPv4 Code (%s)\n"
" Input Port (%s)" %
(hex(eth_type), eth_src, eth_dst, ipv4_src, ipv4_dst, ip_proto,
ip_dscp, ip_ecn, icmpv4_type, icmpv4_code, input_port))
print(" Action: Output (NORMAL)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 18
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1009)
# --- Instruction: 'Apply-actions'
# Action: 'Output' NORMAL
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="NORMAL")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# IP Protocol Number
# IP DSCP
# IP ECN
# ICMPv4 Type
# ICMPv4 Code
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_ipv4_src(ipv4_src)
match.set_ipv4_dst(ipv4_dst)
match.set_ip_proto(ip_proto)
match.set_ip_dscp(ip_dscp)
match.set_ip_ecn(ip_ecn)
match.set_icmpv4_type(icmpv4_type)
match.set_icmpv4_code(icmpv4_code)
match.set_in_port(input_port)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_7():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 7 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# Input Port
# NOTE: Ethernet type must be 2048 (0x800) -> IPv4 protocol
eth_type = ETH_TYPE_IPv4
eth_src = "00:1a:1b:00:22:aa"
eth_dst = "00:2b:00:60:ff:f1"
ipv4_src = "44.44.44.1/24"
ipv4_dst = "55.55.55.1/16"
input_port = 13
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" Input Port (%s)" %
(hex(eth_type), eth_src, eth_dst, ipv4_src, ipv4_dst, input_port))
print(" Action: Output (CONTROLLER)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 15
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1005)
# --- Instruction: 'Apply-actions'
# Action: 'Output' to CONTROLLER
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="CONTROLLER", max_len=60)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_ipv4_src(ipv4_src)
match.set_ipv4_dst(ipv4_dst)
match.set_in_port(input_port)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
" IPv6 Destination Address (%s)\n"
" IPv6 Flow Label (%s)\n"
" IPv6 Extension Header (%s)\n"
" TCP Source Port (%s)\n"
" TCP Destination Port (%s)\n"
" Metadata (%s)" % (hex(eth_type), ip_dscp, ip_ecn,
ipv6_src, ipv6_dst, ipv6_flabel,
ipv6_exthdr,
tcp_src_port, tcp_dst_port, metadata))
print (" Action: Output (to %s)" % output_port)
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 27
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority = 1020)
flow_entry.set_flow_cookie(cookie = 2100)
flow_entry.set_flow_hard_timeout(hard_timeout = 1234)
flow_entry.set_flow_idle_timeout(idle_timeout = 3456)
flow_entry.set_flow_strict(False)
flow_entry.set_flow_install_hw(False)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order = 0)
action = OutputAction(order = 0, port = output_port)
def of_demo_12():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 12 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# ARP Operation
# ARP Source IPv4 Address
# ARP Target IPv4 Address
# ARP source hardware address
# ARP target hardware address
# NOTE: Ethernet type MUST be 2054 (0x0806) -> ARP protocol
eth_type = ETH_TYPE_ARP
eth_src = "00:ab:fe:01:03:31"
eth_dst = "ff:ff:ff:ff:ff:ff"
arp_opcode = ARP_REQUEST
arp_src_ipv4_addr = "192.168.4.1/32"
arp_tgt_ipv4_addr = "10.21.22.23/32"
arp_src_hw_addr = "12:34:56:78:98:ab"
arp_tgt_hw_addr = "fe:dc:ba:98:76:54"
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" ARP Operation (%s)\n"
" ARP Source IPv4 Address (%s)\n"
" ARP Target IPv4 Address (%s)\n"
" ARP Source Hardware Address (%s)\n"
" ARP Target Hardware Address (%s)" %
(hex(eth_type), eth_src,
eth_dst, arp_opcode,
arp_src_ipv4_addr,
arp_tgt_ipv4_addr,
arp_src_hw_addr,
arp_tgt_hw_addr))
print (" Action: Output (CONTROLLER)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 19
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1010)
# --- Instruction: 'Apply-actions'
# Action: 'Output' CONTROLLER
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="CONTROLLER")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# ARP Operation
# ARP Source IPv4 Address
# ARP Target IPv4 Address
# ARP Source Hardware Address
# ARP Target Hardware Address
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_arp_opcode(arp_opcode)
match.set_arp_src_transport_address(arp_src_ipv4_addr)
match.set_arp_tgt_transport_address(arp_tgt_ipv4_addr)
match.set_arp_src_hw_address(arp_src_hw_addr)
match.set_arp_tgt_hw_address(arp_tgt_hw_addr)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Destination Address (%s)"
% (match_in_port,
hex(match_ip_eth_type),
match_ipv4_dst))
print (" Action: Set IPv4 ToS (tos %s)\n"
" Output (Port number %s)"
% (mod_nw_tos,
act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order = 0)
action_order = 0
action = SetNwTosAction(action_order)
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" % (hex(arp_eth_type), customer_vlan_id, customer_port))
print (" Action: Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Output (Physical Port number %s)" % (hex(qinq_eth_type), provider_vlan_id,
hex(dot1q_eth_type), customer_vlan_id,
provider_port))
time.sleep(rundelay)
flow_id = first_flow_id
flow_entry1 = FlowEntry()
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name = "[MLX1-A] Test flow (match:inport=110,arp;actions:push-QINQ-tag,mod_vlan=100,push-DOT1Q-tag,mod_vlan=998,output:111)")
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_hard_timeout(hard_timeout = 600)
flow_entry1.set_flow_idle_timeout(idle_timeout = 300)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order = 0)
action_order = 0
action = PushVlanHeaderAction(action_order)
action.set_eth_type(qinq_eth_type)
instruction.add_apply_action(action)
def of_demo_20():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 20 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# IP DSCP
# IP ECN
# IPv6 Source Address
# IPv6 Destination Address
# IPv6 Flow Label
# ICMPv6 type
# ICMPv6 Code
# Metadata
eth_type = ETH_TYPE_IPv6
ip_dscp = IP_DSCP_CS7 # 'Class Selector' = 'Network'
ip_ecn = IP_ECN_CE # 'Congestion Encountered'
ipv6_src = "1234:5678:9ABC:DEF0:FDCD:A987:6543:210F/76"
ipv6_dst = "2000:2abc:edff:fe00::3456/94"
ipv6_flabel = 15
ip_proto = IP_PROTO_ICMPv6
icmpv6_type = 1 # 'Destination Unreachable'
icmpv6_code = 3 # 'Address Unreachable'
metadata = "0x0123456789ABCDEF"
# --- Flow Actions: Output (CONTROLLER)
output_port = "CONTROLLER"
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" IP DSCP (%s)\n"
" IP ECN (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)\n"
" IPv6 Flow Label (%s)\n"
" ICMPv6 Type (%s)\n"
" ICMPv6 Code (%s)\n"
" Metadata (%s)" %
(hex(eth_type), ip_dscp, ip_ecn, ipv6_src, ipv6_dst, ipv6_flabel,
icmpv6_type, icmpv6_code, metadata))
print(" Action: Output (to %s)" % (output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 26
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_name(flow_name="demo20.py")
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1019)
flow_entry.set_flow_cookie(cookie=250)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
flow_entry.set_flow_hard_timeout(hard_timeout=1200)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IP DSCP
# IP ECN
# IPv6 Source Address
# IPv6 Destination Address
# IPv6 Flow Label
# IP protocol number (ICMPv6)
# ICMPv6 Type
# ICMPv6 Code
# Metadata
match = Match()
match.set_eth_type(eth_type)
match.set_ip_dscp(ip_dscp)
match.set_ip_ecn(ip_ecn)
match.set_ipv6_src(ipv6_src)
match.set_ipv6_dst(ipv6_dst)
match.set_ipv6_flabel(ipv6_flabel)
match.set_ip_proto(ip_proto)
match.set_icmpv6_type(icmpv6_type)
match.set_icmpv6_code(icmpv6_code)
match.set_metadata(metadata)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_42():
f = "cfg.yml"
d = {}
if load_dict_from_file(f, d) is False:
print ("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d["ctrlIpAddr"]
ctrlPortNum = d["ctrlPortNum"]
ctrlUname = d["ctrlUname"]
ctrlPswd = d["ctrlPswd"]
nodeName = d["nodeName"]
rundelay = d["rundelay"]
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 42 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" % (ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Modify MPLS TTL example1"
priority = 900
cookie = 1300
match_in_port = 3
match_eth_type = ETH_TYPE_MPLS_UCAST
match_mpls_label = 567
act_mod_mpls_ttl = 2
act_out_port = 112
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" MPLS Label (%s)" % (match_in_port, hex(match_eth_type), match_mpls_label)
)
print (" Actions: Set MPLS TTL (%s)\n" " Output (%s)" % (act_mod_mpls_ttl, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetMplsTTLAction(action_order)
action.set_ttl(act_mod_mpls_ttl)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_mpls_label(match_mpls_label)
flow_entry1.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if status.eq(STATUS.OK):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Modify MPLS TTL example2"
priority = 900
cookie = 1300
match_in_port = 112
match_eth_type = ETH_TYPE_MPLS_UCAST
match_mpls_label = 567
act_out_port = 3
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" MPLS Label (%s)" % (match_in_port, hex(match_eth_type), match_mpls_label)
)
print (" Actions: Decrement MPLS TTL\n" " Output (%s)" % (act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = DecMplsTTLAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_mpls_label(match_mpls_label)
flow_entry2.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if status.eq(STATUS.OK):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print ("\n")
print (
"<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName)
)
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" IP Protocol Number (%s)\n"
" IP DSCP (%s)\n"
" IP ECN (%s)\n"
" Input Port (%s)" % (hex(eth_type), eth_src,
eth_dst, ipv4_src, ipv4_dst,
ip_proto, ip_dscp, ip_ecn,
input_port))
print (" Action: Output (CONTROLLER)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 15
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority = 1006)
flow_entry.set_flow_cookie(cookie=100)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
# --- Instruction: 'Apply-action'
# Action: 'Output' to CONTROLLER
instruction = Instruction(instruction_order = 0)
action = OutputAction(action_order = 0, port = "CONTROLLER", max_len=60)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
def of_demo_12():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 12 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# ARP Operation
# ARP Source IPv4 Address
# ARP Target IPv4 Address
# ARP source hardware address
# ARP target hardware address
# NOTE: Ethernet type MUST be 2054 (0x0806) -> ARP protocol
eth_type = ETH_TYPE_ARP
eth_src = "00:ab:fe:01:03:31"
eth_dst = "ff:ff:ff:ff:ff:ff"
arp_opcode = ARP_REQUEST
arp_src_ipv4_addr = "192.168.4.1/32"
arp_tgt_ipv4_addr = "10.21.22.23/32"
arp_src_hw_addr = "12:34:56:78:98:ab"
arp_tgt_hw_addr = "fe:dc:ba:98:76:54"
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" ARP Operation (%s)\n"
" ARP Source IPv4 Address (%s)\n"
" ARP Target IPv4 Address (%s)\n"
" ARP Source Hardware Address (%s)\n"
" ARP Target Hardware Address (%s)" %
(hex(eth_type), eth_src, eth_dst, arp_opcode, arp_src_ipv4_addr,
arp_tgt_ipv4_addr, arp_src_hw_addr, arp_tgt_hw_addr))
print(" Action: Output (CONTROLLER)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 19
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1010)
# --- Instruction: 'Apply-actions'
# Action: 'Output' CONTROLLER
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="CONTROLLER")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# ARP Operation
# ARP Source IPv4 Address
# ARP Target IPv4 Address
# ARP Source Hardware Address
# ARP Target Hardware Address
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_arp_opcode(arp_opcode)
match.set_arp_src_transport_address(arp_src_ipv4_addr)
match.set_arp_tgt_transport_address(arp_tgt_ipv4_addr)
match.set_arp_src_hw_address(arp_src_hw_addr)
match.set_arp_tgt_hw_address(arp_tgt_hw_addr)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_16():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 16 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
eth_type = ETH_TYPE_IPv6
ipv6_src = "fe80::2acf:e9ff:fe21:6431/128"
ipv6_dst = "aabb:1234:2acf:e9ff::fe21:6431/64"
# --- Flow Actions: Output (CONTROLLER)
output_port = "CONTROLLER"
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)" %
(hex(eth_type), ipv6_src, ipv6_dst))
print(" Action: Output (to %s)" % (output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
fname = "match=ipv6_src,ipv6_dst;actions=output:Controller"
flow_entry.set_flow_name(flow_name=fname)
table_id = 0
flow_id = 23
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1014)
flow_entry.set_flow_cookie(cookie=408)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
flow_entry.set_flow_hard_timeout(hard_timeout=3400)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
match = Match()
match.set_eth_type(eth_type)
match.set_ipv6_src(ipv6_src)
match.set_ipv6_dst(ipv6_dst)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_42():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 42 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Modify MPLS TTL example1"
priority = 900
cookie = 1300
match_in_port = 3
match_eth_type = ETH_TYPE_MPLS_UCAST
match_mpls_label = 567
act_mod_mpls_ttl = 2
act_out_port = 112
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" MPLS Label (%s)" %
(match_in_port, hex(match_eth_type), match_mpls_label))
print(
" Actions: Set MPLS TTL (%s)\n"
" Output (%s)" % (act_mod_mpls_ttl, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetMplsTTLAction(action_order)
action.set_ttl(act_mod_mpls_ttl)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_mpls_label(match_mpls_label)
flow_entry1.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Modify MPLS TTL example2"
priority = 900
cookie = 1300
match_in_port = 112
match_eth_type = ETH_TYPE_MPLS_UCAST
match_mpls_label = 567
act_out_port = 3
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" MPLS Label (%s)" %
(match_in_port, hex(match_eth_type), match_mpls_label))
print(
" Actions: Decrement MPLS TTL\n"
" Output (%s)" % (act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = DecMplsTTLAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_mpls_label(match_mpls_label)
flow_entry2.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print("\n")
print(
"<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_11():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 11 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# ICMPv4 Type
# ICMPv4 Code
# IP DSCP
# IP ECN
# Input Port
# NOTE: Ethernet type MUST be 2048 (0x800) -> IPv4 protocol
# IP Protocol Type MUST be 1 -> ICMP
eth_type = ETH_TYPE_IPv4
eth_src = "00:00:00:11:23:ae"
eth_dst = "00:ff:20:01:1a:3d"
ipv4_src = "17.1.2.3/8"
ipv4_dst = "172.168.5.6/18"
ip_proto = IP_PROTO_ICMP
ip_dscp = IP_DSCP_CS2 # 'Class Selector' = 'Immediate'
ip_ecn = IP_ECN_CE # Congestion Encountered
icmpv4_type = 6 # Alternate Host Address
icmpv4_code = 3 # Alternate Address for Host
input_port = 10
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'"
% (ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" IP Protocol Number (%s)\n"
" IP DSCP (%s)\n"
" IP ECN (%s)\n"
" ICMPv4 Type (%s)\n"
" ICMPv4 Code (%s)\n"
" Input Port (%s)"
% (hex(eth_type), eth_src,
eth_dst, ipv4_src, ipv4_dst,
ip_proto, ip_dscp, ip_ecn,
icmpv4_type, icmpv4_code,
input_port))
print (" Action: Output (NORMAL)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 18
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1009)
# --- Instruction: 'Apply-actions'
# Action: 'Output' NORMAL
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="NORMAL")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# IP Protocol Number
# IP DSCP
# IP ECN
# ICMPv4 Type
# ICMPv4 Code
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_ipv4_src(ipv4_src)
match.set_ipv4_dst(ipv4_dst)
match.set_ip_proto(ip_proto)
match.set_ip_dscp(ip_dscp)
match.set_ip_ecn(ip_ecn)
match.set_icmpv4_type(icmpv4_type)
match.set_icmpv4_code(icmpv4_code)
match.set_in_port(input_port)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node"
% (flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_25():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 25 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
table_id = 0
priority = 500
cookie = 1000
cookie_mask = 255
customer_port = 110
provider_port = 111
qinq_eth_type = ETH_TYPE_STAG # 802.1ad (QinQ) VLAN tagged frame
dot1q_eth_type = ETH_TYPE_CTAG # 802.1q VLAN tagged frame
arp_eth_type = ETH_TYPE_ARP
ip_eth_type = ETH_TYPE_IPv4
provider_vlan_id = 100 # Provider VLAN
customer_vlan_id = 998 # Customer VLAN
first_flow_id = 31
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" %
(hex(arp_eth_type), customer_vlan_id, customer_port))
print(
" Action: Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Output (Physical Port number %s)" %
(hex(qinq_eth_type), provider_vlan_id, hex(dot1q_eth_type),
customer_vlan_id, provider_port))
time.sleep(rundelay)
flow_id = first_flow_id
flow_entry1 = FlowEntry()
flow_entry1.set_flow_table_id(table_id)
fname = "[MLX1-A] Test flow (match:inport=110,arp;" + \
"actions:push-QINQ-tag,mod_vlan=100," + \
"push-DOT1Q-tag,mod_vlan=998,output:111)"
flow_entry1.set_flow_name(flow_name=fname)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_hard_timeout(hard_timeout=600)
flow_entry1.set_flow_idle_timeout(idle_timeout=300)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PushVlanHeaderAction(action_order)
action.set_eth_type(qinq_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(provider_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = PushVlanHeaderAction(action_order)
action.set_eth_type(dot1q_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(customer_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, provider_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
match = Match()
match.set_eth_type(arp_eth_type)
match.set_vlan_id(customer_vlan_id)
match.set_in_port(in_port=customer_port)
flow_entry1.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" %
(hex(ip_eth_type), customer_vlan_id, customer_port))
print(
" Action: Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Output (Physical Port number %s)" %
(hex(qinq_eth_type), provider_vlan_id, hex(dot1q_eth_type),
customer_vlan_id, provider_port))
time.sleep(rundelay)
flow_id += 1
flow_entry2 = FlowEntry()
flow_entry2.set_flow_table_id(table_id)
fname = "[MLX1-A] Test flow (match:inport=110,ip;" + \
"actions:push-QINQ-tag,mod_vlan=100,output:111)"
flow_entry2.set_flow_name(flow_name=fname)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_hard_timeout(hard_timeout=600)
flow_entry2.set_flow_idle_timeout(idle_timeout=300)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PushVlanHeaderAction(action_order)
action.set_eth_type(qinq_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(provider_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = PushVlanHeaderAction(action_order)
action.set_eth_type(dot1q_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(customer_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, provider_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
match = Match()
match.set_eth_type(ip_eth_type)
match.set_vlan_id(customer_vlan_id)
match.set_in_port(in_port=customer_port)
flow_entry2.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Third flow entry
# ---------------------------------------------------
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" %
(hex(arp_eth_type), provider_vlan_id, provider_port))
print(
" Action: Pop VLAN\n"
" Output (Physical Port number %s)" % (customer_port))
time.sleep(rundelay)
flow_id += 1
flow_entry3 = FlowEntry()
flow_entry3.set_flow_table_id(table_id)
fname = "[MLX1-A] Test flow (match:inport=111,arp,vid=100;" + \
"actions:pop-vlan-tag,output=110)"
flow_entry3.set_flow_name(flow_name=fname)
flow_entry3.set_flow_id(flow_id)
flow_entry3.set_flow_hard_timeout(hard_timeout=600)
flow_entry3.set_flow_idle_timeout(idle_timeout=300)
flow_entry3.set_flow_priority(priority)
flow_entry3.set_flow_cookie(cookie)
flow_entry3.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PopVlanHeaderAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, customer_port)
instruction.add_apply_action(action)
flow_entry3.add_instruction(instruction)
match = Match()
match.set_eth_type(arp_eth_type)
match.set_vlan_id(provider_vlan_id)
match.set_in_port(provider_port)
flow_entry3.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry3.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry3)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Fourth flow entry
# ---------------------------------------------------
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" %
(hex(ip_eth_type), provider_vlan_id, provider_port))
print(
" Action: Pop VLAN\n"
" Output (Physical Port number %s)" % (customer_port))
time.sleep(rundelay)
flow_id += 1
flow_entry4 = FlowEntry()
flow_entry4.set_flow_table_id(table_id)
flow_entry4.set_flow_id(flow_id)
fname = "[MLX1-A] Test flow (match:inport=111,ip,vid=100;" + \
"actions:pop-vlan-tag,output=110)"
flow_entry4.set_flow_name(flow_name=fname)
flow_entry4.set_flow_hard_timeout(hard_timeout=600)
flow_entry4.set_flow_idle_timeout(idle_timeout=300)
flow_entry4.set_flow_priority(priority)
flow_entry4.set_flow_cookie(cookie)
flow_entry4.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PopVlanHeaderAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, customer_port)
instruction.add_apply_action(action)
flow_entry4.add_instruction(instruction)
match = Match()
match.set_eth_type(ip_eth_type)
match.set_vlan_id(provider_vlan_id)
match.set_in_port(provider_port)
flow_entry4.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry4.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry4)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print("\n")
print("<<< Get configured flows from the Controller")
time.sleep(rundelay)
for i in range(first_flow_id, flow_id + 1):
result = ofswitch.get_configured_flow(table_id, i)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow '%s' successfully read from the Controller" % i)
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print("\n")
print(
"<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_25():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 25 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
table_id = 0
priority = 500
cookie = 1000
cookie_mask = 255
customer_port = 110
provider_port = 111
qinq_eth_type = ETH_TYPE_STAG # 802.1ad (QinQ) VLAN tagged frame
dot1q_eth_type = ETH_TYPE_CTAG # 802.1q VLAN tagged frame
arp_eth_type = ETH_TYPE_ARP
ip_eth_type = ETH_TYPE_IPv4
provider_vlan_id = 100 # Provider VLAN
customer_vlan_id = 998 # Customer VLAN
first_flow_id = 31
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'"
% (ctrlIpAddr, nodeName))
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)"
% (hex(arp_eth_type), customer_vlan_id, customer_port))
print (" Action: Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Output (Physical Port number %s)"
% (hex(qinq_eth_type), provider_vlan_id,
hex(dot1q_eth_type), customer_vlan_id,
provider_port))
time.sleep(rundelay)
flow_id = first_flow_id
flow_entry1 = FlowEntry()
flow_entry1.set_flow_table_id(table_id)
fname = "[MLX1-A] Test flow (match:inport=110,arp;" + \
"actions:push-QINQ-tag,mod_vlan=100," + \
"push-DOT1Q-tag,mod_vlan=998,output:111)"
flow_entry1.set_flow_name(flow_name=fname)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_hard_timeout(hard_timeout=600)
flow_entry1.set_flow_idle_timeout(idle_timeout=300)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PushVlanHeaderAction(action_order)
action.set_eth_type(qinq_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(provider_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = PushVlanHeaderAction(action_order)
action.set_eth_type(dot1q_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(customer_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, provider_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
match = Match()
match.set_eth_type(arp_eth_type)
match.set_vlan_id(customer_vlan_id)
match.set_in_port(in_port=customer_port)
flow_entry1.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id+1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)"
% (hex(ip_eth_type), customer_vlan_id, customer_port))
print (" Action: Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Push VLAN (Ethernet Type %s)\n"
" Set Field (VLAN ID %s)\n"
" Output (Physical Port number %s)"
% (hex(qinq_eth_type), provider_vlan_id,
hex(dot1q_eth_type), customer_vlan_id,
provider_port))
time.sleep(rundelay)
flow_id += 1
flow_entry2 = FlowEntry()
flow_entry2.set_flow_table_id(table_id)
fname = "[MLX1-A] Test flow (match:inport=110,ip;" + \
"actions:push-QINQ-tag,mod_vlan=100,output:111)"
flow_entry2.set_flow_name(flow_name=fname)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_hard_timeout(hard_timeout=600)
flow_entry2.set_flow_idle_timeout(idle_timeout=300)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PushVlanHeaderAction(action_order)
action.set_eth_type(qinq_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(provider_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = PushVlanHeaderAction(action_order)
action.set_eth_type(dot1q_eth_type)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_id(customer_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, provider_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
match = Match()
match.set_eth_type(ip_eth_type)
match.set_vlan_id(customer_vlan_id)
match.set_in_port(in_port=customer_port)
flow_entry2.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id+1))
exit(0)
# ---------------------------------------------------
# Third flow entry
# ---------------------------------------------------
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)"
% (hex(arp_eth_type), provider_vlan_id, provider_port))
print (" Action: Pop VLAN\n"
" Output (Physical Port number %s)"
% (customer_port))
time.sleep(rundelay)
flow_id += 1
flow_entry3 = FlowEntry()
flow_entry3.set_flow_table_id(table_id)
fname = "[MLX1-A] Test flow (match:inport=111,arp,vid=100;" + \
"actions:pop-vlan-tag,output=110)"
flow_entry3.set_flow_name(flow_name=fname)
flow_entry3.set_flow_id(flow_id)
flow_entry3.set_flow_hard_timeout(hard_timeout=600)
flow_entry3.set_flow_idle_timeout(idle_timeout=300)
flow_entry3.set_flow_priority(priority)
flow_entry3.set_flow_cookie(cookie)
flow_entry3.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PopVlanHeaderAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, customer_port)
instruction.add_apply_action(action)
flow_entry3.add_instruction(instruction)
match = Match()
match.set_eth_type(arp_eth_type)
match.set_vlan_id(provider_vlan_id)
match.set_in_port(provider_port)
flow_entry3.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry3.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry3)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id+1))
exit(0)
# ---------------------------------------------------
# Fourth flow entry
# ---------------------------------------------------
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)"
% (hex(ip_eth_type), provider_vlan_id, provider_port))
print (" Action: Pop VLAN\n"
" Output (Physical Port number %s)"
% (customer_port))
time.sleep(rundelay)
flow_id += 1
flow_entry4 = FlowEntry()
flow_entry4.set_flow_table_id(table_id)
flow_entry4.set_flow_id(flow_id)
fname = "[MLX1-A] Test flow (match:inport=111,ip,vid=100;" + \
"actions:pop-vlan-tag,output=110)"
flow_entry4.set_flow_name(flow_name=fname)
flow_entry4.set_flow_hard_timeout(hard_timeout=600)
flow_entry4.set_flow_idle_timeout(idle_timeout=300)
flow_entry4.set_flow_priority(priority)
flow_entry4.set_flow_cookie(cookie)
flow_entry4.set_flow_cookie_mask(cookie_mask)
instruction = Instruction(instruction_order=0)
action_order = 0
action = PopVlanHeaderAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order, customer_port)
instruction.add_apply_action(action)
flow_entry4.add_instruction(instruction)
match = Match()
match.set_eth_type(ip_eth_type)
match.set_vlan_id(provider_vlan_id)
match.set_in_port(provider_port)
flow_entry4.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry4.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry4)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id+1))
exit(0)
print ("\n")
print ("<<< Get configured flows from the Controller")
time.sleep(rundelay)
for i in range(first_flow_id, flow_id+1):
result = ofswitch.get_configured_flow(table_id, i)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow '%s' successfully read from the Controller" % i)
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id+1))
exit(0)
print ("\n")
print ("<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id+1))
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_43():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 43 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Set Queue example"
priority = 1000
cookie = 1400
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_ipv4_dst_addr = "10.0.0.0/8"
act_queue_id = 7
act_out_port = 112
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Destination Address (%s)" %
(match_in_port,
hex(match_eth_type),
match_ipv4_dst_addr))
print (" Actions: Set Queue (%s)\n"
" Output (%s)" %
(act_queue_id, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetQueueAction(action_order)
action.set_gueue_id(act_queue_id)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ipv4_dst(match_ipv4_dst_addr)
flow_entry1.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
print ("<<< Get Queues Statistics for Port '%s'") % act_out_port
time.sleep(rundelay)
queues = []
result = ofswitch.get_port_queues_stats(act_out_port, decode_obj=True)
status = result.get_status()
if(status.eq(STATUS.OK)):
queues = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
pass
else:
print ("\n")
print ("!!!Error, failed to get queue statistics for port '%s" %
act_out_port)
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
s = "Port '{} - Queues Statistics'".format(act_out_port)
print " %s\n" % s
if queues:
for queue in sorted(queues, key=lambda q: q.queue_id()):
print " Queue '{}'".format(queue.queue_id())
print "\n".strip()
print " Tx Packets : {}".format(queue.tx_pkts())
print " Tx Bytes : {}".format(queue.tx_bytes())
print " Tx Errors : {}".format(queue.tx_errs())
print " Duration : {}s".format(queue.time_alive())
print "\n".strip()
else:
print " None"
print "\n".strip()
print ("<<< Get Queue '%s' Statistics for Port '%s'" %
(act_queue_id, act_out_port))
time.sleep(rundelay)
queue = None
result = ofswitch.get_port_queue_stats(port_num=act_out_port,
queue_id=act_queue_id,
decode_obj=True)
status = result.get_status()
if(status.eq(STATUS.OK)):
queue = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
pass
else:
print ("\n")
print ("!!!Error, failed to get port '%s' queue '%s' statistics " %
act_out_port, act_queue_id)
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
s = "Port '{}' - Queue '{}' Statistics".format(act_out_port, act_queue_id)
print " %s\n" % s
if queue:
print " Tx Packets : {}".format(queue.tx_pkts())
print " Tx Bytes : {}".format(queue.tx_bytes())
print " Tx Errors : {}".format(queue.tx_errs())
print " Duration : {}s".format(queue.time_alive())
print "\n".strip()
else:
print " None"
print ("\n")
print ("<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_40():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 40 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Modify IP packet example1"
priority = 900
cookie = 1300
match_in_port = 10
match_eth_type = ETH_TYPE_IPv4
match_ip_proto = IP_PROTO_TCP
match_ipv4_src_addr = "192.1.2.0/24"
match_ipv4_dst_addr = "173.194.123.40/32"
match_tcp_dst_port = 8080
act_mod_ipv4_src_addr = "212.16.1.8/32"
act_mod_ipv4_dst_addr = "52.87.12.11/32"
act_mod_tcp_src_port = 8888
act_mod_tcp_dst_port = 9999
act_out_port = 119
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IP Protocol (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" TCP Destination Port (%s)" %
(match_in_port, hex(match_eth_type), match_ip_proto,
match_ipv4_src_addr, match_ipv4_dst_addr, match_tcp_dst_port))
print(
" Actions: Modify IPv4 Source Address (%s)\n"
" Modify IPv4 Destination Address (%s)\n"
" Modify TCP Source Port (%s)\n"
" Modify TCP Destination Port (%s)\n"
" Output (%s)" %
(act_mod_ipv4_src_addr, act_mod_ipv4_dst_addr, act_mod_tcp_src_port,
act_mod_tcp_dst_port, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetNwSrcAction(action_order)
action.set_nw_src(act_mod_ipv4_src_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetNwDstAction(action_order)
action.set_nw_dst(act_mod_ipv4_dst_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetTpSrcAction(action_order)
action.set_tp_src(act_mod_tcp_src_port)
instruction.add_apply_action(action)
action_order += 1
action = SetTpDstAction(action_order)
action.set_tp_dst(act_mod_tcp_dst_port)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ip_proto(match_ip_proto)
match.set_ipv4_src(match_ipv4_src_addr)
match.set_ipv4_dst(match_ipv4_dst_addr)
match.set_tcp_dst(match_tcp_dst_port)
flow_entry1.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Modify IP packet example2"
priority = 900
cookie = 1300
match_in_port = 110
match_eth_type = ETH_TYPE_IPv4
match_ip_proto = IP_PROTO_UDP
match_ipv4_src_addr = "10.1.0.0/16"
match_ipv4_dst_addr = "168.1.1.101/32"
match_udp_dst_port = 1812
act_mod_ipv4_src_addr = "172.101.1.9/32"
act_mod_ipv4_dst_addr = "172.101.1.1/32"
act_mod_udp_src_port = 5555
act_mod_udp_dst_port = 7777
act_out_port = 120
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IP Protocol (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" UDP Destination Port (%s)" %
(match_in_port, hex(match_eth_type), match_ip_proto,
match_ipv4_src_addr, match_ipv4_dst_addr, match_udp_dst_port))
print(
" Actions: Set Field (IPv4 Source Address %s)\n"
" Set Field (IPv4 Destination Address %s)\n"
" Set Field (UDP Source Port %s)\n"
" Set Field (UDP Destination Port %s)\n"
" Output (%s)" %
(act_mod_ipv4_src_addr, act_mod_ipv4_dst_addr, act_mod_udp_src_port,
act_mod_udp_dst_port, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetFieldAction(action_order)
action.set_ipv4_src(act_mod_ipv4_src_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_ipv4_dst(act_mod_ipv4_dst_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_udp_src(act_mod_udp_src_port)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_udp_dst(act_mod_udp_dst_port)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ip_proto(match_ip_proto)
match.set_ipv4_src(match_ipv4_src_addr)
match.set_ipv4_dst(match_ipv4_dst_addr)
match.set_udp_dst(match_udp_dst_port)
flow_entry2.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print("\n")
print(
"<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" % (ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Input Port (%s)\n"
" MPLS Label (%s)"% (hex(eth_type), in_port, mpls_label))
print (" Action: Set Field (MPLS Label %s)\n"
" Output (Physical Port number %s)" % (new_mpls_label, output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 29
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_name(flow_name = "Change MPLS Label")
flow_entry.set_flow_hard_timeout(hard_timeout = 0)
flow_entry.set_flow_idle_timeout(idle_timeout = 0)
flow_entry.set_flow_priority(flow_priority = 1022)
flow_entry.set_flow_cookie(cookie = 401)
flow_entry.set_flow_cookie_mask(cookie_mask = 255)
# --- Instruction: 'Apply-actions'
# Actions: 'Set Field'
# 'Output'
instruction = Instruction(instruction_order = 0)
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" Input Port (%s)\n" % (hex(eth_type), eth_src,
eth_dst, input_port))
print (" Actions: 'Push VLAN' (Ethernet Type=%s)"
% hex(push_eth_type))
print (" 'Set Field' (VLAN ID=%s)" % push_vlan_id)
print (" 'Output' (to Physical Port Number %s)" % output_port)
time.sleep(rundelay)
flow_entry = FlowEntry()
flow_entry.set_flow_name(flow_name = "push_vlan_flow")
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 21
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority = 1012)
flow_entry.set_flow_cookie(cookie = 401)
flow_entry.set_flow_cookie_mask(cookie_mask = 255)
flow_entry.set_flow_hard_timeout(hard_timeout = 1200)
flow_entry.set_flow_idle_timeout(idle_timeout = 3400)
# --- Instruction: 'Apply-action'
# Actions: 'PushVlan'
# 'SetField'
# 'Output'
def of_demo_20():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 20 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# IP DSCP
# IP ECN
# IPv6 Source Address
# IPv6 Destination Address
# IPv6 Flow Label
# ICMPv6 type
# ICMPv6 Code
# Metadata
eth_type = ETH_TYPE_IPv6
ip_dscp = IP_DSCP_CS7 # 'Class Selector' = 'Network'
ip_ecn = IP_ECN_CE # 'Congestion Encountered'
ipv6_src = "1234:5678:9ABC:DEF0:FDCD:A987:6543:210F/76"
ipv6_dst = "2000:2abc:edff:fe00::3456/94"
ipv6_flabel = 15
ip_proto = IP_PROTO_ICMPv6
icmpv6_type = 1 # 'Destination Unreachable'
icmpv6_code = 3 # 'Address Unreachable'
metadata = "0x0123456789ABCDEF"
# --- Flow Actions: Output (CONTROLLER)
output_port = "CONTROLLER"
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" IP DSCP (%s)\n"
" IP ECN (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)\n"
" IPv6 Flow Label (%s)\n"
" ICMPv6 Type (%s)\n"
" ICMPv6 Code (%s)\n"
" Metadata (%s)" %
(hex(eth_type), ip_dscp, ip_ecn,
ipv6_src, ipv6_dst, ipv6_flabel,
icmpv6_type, icmpv6_code, metadata))
print (" Action: Output (to %s)" % (output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 26
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_name(flow_name="demo20.py")
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1019)
flow_entry.set_flow_cookie(cookie=250)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
flow_entry.set_flow_hard_timeout(hard_timeout=1200)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IP DSCP
# IP ECN
# IPv6 Source Address
# IPv6 Destination Address
# IPv6 Flow Label
# IP protocol number (ICMPv6)
# ICMPv6 Type
# ICMPv6 Code
# Metadata
match = Match()
match.set_eth_type(eth_type)
match.set_ip_dscp(ip_dscp)
match.set_ip_ecn(ip_ecn)
match.set_ipv6_src(ipv6_src)
match.set_ipv6_dst(ipv6_dst)
match.set_ipv6_flabel(ipv6_flabel)
match.set_ip_proto(ip_proto)
match.set_icmpv6_type(icmpv6_type)
match.set_icmpv6_code(icmpv6_code)
match.set_metadata(metadata)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
" IP ECN (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)\n"
" IPv6 Flow Label (%s)\n"
" ICMPv6 Type (%s)\n"
" ICMPv6 Code (%s)\n"
" Metadata (%s)" % (hex(eth_type), ip_dscp, ip_ecn,
ipv6_src, ipv6_dst, ipv6_flabel,
icmpv6_type, icmpv6_code, metadata))
print (" Action: Output (to %s)" % output_port)
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 26
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_name(flow_name = "demo20.py")
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority = 1019)
flow_entry.set_flow_cookie(cookie = 250)
flow_entry.set_flow_cookie_mask(cookie_mask = 255)
flow_entry.set_flow_hard_timeout(hard_timeout = 1200)
flow_entry.set_flow_idle_timeout(idle_timeout = 3400)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order = 0)
action = OutputAction(order = 0, port = output_port)
def of_demo_43():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 43 Start")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Set Queue example"
priority = 1000
cookie = 1400
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_ipv4_dst_addr = "10.0.0.0/8"
act_queue_id = 7
act_out_port = 112
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Destination Address (%s)" %
(match_in_port, hex(match_eth_type), match_ipv4_dst_addr))
print(" Actions: Set Queue (%s)\n"
" Output (%s)" % (act_queue_id, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetQueueAction(action_order)
action.set_gueue_id(act_queue_id)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ipv4_dst(match_ipv4_dst_addr)
flow_entry1.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
print("<<< Get Queues Statistics for Port '%s'") % act_out_port
time.sleep(rundelay)
queues = []
result = ofswitch.get_port_queues_stats(act_out_port, decode_obj=True)
status = result.get_status()
if (status.eq(STATUS.OK)):
queues = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
pass
else:
print("\n")
print("!!!Error, failed to get queue statistics for port '%s" %
act_out_port)
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
s = "Port '{} - Queues Statistics'".format(act_out_port)
print " %s\n" % s
if queues:
for queue in sorted(queues, key=lambda q: q.queue_id()):
print " Queue '{}'".format(queue.queue_id())
print "\n".strip()
print " Tx Packets : {}".format(queue.tx_pkts())
print " Tx Bytes : {}".format(queue.tx_bytes())
print " Tx Errors : {}".format(queue.tx_errs())
print " Duration : {}s".format(queue.time_alive())
print "\n".strip()
else:
print " None"
print "\n".strip()
print("<<< Get Queue '%s' Statistics for Port '%s'" %
(act_queue_id, act_out_port))
time.sleep(rundelay)
queue = None
result = ofswitch.get_port_queue_stats(port_num=act_out_port,
queue_id=act_queue_id,
decode_obj=True)
status = result.get_status()
if (status.eq(STATUS.OK)):
queue = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
pass
else:
print("\n")
print(
"!!!Error, failed to get port '%s' queue '%s' statistics " %
act_out_port, act_queue_id)
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
s = "Port '{}' - Queue '{}' Statistics".format(act_out_port, act_queue_id)
print " %s\n" % s
if queue:
print " Tx Packets : {}".format(queue.tx_pkts())
print " Tx Bytes : {}".format(queue.tx_bytes())
print " Tx Errors : {}".format(queue.tx_errs())
print " Duration : {}s".format(queue.time_alive())
print "\n".strip()
else:
print " None"
print("\n")
print(
"<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
" IP Protocol Number (%s)\n"
" IP DSCP (%s)\n"
" TCP Source Port Number (%s)\n"
" TCP Destination Port Number (%s)\n"
" Input Port (%s)" % (hex(eth_type), eth_src,
eth_dst, ipv4_src, ipv4_dst,
ip_proto, ip_dscp,
tcp_src_port, tcp_dst_port,
input_port))
print (" Action: Output (NORMAL)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 16
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority = 1007)
flow_entry.set_flow_cookie(cookie=101)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
# --- Instruction: 'Apply-actions'
# Action: 'Output' NORMAL
instruction = Instruction(instruction_order = 0)
action = OutputAction(order = 0, port = "NORMAL")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
def of_demo_13():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 13 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# VLAN ID
# VLAN PCP
eth_type = ETH_TYPE_IPv4
eth_src = "00:00:00:11:23:ad"
eth_dst = "00:ff:29:01:19:61"
vlan_id = 100
vlan_pcp = PCP_CA # 'Critical Applications' (priority 3)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'"
% (ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" VLAN ID (%s)\n"
" VLAN PCP(%s)"
% (hex(eth_type), eth_src,
eth_dst, vlan_id, vlan_pcp))
print (" Action: Output (to Physical Port Number)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 20
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1011)
# --- Instruction: 'Apply-actions'
# Action: 'Output' to port 7
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=7)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# VLAN ID
# VLAN PCP
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_vlan_id(vlan_id)
match.set_vlan_pcp(vlan_pcp)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node"
% (flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_8():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 8 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# IP Protocol Number
# IP DSCP
# Input Port
# NOTE: Ethernet type MUST be 2048 (0x800) -> IPv4 protocol
eth_type = ETH_TYPE_IPv4
eth_src = "00:1c:01:00:23:aa"
eth_dst = "00:02:02:60:ff:fe"
ipv4_src = "10.0.245.1/24"
ipv4_dst = "192.168.1.123/16"
ip_proto = IP_PROTO_TLSP
ip_dscp = IP_DSCP_CS3 # 'Class Selector' = 'Flash'
input_port = 13
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'"
% (ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" IP Protocol Number (%s)\n"
" IP DSCP (%s)\n"
" Input Port (%s)"
% (hex(eth_type), eth_src,
eth_dst, ipv4_src, ipv4_dst,
ip_proto, ip_dscp,
input_port))
print (" Action: Output (CONTROLLER)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 15
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1006)
flow_entry.set_flow_cookie(cookie=100)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
# --- Instruction: 'Apply-actions'
# Action: 'Output' to CONTROLLER
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="CONTROLLER", max_len=60)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# IP Protocol Number
# IP DSCP
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_ipv4_src(ipv4_src)
match.set_ipv4_dst(ipv4_dst)
match.set_ip_proto(ip_proto)
match.set_ip_dscp(ip_dscp)
match.set_in_port(input_port)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node"
% (flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_13():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 13 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# VLAN ID
# VLAN PCP
eth_type = ETH_TYPE_IPv4
eth_src = "00:00:00:11:23:ad"
eth_dst = "00:ff:29:01:19:61"
vlan_id = 100
vlan_pcp = PCP_CA # 'Critical Applications' (priority 3)
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" VLAN ID (%s)\n"
" VLAN PCP(%s)" %
(hex(eth_type), eth_src, eth_dst, vlan_id, vlan_pcp))
print(" Action: Output (to Physical Port Number)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 20
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1011)
# --- Instruction: 'Apply-actions'
# Action: 'Output' to port 7
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=7)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# VLAN ID
# VLAN PCP
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_vlan_id(vlan_id)
match.set_vlan_pcp(vlan_pcp)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_26():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 26 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
flow_table_id = 0
flow_id_base = 12
flow_id = flow_id_base
flowEntries = []
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(6001)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_idle_timeout(12000)
flow_entry.set_flow_hard_timeout(12000)
flow_entry.set_flow_priority(1000)
instruction = Instruction(instruction_order=0)
action = DropAction(order=0)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
match.set_eth_src("00:11:22:33:44:55")
match.set_eth_dst("aa:bb:cc:dd:ee:ff")
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(7001)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_idle_timeout(2400)
flow_entry.set_flow_hard_timeout(2400)
flow_entry.set_flow_priority(2000)
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="CONTROLLER", max_len=60)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_IPv4)
match.set_ipv4_src("1.2.3.4/32")
match.set_ipv4_dst("192.168.1.11/32")
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(800)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(1800)
flow_entry.set_flow_idle_timeout(1800)
flow_entry.set_flow_priority(3000)
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=5)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=6)
instruction.add_apply_action(action)
action = OutputAction(order=2, port=7)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_in_port(1)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PushVlanHeaderAction(order=0)
action.set_eth_type(ETH_TYPE_QINQ)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_vlan_id(100)
instruction.add_apply_action(action)
action = PushVlanHeaderAction(order=2)
action.set_eth_type(ETH_TYPE_DOT1Q)
instruction.add_apply_action(action)
action = SetFieldAction(order=3)
action.set_vlan_id(998)
instruction.add_apply_action(action)
action = OutputAction(order=4, port=111)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
match.set_vlan_id(998)
match.set_in_port(in_port=110)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PushVlanHeaderAction(order=0)
action.set_eth_type(ETH_TYPE_QINQ)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_vlan_id(100)
instruction.add_apply_action(action)
action = PushVlanHeaderAction(order=2)
action.set_eth_type(ETH_TYPE_DOT1Q)
instruction.add_apply_action(action)
action = SetFieldAction(order=3)
action.set_vlan_id(998)
instruction.add_apply_action(action)
action = OutputAction(order=4, port=111)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_IPv4)
match.set_vlan_id(998)
match.set_in_port(in_port=110)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PopVlanHeaderAction(order=0)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=110)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
match.set_vlan_id(100)
match.set_in_port(111)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PopVlanHeaderAction(order=0)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=110)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_IPv4)
match.set_vlan_id(100)
match.set_in_port(111)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
print ("\n")
print ("<<< Remove configured flows from the Controller")
ofswitch.delete_flows(flow_table_id)
print ("\n")
print ("<<< Set OpenFlow flows on the Controller")
print ("\n")
print ("<<< Flows to be configured:")
flowEntries = sorted(flowEntries, key=lambda fe: fe.get_flow_priority())
for fe in flowEntries:
print (" %s" % fe.to_ofp_oxm_syntax())
time.sleep(rundelay)
success = True
for fe in flowEntries:
result = ofswitch.add_modify_flow(fe)
status = result.get_status()
if(status.eq(STATUS.OK)):
pass
else:
success = False
print ("\n")
print ("!!!Demo terminated, failed to add flow:\n '%s'" %
fe.to_ofp_oxm_syntax())
print (" Failure reason: %s" % status.detailed())
if success:
print "\n"
print ("<<< Flows successfully added to the Controller")
else:
print "\n"
print ("<<< Removing all flows from the Controller")
ofswitch.delete_flows(flow_table_id)
exit(0)
print ("\n")
print ("<<< Get configured flows from the Controller")
time.sleep(rundelay)
print ("\n")
print ("<<< Configured flows:")
result = ofswitch.get_configured_FlowEntries(flow_table_id=0)
status = result.get_status()
if(status.eq(STATUS.OK)):
data = result.get_data()
flowEntries = sorted(data, key=lambda fe: fe.get_flow_priority())
for fe in flowEntries:
print " %s" % fe.to_ofp_oxm_syntax()
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flows by IDs from the Controller:")
time.sleep(rundelay)
for i in range(flow_id_base, flow_id):
result = ofswitch.get_configured_FlowEntry(flow_table_id, i)
status = result.get_status()
if(status.eq(STATUS.OK)):
print (" -- Flow id '%s'" % i)
fe = result.get_data()
print " %s" % fe.to_ofp_oxm_syntax()
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
print ("<<< Removing all flows from the Controller")
ofswitch.delete_flows(flow_table_id)
exit(0)
time.sleep(rundelay)
print ("\n")
print ("<<< Remove configured flows from the Controller")
ofswitch.delete_flows(flow_table_id)
time.sleep(rundelay)
print ("\n")
print ("<<< Get configured flows from the Controller")
result = ofswitch.get_configured_FlowEntries(flow_table_id=0)
status = result.get_status()
if(status.eq(STATUS.DATA_NOT_FOUND)):
print ("\n")
print "<<< No configured flows"
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_5():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 5 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: IPv4 Source Address
# NOTE: Ethernet type MUST be 2048 (0x800) -> IPv4 protocol
eth_type = ETH_TYPE_IPv4
ipv4_src = "10.11.12.13/24"
print ("<<< 'Controller': %s, 'OpenFlow' switch: %s" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" IPv4 Source Address (%s)" %
(hex(eth_type), ipv4_src))
print (" Action: Drop")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 12
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1000)
# --- Instruction: 'Apply-actions'
# Action: 'Drop'
instruction = Instruction(instruction_order=0)
action = DropAction(order=0)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IPv4 Source Address
match = Match()
match.set_eth_type(eth_type)
match.set_ipv4_src(ipv4_src)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_15():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 15 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# VLAN ID
# Input Port
eth_type = ETH_TYPE_IPv4
vlan_id = 100
input_port = 3
# --- Flow Actions: Push VLAN: Ethernet Type
# Set Field: VLAN ID
# Output: Port Number
push_eth_type = ETH_TYPE_DOT1AD # 802.1ad VLAN tagged frame
push_vlan_id = 200
output_port = 5
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" %
(hex(eth_type), vlan_id, input_port))
print (" Action: Push VLAN (Ethernet Type=%s)" %
(hex(push_eth_type)))
print (" Set Field (VLAN ID=%s)" %
(push_vlan_id))
print (" Output (to Physical Port Number %s)" %
(output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
flow_entry.set_flow_name(flow_name="Push VLAN")
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 22
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1013)
flow_entry.set_flow_cookie(cookie=407)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
flow_entry.set_flow_hard_timeout(hard_timeout=3400)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'PushVlan'
# 'SetField'
# 'Output'
instruction = Instruction(instruction_order=0)
action = PushVlanHeaderAction(order=0)
action.set_eth_type(eth_type=push_eth_type)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_vlan_id(vid=push_vlan_id)
instruction.add_apply_action(action)
action = OutputAction(order=2, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_vlan_id(vlan_id)
match.set_in_port(in_port=input_port)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_36():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 36 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print "\n".strip()
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
grp_ids_cfg = []
grp_ids_oper = []
print "\n".strip()
print ("<<< Get OpenFlow Groups Information")
time.sleep(rundelay)
result = ofswitch.get_configured_group_ids()
status = result.get_status()
if(status.eq(STATUS.OK)):
grp_ids_cfg = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_cfg = []
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
result = ofswitch.get_operational_group_ids()
status = result.get_status()
if(status.eq(STATUS.OK)):
grp_ids_oper = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_oper = []
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
# Show current state of the Group Table in the Controller's
# configuration and operational data stores
print_groups(grp_ids_cfg, grp_ids_oper)
# Create new group
group_id = 15
group_type = OFPGT_FF
group_name = "Example of 'link fast failover' group"
watch_port1 = 110
watch_port2 = 111
watch_port3 = 112
out_port1 = 110
out_port2 = 111
out_port3 = 112
print "\n".strip()
print ("<<< Create Group")
print "\n".strip()
print (" Group Type : %s\n"
" Group ID : %s\n"
" Group Name : \"%s\"" %
(group_type.strip('group-').upper(),
group_id, group_name))
print (" Buckets :")
print (" [0] watch-port: %s" %
watch_port1)
print (" actions: Output (%s)" %
out_port1)
print (" [1] watch-port: %s" %
watch_port2)
print (" actions: Output (%s)" %
out_port2)
print (" [2] watch-port: %s" %
watch_port3)
print (" actions: Output (%s)" %
out_port3)
time.sleep(rundelay)
# Allocate a placeholder for the group entry
group_entry = GroupEntry(group_id, group_type)
group_entry.set_group_name(group_name)
# Fill in group entry with action buckets
# ---------
bucket_id = 0
bucket1 = GroupBucket(bucket_id)
bucket1.set_watch_port(watch_port1)
action = OutputAction(order=0, port=out_port1)
bucket1.add_action(action)
group_entry.add_bucket(bucket1)
# ---------
bucket_id += 1
bucket2 = GroupBucket(bucket_id)
bucket2.set_watch_port(watch_port2)
action = OutputAction(order=0, port=out_port2)
bucket2.add_action(action)
group_entry.add_bucket(bucket2)
# ---------
bucket_id += 1
bucket3 = GroupBucket(bucket_id)
bucket3.set_watch_port(watch_port3)
action = OutputAction(order=0, port=out_port3)
bucket3.add_action(action)
group_entry.add_bucket(bucket3)
# Request Controller to create the group
print "\n".strip()
print ("<<< Group to create:")
print group_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_group(group_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Group successfully added")
grp_ids_oper = result.get_data()
else:
print ("\n").strip()
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print ("\n").strip()
print ("<<< Get group '%s' configuration status") % group_id
time.sleep(rundelay)
result = ofswitch.get_configured_group(group_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("Group configuration info:")
group = result.get_data()
print json.dumps(group, indent=4)
else:
print ("\n").strip()
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print ("\n").strip()
print ("<<< Get group '%s' operational status") % group_id
time.sleep(rundelay)
result = ofswitch.get_group_description(group_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("Group operational info:")
group = result.get_data()
print json.dumps(group, indent=4)
else:
print ("\n").strip()
print ("!!!Error, reason: %s" % status.detailed())
print ("\n").strip()
print ("<<< Get group '%s' statistics information") % group_id
time.sleep(rundelay)
result = ofswitch.get_group_statistics(group_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("Group statistics info:")
group = result.get_data()
print json.dumps(group, indent=4)
else:
print ("\n").strip()
print ("!!!Error, reason: %s" % status.detailed())
print ("\n").strip()
print ("<<< Get OpenFlow Groups Information")
time.sleep(rundelay)
result = ofswitch.get_configured_group_ids()
status = result.get_status()
if(status.eq(STATUS.OK)):
grp_ids_cfg = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_cfg = []
else:
print ("\n").strip()
print ("!!!Error, reason: %s" % status.detailed())
result = ofswitch.get_operational_group_ids()
status = result.get_status()
if(status.eq(STATUS.OK)):
grp_ids_oper = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_oper = []
else:
print ("\n").strip()
print ("!!!Error, reason: %s" % status.detailed())
# Show current state of the Group Table in the Controller's
# configuration and operational data stores
print_groups(grp_ids_cfg, grp_ids_oper)
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Group action example"
priority = 1000
cookie = 1400
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
print "\n".strip()
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)" %
(match_in_port, hex(match_eth_type)))
print (" Actions: Apply Group (%s)\n" % group_id)
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = GroupAction(action_order)
action.set_group_id(group_id)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
flow_entry1.add_match(match)
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_groups(ofswitch, grp_ids_cfg)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
print ("<<< Remove all flows from the Controller")
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print "\n".strip()
print ("<<< Remove all groups from the Controller")
for group_id in grp_ids_cfg:
result = ofswitch.delete_group(group_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Group '%s' successfully removed from the Controller" %
group_id)
else:
print ("\n").strip()
print ("!!!Error, failed to remove group '%s', reason: %s" %
(group_id, status.detailed()))
print ("\n").strip()
print ("<<< Get OpenFlow Groups Information")
time.sleep(rundelay)
result = ofswitch.get_configured_group_ids()
status = result.get_status()
if(status.eq(STATUS.OK)):
grp_ids_cfg = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_cfg = []
else:
print ("\n").strip()
print ("!!!Error, reason: %s" % status.detailed())
result = ofswitch.get_operational_group_ids()
status = result.get_status()
if(status.eq(STATUS.OK)):
grp_ids_oper = result.get_data()
elif(status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_oper = []
else:
print ("\n")
print ("!!!Error, reason: %s" % status.detailed())
# Show current state of the Group Table in the Controller's
# configuration and operational data stores
print_groups(grp_ids_cfg, grp_ids_oper)
print ("\n").strip()
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
" IP DSCP (%s)\n"
" IP ECN (%s)\n"
" ICMPv4 Type (%s)\n"
" ICMPv4 Code (%s)\n"
" Input Port (%s)" % (hex(eth_type), eth_src,
eth_dst, ipv4_src, ipv4_dst,
ip_proto, ip_dscp, ip_ecn,
icmpv4_type, icmpv4_code,
input_port))
print (" Action: Output (NORMAL)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 18
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(1009)
# --- Instruction: 'Apply-actions'
# Action: 'Output' NORMAL
instruction = Instruction(instruction_order = 0)
action = OutputAction(order = 0, port = "NORMAL")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
def of_demo_37():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 37 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Modify VLAN ID and VLAN priority example1"
priority = 600
cookie = 1000
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_vlan_id = 100
act_mod_vlan_id = 172
act_mod_vlan_pcp = 2
act_out_port = 112
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" VLAN ID (%s)" %
(match_in_port,
hex(match_eth_type),
match_vlan_id))
print (" Actions: Set VLAN ID (%s)\n"
" Set VLAN priority (%s)\n"
" Output (%s)" %
(act_mod_vlan_id, act_mod_vlan_pcp, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetVlanIdAction(action_order)
action.set_vid(act_mod_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = SetVlanPCPAction(action_order)
action.set_vlan_pcp(act_mod_vlan_pcp)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_vlan_id(match_vlan_id)
flow_entry1.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Modify VLAN ID and VLAN priority example2"
priority = 600
cookie = 1000
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_vlan_id = 111
act_mod_vlan_id = 1024
act_mod_vlan_pcp = 3
act_out_port = 112
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" VLAN ID (%s)" %
(match_in_port,
hex(match_eth_type),
match_vlan_id))
print (" Actions: Set Field (VLAN ID %s)\n"
" Set Field (VLAN PCP %s)\n"
" Output (Port number %s)" %
(act_mod_vlan_id, act_mod_vlan_pcp, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetFieldAction(action_order)
action.set_vlan_id(act_mod_vlan_id)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_vlan_pcp(act_mod_vlan_pcp)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_vlan_id(match_vlan_id)
flow_entry2.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Third flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Strip VLAN header action example"
priority = 600
cookie = 1000
match_in_port = 112
match_eth_type = ETH_TYPE_IPv4
match_vlan_id = 172
act_out_port = 109
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" VLAN ID (%s)" %
(match_in_port,
hex(match_eth_type),
match_vlan_id))
print (" Actions: Strip VLAN header\n"
" Output (Port number %s)" %
(act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry3 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry3.set_flow_table_id(table_id)
flow_entry3.set_flow_name(flow_name)
flow_entry3.set_flow_id(flow_id)
flow_entry3.set_flow_cookie(cookie)
flow_entry3.set_flow_priority(priority)
flow_entry3.set_flow_hard_timeout(0)
flow_entry3.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = StripVlanAction(action_order)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry3.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_vlan_id(match_vlan_id)
flow_entry3.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry3.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry3)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print ("\n")
print ("<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_26():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 26 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
flow_table_id = 0
flow_id_base = 12
flow_id = flow_id_base
flowEntries = []
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(6001)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_idle_timeout(12000)
flow_entry.set_flow_hard_timeout(12000)
flow_entry.set_flow_priority(1000)
instruction = Instruction(instruction_order=0)
action = DropAction(order=0)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
match.set_eth_src("00:11:22:33:44:55")
match.set_eth_dst("aa:bb:cc:dd:ee:ff")
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(7001)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_idle_timeout(2400)
flow_entry.set_flow_hard_timeout(2400)
flow_entry.set_flow_priority(2000)
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="CONTROLLER", max_len=60)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_IPv4)
match.set_ipv4_src("1.2.3.4/32")
match.set_ipv4_dst("192.168.1.11/32")
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(800)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(1800)
flow_entry.set_flow_idle_timeout(1800)
flow_entry.set_flow_priority(3000)
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=5)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=6)
instruction.add_apply_action(action)
action = OutputAction(order=2, port=7)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_in_port(1)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PushVlanHeaderAction(order=0)
action.set_eth_type(ETH_TYPE_QINQ)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_vlan_id(100)
instruction.add_apply_action(action)
action = PushVlanHeaderAction(order=2)
action.set_eth_type(ETH_TYPE_DOT1Q)
instruction.add_apply_action(action)
action = SetFieldAction(order=3)
action.set_vlan_id(998)
instruction.add_apply_action(action)
action = OutputAction(order=4, port=111)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
match.set_vlan_id(998)
match.set_in_port(in_port=110)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PushVlanHeaderAction(order=0)
action.set_eth_type(ETH_TYPE_QINQ)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_vlan_id(100)
instruction.add_apply_action(action)
action = PushVlanHeaderAction(order=2)
action.set_eth_type(ETH_TYPE_DOT1Q)
instruction.add_apply_action(action)
action = SetFieldAction(order=3)
action.set_vlan_id(998)
instruction.add_apply_action(action)
action = OutputAction(order=4, port=111)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_IPv4)
match.set_vlan_id(998)
match.set_in_port(in_port=110)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PopVlanHeaderAction(order=0)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=110)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
match.set_vlan_id(100)
match.set_in_port(111)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(1234)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(4000)
instruction = Instruction(instruction_order=0)
action = PopVlanHeaderAction(order=0)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=110)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_IPv4)
match.set_vlan_id(100)
match.set_in_port(111)
flow_entry.add_match(match)
flowEntries.append(flow_entry)
print("\n")
print("<<< Remove configured flows from the Controller")
ofswitch.delete_flows(flow_table_id)
print("\n")
print("<<< Set OpenFlow flows on the Controller")
print("\n")
print("<<< Flows to be configured:")
flowEntries = sorted(flowEntries, key=lambda fe: fe.get_flow_priority())
for fe in flowEntries:
print(" %s" % fe.to_ofp_oxm_syntax())
time.sleep(rundelay)
success = True
for fe in flowEntries:
result = ofswitch.add_modify_flow(fe)
status = result.get_status()
if (status.eq(STATUS.OK)):
pass
else:
success = False
print("\n")
print("!!!Demo terminated, failed to add flow:\n '%s'" %
fe.to_ofp_oxm_syntax())
print(" Failure reason: %s" % status.detailed())
if success:
print "\n"
print("<<< Flows successfully added to the Controller")
else:
print "\n"
print("<<< Removing all flows from the Controller")
ofswitch.delete_flows(flow_table_id)
exit(0)
print("\n")
print("<<< Get configured flows from the Controller")
time.sleep(rundelay)
print("\n")
print("<<< Configured flows:")
result = ofswitch.get_configured_FlowEntries(flow_table_id=0)
status = result.get_status()
if (status.eq(STATUS.OK)):
data = result.get_data()
flowEntries = sorted(data, key=lambda fe: fe.get_flow_priority())
for fe in flowEntries:
print " %s" % fe.to_ofp_oxm_syntax()
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flows by IDs from the Controller:")
time.sleep(rundelay)
for i in range(flow_id_base, flow_id):
result = ofswitch.get_configured_FlowEntry(flow_table_id, i)
status = result.get_status()
if (status.eq(STATUS.OK)):
print(" -- Flow id '%s'" % i)
fe = result.get_data()
print " %s" % fe.to_ofp_oxm_syntax()
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
print("<<< Removing all flows from the Controller")
ofswitch.delete_flows(flow_table_id)
exit(0)
time.sleep(rundelay)
print("\n")
print("<<< Remove configured flows from the Controller")
ofswitch.delete_flows(flow_table_id)
time.sleep(rundelay)
print("\n")
print("<<< Get configured flows from the Controller")
result = ofswitch.get_configured_FlowEntries(flow_table_id=0)
status = result.get_status()
if (status.eq(STATUS.DATA_NOT_FOUND)):
print("\n")
print "<<< No configured flows"
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
rundelay = 5
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" % (ctrlIpAddr, nodeName))
flow_table_id = 0
flow_id_base = 12
flow_id = flow_id_base
flowEntries = []
# Sample flow entry
flow_entry = FlowEntry()
flow_entry.set_flow_cookie(6001)
flow_entry.set_flow_table_id(flow_table_id)
flow_entry.set_flow_id(flow_id)
flow_id += 1
flow_entry.set_flow_idle_timeout(12000)
flow_entry.set_flow_hard_timeout(12000)
flow_entry.set_flow_priority(1000)
instruction = Instruction(instruction_order = 0)
action = DropAction(order = 0)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
match = Match()
match.set_eth_type(ETH_TYPE_ARP)
def of_demo_16():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 16 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
eth_type = ETH_TYPE_IPv6
ipv6_src = "fe80::2acf:e9ff:fe21:6431/128"
ipv6_dst = "aabb:1234:2acf:e9ff::fe21:6431/64"
# --- Flow Actions: Output (CONTROLLER)
output_port = "CONTROLLER"
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)" %
(hex(eth_type), ipv6_src, ipv6_dst))
print (" Action: Output (to %s)" %
(output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
fname = "match=ipv6_src,ipv6_dst;actions=output:Controller"
flow_entry.set_flow_name(flow_name=fname)
table_id = 0
flow_id = 23
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1014)
flow_entry.set_flow_cookie(cookie=408)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
flow_entry.set_flow_hard_timeout(hard_timeout=3400)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
match = Match()
match.set_eth_type(eth_type)
match.set_ipv6_src(ipv6_src)
match.set_ipv6_dst(ipv6_dst)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_38():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 38 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Modify source and destination MAC addresses example1"
priority = 700
cookie = 1100
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_ipv4_src_addr = "10.0.0.4/32"
act_mod_src_mac_addr = "00:00:00:11:23:ae"
act_mod_dst_mac_addr = "a0:ff:29:01:19:61"
act_out_port = 112
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Source Address (%s)" %
(match_in_port,
hex(match_eth_type),
match_ipv4_src_addr))
print (" Actions: Modify Ethernet Source MAC Address (%s)\n"
" Modify Ethernet Destination MAC Address (%s)\n"
" Output (%s)" %
(act_mod_src_mac_addr, act_mod_dst_mac_addr, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetDlSrcAction(action_order)
action.set_dl_src(act_mod_src_mac_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetDlDstAction(action_order)
action.set_dl_dst(act_mod_dst_mac_addr)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ipv4_src(match_ipv4_src_addr)
flow_entry1.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Modify source and destination MAC addresses example2"
priority = 700
cookie = 1100
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_ipv4_src_addr = "192.1.0.11/32"
act_mod_src_mac_addr = "00:1c:42:80:bd:66"
act_mod_dst_mac_addr = "aa:1d:40:60:7c:9f"
act_out_port = 112
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Source Address (%s)" %
(match_in_port,
hex(match_eth_type),
match_ipv4_src_addr))
print (" Actions: Set Field (Ethernet Source MAC Address %s)\n"
" Set Field (Ethernet Destination MAC Address %s)\n"
" Output (%s)" %
(act_mod_src_mac_addr, act_mod_dst_mac_addr, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetFieldAction(action_order)
action.set_eth_src(act_mod_src_mac_addr)
instruction.add_apply_action(action)
action_order += 1
action = SetFieldAction(action_order)
action.set_eth_dst(act_mod_dst_mac_addr)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ipv4_src(match_ipv4_src_addr)
flow_entry2.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print ("\n")
print ("<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_36():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 36 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print "\n".strip()
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
grp_ids_cfg = []
grp_ids_oper = []
print "\n".strip()
print("<<< Get OpenFlow Groups Information")
time.sleep(rundelay)
result = ofswitch.get_configured_group_ids()
status = result.get_status()
if (status.eq(STATUS.OK)):
grp_ids_cfg = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_cfg = []
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
result = ofswitch.get_operational_group_ids()
status = result.get_status()
if (status.eq(STATUS.OK)):
grp_ids_oper = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_oper = []
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
# Show current state of the Group Table in the Controller's
# configuration and operational data stores
print_groups(grp_ids_cfg, grp_ids_oper)
# Create new group
group_id = 15
group_type = OFPGT_FF
group_name = "Example of 'link fast failover' group"
watch_port1 = 110
watch_port2 = 111
watch_port3 = 112
out_port1 = 110
out_port2 = 111
out_port3 = 112
print "\n".strip()
print("<<< Create Group")
print "\n".strip()
print(
" Group Type : %s\n"
" Group ID : %s\n"
" Group Name : \"%s\"" %
(group_type.strip('group-').upper(), group_id, group_name))
print(" Buckets :")
print(" [0] watch-port: %s" % watch_port1)
print(" actions: Output (%s)" % out_port1)
print(" [1] watch-port: %s" % watch_port2)
print(" actions: Output (%s)" % out_port2)
print(" [2] watch-port: %s" % watch_port3)
print(" actions: Output (%s)" % out_port3)
time.sleep(rundelay)
# Allocate a placeholder for the group entry
group_entry = GroupEntry(group_id, group_type)
group_entry.set_group_name(group_name)
# Fill in group entry with action buckets
# ---------
bucket_id = 0
bucket1 = GroupBucket(bucket_id)
bucket1.set_watch_port(watch_port1)
action = OutputAction(order=0, port=out_port1)
bucket1.add_action(action)
group_entry.add_bucket(bucket1)
# ---------
bucket_id += 1
bucket2 = GroupBucket(bucket_id)
bucket2.set_watch_port(watch_port2)
action = OutputAction(order=0, port=out_port2)
bucket2.add_action(action)
group_entry.add_bucket(bucket2)
# ---------
bucket_id += 1
bucket3 = GroupBucket(bucket_id)
bucket3.set_watch_port(watch_port3)
action = OutputAction(order=0, port=out_port3)
bucket3.add_action(action)
group_entry.add_bucket(bucket3)
# Request Controller to create the group
print "\n".strip()
print("<<< Group to create:")
print group_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_group(group_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Group successfully added")
grp_ids_oper = result.get_data()
else:
print("\n").strip()
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print("\n").strip()
print("<<< Get group '%s' configuration status") % group_id
time.sleep(rundelay)
result = ofswitch.get_configured_group(group_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("Group configuration info:")
group = result.get_data()
print json.dumps(group, indent=4)
else:
print("\n").strip()
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print("\n").strip()
print("<<< Get group '%s' operational status") % group_id
time.sleep(rundelay)
result = ofswitch.get_group_description(group_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("Group operational info:")
group = result.get_data()
print json.dumps(group, indent=4)
else:
print("\n").strip()
print("!!!Error, reason: %s" % status.detailed())
print("\n").strip()
print("<<< Get group '%s' statistics information") % group_id
time.sleep(rundelay)
result = ofswitch.get_group_statistics(group_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("Group statistics info:")
group = result.get_data()
print json.dumps(group, indent=4)
else:
print("\n").strip()
print("!!!Error, reason: %s" % status.detailed())
print("\n").strip()
print("<<< Get OpenFlow Groups Information")
time.sleep(rundelay)
result = ofswitch.get_configured_group_ids()
status = result.get_status()
if (status.eq(STATUS.OK)):
grp_ids_cfg = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_cfg = []
else:
print("\n").strip()
print("!!!Error, reason: %s" % status.detailed())
result = ofswitch.get_operational_group_ids()
status = result.get_status()
if (status.eq(STATUS.OK)):
grp_ids_oper = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_oper = []
else:
print("\n").strip()
print("!!!Error, reason: %s" % status.detailed())
# Show current state of the Group Table in the Controller's
# configuration and operational data stores
print_groups(grp_ids_cfg, grp_ids_oper)
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Group action example"
priority = 1000
cookie = 1400
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
print "\n".strip()
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)" %
(match_in_port, hex(match_eth_type)))
print(" Actions: Apply Group (%s)\n" % group_id)
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = GroupAction(action_order)
action.set_group_id(group_id)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
flow_entry1.add_match(match)
print("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_groups(ofswitch, grp_ids_cfg)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print "\n".strip()
print("<<< Remove all flows from the Controller")
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print "\n".strip()
print("<<< Remove all groups from the Controller")
for group_id in grp_ids_cfg:
result = ofswitch.delete_group(group_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Group '%s' successfully removed from the Controller" %
group_id)
else:
print("\n").strip()
print("!!!Error, failed to remove group '%s', reason: %s" %
(group_id, status.detailed()))
print("\n").strip()
print("<<< Get OpenFlow Groups Information")
time.sleep(rundelay)
result = ofswitch.get_configured_group_ids()
status = result.get_status()
if (status.eq(STATUS.OK)):
grp_ids_cfg = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_cfg = []
else:
print("\n").strip()
print("!!!Error, reason: %s" % status.detailed())
result = ofswitch.get_operational_group_ids()
status = result.get_status()
if (status.eq(STATUS.OK)):
grp_ids_oper = result.get_data()
elif (status.eq(STATUS.DATA_NOT_FOUND)):
grp_ids_oper = []
else:
print("\n")
print("!!!Error, reason: %s" % status.detailed())
# Show current state of the Group Table in the Controller's
# configuration and operational data stores
print_groups(grp_ids_cfg, grp_ids_oper)
print("\n").strip()
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_22():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 22 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# Input Port
# IPv4 Destination Address
eth_type = ETH_TYPE_IPv4
in_port = 13
ipv4_dst = "10.12.5.4/32"
# --- Flow Actions: Push MPLS
# Set Field
# Output
push_ether_type = ETH_TYPE_MPLS_UCAST
mpls_label = 27
output_port = 14
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" Input Port (%s)\n"
" IPv4 Destination Address (%s)" %
(hex(eth_type), in_port, ipv4_dst))
print(
" Action: Push MPLS Header (Ethernet Type %s)\n"
" Set Field (MPLS label %s)\n"
" Output (Physical Port number %s)" %
(hex(push_ether_type), mpls_label, output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 28
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_name(flow_name="Push MPLS Label")
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(hard_timeout=0)
flow_entry.set_flow_idle_timeout(idle_timeout=0)
flow_entry.set_flow_priority(flow_priority=1021)
flow_entry.set_flow_cookie(cookie=654)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
# --- Instruction: 'Apply-actions'
# Actions: 'Push MPLS Header'
# 'Set Field'
# 'Output'
instruction = Instruction(instruction_order=0)
action = PushMplsHeaderAction(order=0)
action.set_eth_type(push_ether_type)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_mpls_label(mpls_label)
instruction.add_apply_action(action)
action = OutputAction(order=2, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Input Port
# IPv4 Destination Address
match = Match()
match.set_eth_type(eth_type)
match.set_in_port(in_port)
match.set_ipv4_dst(ipv4_dst)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
eth_dst = "ff:ff:ff:ff:ff:ff"
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" % (ctrlIpAddr, node))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)" % (hex(eth_type), eth_src, eth_dst))
print (" Action: Drop")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 14
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority = 1000)
# --- Instruction: 'Apply-action'
# Action: 'Drop'
instruction = Instruction(instruction_order = 0)
action = DropAction(action_order = 0)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
def of_demo_6():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 6 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Addresses
eth_type = 45 # (0x002D)
eth_src = "00:01:02:03:04:05"
eth_dst = "aa:bb:cc:dd:ee:ff"
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)" %
(hex(eth_type), eth_src, eth_dst))
print (" Action: Drop")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 14
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1000)
# --- Instruction: 'Apply-actions'
# Action: 'Drop'
instruction = Instruction(instruction_order=0)
action = DropAction(order=0)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_15():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 15 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# VLAN ID
# Input Port
eth_type = ETH_TYPE_IPv4
vlan_id = 100
input_port = 3
# --- Flow Actions: Push VLAN: Ethernet Type
# Set Field: VLAN ID
# Output: Port Number
push_eth_type = ETH_TYPE_DOT1AD # 802.1ad VLAN tagged frame
push_vlan_id = 200
output_port = 5
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" VLAN ID (%s)\n"
" Input Port (%s)" %
(hex(eth_type), vlan_id, input_port))
print(" Action: Push VLAN (Ethernet Type=%s)" %
(hex(push_eth_type)))
print(" Set Field (VLAN ID=%s)" % (push_vlan_id))
print(" Output (to Physical Port Number %s)" %
(output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
flow_entry.set_flow_name(flow_name="Push VLAN")
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 22
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1013)
flow_entry.set_flow_cookie(cookie=407)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
flow_entry.set_flow_hard_timeout(hard_timeout=3400)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'PushVlan'
# 'SetField'
# 'Output'
instruction = Instruction(instruction_order=0)
action = PushVlanHeaderAction(order=0)
action.set_eth_type(eth_type=push_eth_type)
instruction.add_apply_action(action)
action = SetFieldAction(order=1)
action.set_vlan_id(vid=push_vlan_id)
instruction.add_apply_action(action)
action = OutputAction(order=2, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_vlan_id(vlan_id)
match.set_in_port(in_port=input_port)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_23():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 23 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# Input Port
# IPv4 Destination Address
eth_type = ETH_TYPE_MPLS_UCAST
in_port = 13
mpls_label = 27
# --- Flow Actions: Set Field
# Output
new_mpls_label = 44
output_port = 14
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Input Port (%s)\n"
" MPLS Label (%s)" %
(hex(eth_type), in_port, mpls_label))
print (" Action: Set Field (MPLS Label %s)\n"
" Output (Physical Port number %s)" %
(new_mpls_label, output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_id = 29
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_name(flow_name="Change MPLS Label")
flow_entry.set_flow_hard_timeout(hard_timeout=0)
flow_entry.set_flow_idle_timeout(idle_timeout=0)
flow_entry.set_flow_priority(flow_priority=1022)
flow_entry.set_flow_cookie(cookie=401)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
# --- Instruction: 'Apply-actions'
# Actions: 'Set Field'
# 'Output'
instruction = Instruction(instruction_order=0)
action = SetFieldAction(order=0)
action.set_mpls_label(new_mpls_label)
instruction.add_apply_action(action)
action = OutputAction(order=1, port=2)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Input Port
# MPLS Label
match = Match()
match.set_eth_type(eth_type)
match.set_in_port(in_port)
match.set_mpls_label(mpls_label)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.detailed())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_19():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 19 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
# IP DSCP
# TCP Source Port
# TCP Destination Port
eth_type = ETH_TYPE_IPv6
ipv6_src = "4231::3210:3210:3210:3210/80"
ipv6_dst = "1234:1234:1234:1234::5678:5678/64"
ipv6_flabel = 33
ip_dscp = IP_DSCP_CS5 # 'Class Selector' = 'Critical'
ip_proto = IP_PROTO_TCP
tcp_src_port = 11111
tcp_dst_port = 22222
# --- Flow Actions: Output (CONTROLLER)
output_port = "CONTROLLER"
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Ethernet Type (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)\n"
" IPv6 Flow Label (%s)\n"
" IP DSCP (%s)\n"
" TCP Source Port (%s)\n"
" TCP Destination Port (%s)" %
(hex(eth_type), ipv6_src, ipv6_dst, ipv6_flabel, ip_dscp, tcp_src_port,
tcp_dst_port))
print(" Action: Output (to %s)" % (output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
flow_entry.set_flow_name(flow_name="demo19.py")
table_id = 0
flow_id = 25
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1018)
flow_entry.set_flow_cookie(cookie=23)
flow_entry.set_flow_hard_timeout(hard_timeout=1200)
flow_entry.set_flow_idle_timeout(idle_timeout=3400)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
# IPv6 Flow Label
# IP protocol number (TCP)
# IP DSCP
# TCP Source Port
# TCP Destination Port
match = Match()
match.set_eth_type(eth_type)
match.set_ipv6_src(ipv6_src)
match.set_ipv6_dst(ipv6_dst)
match.set_ipv6_flabel(ipv6_flabel)
match.set_ip_proto(ip_proto)
match.set_ip_dscp(ip_dscp)
match.set_tcp_src(tcp_src_port)
match.set_tcp_dst(tcp_dst_port)
flow_entry.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully read from the Controller")
print("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(
"<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully removed from the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_9():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 9 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# TCP Source Port Number
# TCP Destination Port Number
# IP DSCP
# Input Port
# NOTE: Ethernet type MUST be 2048 (0x800) -> IPv4 protocol
eth_type = ETH_TYPE_IPv4
eth_src = "00:00:00:11:23:ae"
eth_dst = "ff:ff:29:01:19:61"
ipv4_src = "17.1.2.3/8"
ipv4_dst = "172.168.5.6/16"
ip_proto = IP_PROTO_TCP
# Assured Forwarding ('class'=1, 'drop precedence'=2)
ip_dscp = IP_DSCP_AF12
tcp_src_port = 25364
tcp_dst_port = 8080
input_port = 13
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" Ethernet Source Address (%s)\n"
" Ethernet Destination Address (%s)\n"
" IPv4 Source Address (%s)\n"
" IPv4 Destination Address (%s)\n"
" IP Protocol Number (%s)\n"
" IP DSCP (%s)\n"
" TCP Source Port Number (%s)\n"
" TCP Destination Port Number (%s)\n"
" Input Port (%s)" %
(hex(eth_type), eth_src,
eth_dst, ipv4_src, ipv4_dst,
ip_proto, ip_dscp,
tcp_src_port, tcp_dst_port,
input_port))
print (" Action: Output (NORMAL)")
time.sleep(rundelay)
flow_entry = FlowEntry()
table_id = 0
flow_entry.set_flow_table_id(table_id)
flow_id = 16
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_priority(flow_priority=1007)
flow_entry.set_flow_cookie(cookie=101)
flow_entry.set_flow_cookie_mask(cookie_mask=255)
# --- Instruction: 'Apply-actions'
# Action: 'Output' NORMAL
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port="NORMAL")
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# Ethernet Source Address
# Ethernet Destination Address
# IPv4 Source Address
# IPv4 Destination Address
# IP Protocol Number
# IP DSCP
# IP ECN
# TCP Source Port Number
# TCP Destination Port Number
# Input Port
match = Match()
match.set_eth_type(eth_type)
match.set_eth_src(eth_src)
match.set_eth_dst(eth_dst)
match.set_ipv4_src(ipv4_src)
match.set_ipv4_dst(ipv4_dst)
match.set_ip_proto(ip_proto)
match.set_ip_dscp(ip_dscp)
match.set_tcp_src(tcp_src_port)
match.set_tcp_dst(tcp_dst_port)
match.set_in_port(input_port)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node" %
(flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_18():
f = "cfg.yml"
d = {}
if(load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit()
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print ("Failed to get Controller device attributes")
exit(0)
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print ("<<< Demo 18 Start")
print ("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
# --- Flow Match: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
# IP DSCP
# TCP Source Port
# TCP Destination Port
eth_type = ETH_TYPE_IPv6
ipv6_src = "2001::2acf:e9ff:fe21:6431/80"
ipv6_dst = "2004:1234:2acf:e9ff::fe21:6431/64"
ip_dscp = IP_DSCP_CS1 # 'Class Selector' = 'Priority'
ip_proto = IP_PROTO_TCP
tcp_src_port = 12345
tcp_dst_port = 54321
# --- Flow Actions: Output (CONTROLLER)
output_port = "CONTROLLER"
print ("<<< 'Controller': %s, 'OpenFlow' switch: '%s'"
% (ctrlIpAddr, nodeName))
print "\n"
print ("<<< Set OpenFlow flow on the Controller")
print (" Match: Ethernet Type (%s)\n"
" IPv6 Source Address (%s)\n"
" IPv6 Destination Address (%s)\n"
" IP DSCP (%s)\n"
" TCP Source Port (%s)\n"
" TCP Destination Port (%s)"
% (hex(eth_type), ipv6_src, ipv6_dst,
ip_dscp, tcp_src_port, tcp_dst_port))
print (" Action: Output (to %s)"
% (output_port))
time.sleep(rundelay)
flow_entry = FlowEntry()
flow_entry.set_flow_name(flow_name="demo18.py")
table_id = 0
flow_id = 24
flow_entry.set_flow_table_id(table_id)
flow_entry.set_flow_id(flow_id)
flow_entry.set_flow_hard_timeout(0)
flow_entry.set_flow_idle_timeout(0)
flow_entry.set_flow_priority(flow_priority=1017)
# --- Instruction: 'Apply-actions'
# Actions: 'Output'
instruction = Instruction(instruction_order=0)
action = OutputAction(order=0, port=output_port)
instruction.add_apply_action(action)
flow_entry.add_instruction(instruction)
# --- Match Fields: Ethernet Type
# IPv6 Source Address
# IPv6 Destination Address
# IP protocol number (TCP)
# IP DSCP
# TCP Source Port
# TCP Destination Port
match = Match()
match.set_eth_type(eth_type)
match.set_ipv6_src(ipv6_src)
match.set_ipv6_dst(ipv6_dst)
match.set_ip_proto(ip_proto)
match.set_ip_dscp(ip_dscp)
match.set_tcp_src_port(tcp_src_port)
match.set_tcp_dst_port(tcp_dst_port)
flow_entry.add_match(match)
print ("\n")
print ("<<< Flow to send:")
print flow_entry.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully added to the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Get configured flow from the Controller")
time.sleep(rundelay)
result = ofswitch.get_configured_flow(table_id, flow_id)
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully read from the Controller")
print ("Flow info:")
flow = result.get_data()
print json.dumps(flow, indent=4)
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print ("<<< Delete flow with id of '%s' from the Controller's cache "
"and from the table '%s' on the '%s' node"
% (flow_id, table_id, nodeName))
time.sleep(rundelay)
result = ofswitch.delete_flow(flow_entry.get_flow_table_id(),
flow_entry.get_flow_id())
status = result.get_status()
if(status.eq(STATUS.OK)):
print ("<<< Flow successfully removed from the Controller")
else:
print ("\n")
print ("!!!Demo terminated, reason: %s" % status.brief().lower())
exit(0)
print ("\n")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print (">>> Demo End")
print (">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
def of_demo_31():
f = "cfg.yml"
d = {}
if (load_dict_from_file(f, d) is False):
print("Config file '%s' read error: " % f)
exit(0)
try:
ctrlIpAddr = d['ctrlIpAddr']
ctrlPortNum = d['ctrlPortNum']
ctrlUname = d['ctrlUname']
ctrlPswd = d['ctrlPswd']
nodeName = d['nodeName']
rundelay = d['rundelay']
except:
print("Failed to get Controller device attributes")
exit(0)
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
print("<<< Demo 31 Start")
print("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<")
ctrl = Controller(ctrlIpAddr, ctrlPortNum, ctrlUname, ctrlPswd)
ofswitch = OFSwitch(ctrl, nodeName)
print("<<< 'Controller': %s, 'OpenFlow' switch: '%s'" %
(ctrlIpAddr, nodeName))
first_flow_id = 110
# ---------------------------------------------------
# First flow entry
# ---------------------------------------------------
table_id = 0
flow_id = first_flow_id
flow_name = "Set IPv4 ToS action"
priority = 600
cookie = 1000
match_in_port = 109
match_ip_eth_type = ETH_TYPE_IPv4
match_ipv4_dst = "10.1.2.3/32"
mod_nw_tos = 8
act_out_port = 112
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Destination Address (%s)" %
(match_in_port, hex(match_ip_eth_type), match_ipv4_dst))
print(
" Actions: Set IPv4 ToS (tos %s)\n"
" Output (Port number %s)" %
(mod_nw_tos, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry1 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry1.set_flow_table_id(table_id)
flow_entry1.set_flow_name(flow_name)
flow_entry1.set_flow_id(flow_id)
flow_entry1.set_flow_cookie(cookie)
flow_entry1.set_flow_priority(priority)
flow_entry1.set_flow_hard_timeout(0)
flow_entry1.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetNwTosAction(action_order)
action.set_tos(mod_nw_tos)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry1.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_ip_eth_type)
match.set_ipv4_dst(match_ipv4_dst)
flow_entry1.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry1.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry1)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
# ---------------------------------------------------
# Second flow entry
# ---------------------------------------------------
table_id = 0
flow_id += 1
flow_name = "Set Field (IP DSCP) action"
priority = 600
cookie = 1000
match_in_port = 109
match_eth_type = ETH_TYPE_IPv4
match_ipv4_dst = "192.1.2.3/32"
mod_ip_dscp = IP_DSCP_CS5
act_out_port = 112
print "\n"
print("<<< Set OpenFlow flow on the Controller")
print(
" Match: Input Port (%s)\n"
" Ethernet Type (%s)\n"
" IPv4 Destination Address (%s)" %
(match_in_port, hex(match_ip_eth_type), match_ipv4_dst))
print(
" Actions: Set Field (IP DSCP %s)\n"
" Output (Port number %s)" %
(mod_ip_dscp, act_out_port))
time.sleep(rundelay)
# Allocate a placeholder for the Flow Entry
flow_entry2 = FlowEntry()
# Generic attributes of the Flow Entry
flow_entry2.set_flow_table_id(table_id)
flow_entry2.set_flow_name(flow_name)
flow_entry2.set_flow_id(flow_id)
flow_entry2.set_flow_cookie(cookie)
flow_entry2.set_flow_priority(priority)
flow_entry2.set_flow_hard_timeout(0)
flow_entry2.set_flow_idle_timeout(0)
# Instructions/Actions for the Flow Entry
instruction = Instruction(instruction_order=0)
action_order = 0
action = SetFieldAction(action_order)
action.set_ip_dscp(mod_ip_dscp)
instruction.add_apply_action(action)
action_order += 1
action = OutputAction(action_order)
action.set_outport(act_out_port)
instruction.add_apply_action(action)
flow_entry2.add_instruction(instruction)
# Match Fields for the Flow Entry
match = Match()
match.set_in_port(match_in_port)
match.set_eth_type(match_eth_type)
match.set_ipv4_dst(match_ipv4_dst)
flow_entry2.add_match(match)
print("\n")
print("<<< Flow to send:")
print flow_entry2.get_payload()
time.sleep(rundelay)
result = ofswitch.add_modify_flow(flow_entry2)
status = result.get_status()
if (status.eq(STATUS.OK)):
print("<<< Flow successfully added to the Controller")
else:
print("\n")
print("!!!Demo terminated, reason: %s" % status.detailed())
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
exit(0)
print("\n")
print(
"<<< Delete flows from the Controller's cache "
"and from the table '%s' on the '%s' node" % (table_id, nodeName))
time.sleep(rundelay)
delete_flows(ofswitch, table_id, range(first_flow_id, flow_id + 1))
print("\n")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
print(">>> Demo End")
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")