def updateConfig(self):
'''
Performs a SetForwardingPipelineConfig on the device with provided
P4Info and binary device config.
Prerequisite: setUp() method has been called first to create
the channel.
'''
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = self.device_id
config = request.config
# TBD: It seems like there should be a way to do this without
# reading the P4info file again, instead getting the data from
# self.p4info as saved when executing the setUp() method
# above. The following commented-out assignment does not work.
#config.p4info = self.p4info
proto_txt_path = testutils.test_param_get("p4info")
with open(proto_txt_path, 'r') as fin:
google.protobuf.text_format.Merge(fin.read(), config.p4info)
config_path = testutils.test_param_get("config")
logging.info(
"Reading config (compiled P4 program) from {}".format(config_path))
with open(config_path, 'rb') as config_f:
config.p4_device_config = config_f.read()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
response = self.stub.SetForwardingPipelineConfig(request)
except Exception as e:
logging.error("Error during SetForwardingPipelineConfig",
file=sys.stderr)
logging.error(str(e), file=sys.stderr)
return False
return True
def SetForwardingPipelineConfig(self, p4info, dry_run=False, **kwargs):
device_config = self.buildDeviceConfig(**kwargs)
device_config.reassign = True
with open(kwargs['bmv2_json_file_path']) as f:
device_config.device_data = f.read()
self.bmv2_json_file_path = kwargs['bmv2_json_file_path']
#return
#with open(bmv2_json_file_path) as f:
# device_config.device_data = f.read()
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.election_id.low = 1
request.device_id = self.device_id
config = request.config
config.p4info.CopyFrom(p4info)
config.p4_device_config = device_config.SerializeToString()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
if dry_run:
print "P4Runtime SetForwardingPipelineConfig:", request
else:
self.client_stub.SetForwardingPipelineConfig(request)
def update_config(p4info_path, bmv2_json_path, tofino_bin_path,
tofino_cxt_json_path, grpc_addr, device_id):
"""
Performs a SetForwardingPipelineConfig on the device
"""
channel = grpc.insecure_channel(grpc_addr)
stub = p4runtime_pb2.P4RuntimeStub(channel)
info("Sending P4 config")
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = device_id
config = request.config
with open(p4info_path, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
if bmv2_json_path is not None:
device_config = build_bmv2_config(bmv2_json_path)
else:
device_config = build_tofino_config("name", tofino_bin_path,
tofino_cxt_json_path)
config.p4_device_config = device_config.SerializeToString()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
stub.SetForwardingPipelineConfig(request)
except Exception as e:
error("Error during SetForwardingPipelineConfig")
error(str(e))
return False
return True
def SetForwardingPipelineConfig(self, p4info, dry_run=False, **kwargs):
device_config = self.buildDeviceConfig(**kwargs)
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = self.device_id
config = request.config
config.p4info.CopyFrom(p4info)
config.p4_device_config = device_config.SerializeToString()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
if dry_run:
print "P4 Runtime SetForwardingPipelineConfig:", request
else:
self.client_stub.SetForwardingPipelineConfig(request)
def set_fwd_pipe_config(self, p4info_path, bin_path):
logging.debug("Setting forwarding pipeline config")
req = p4runtime_pb2.SetForwardingPipelineConfigRequest()
req.device_id = self.device_id
election_id = req.election_id
election_id.high = self.election_id[0]
election_id.low = self.election_id[1]
req.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
with open(p4info_path, 'r') as f1:
with open(bin_path, 'rb') as f2:
try:
google.protobuf.text_format.Merge(f1.read(), req.config.p4info)
except google.protobuf.text_format.ParseError:
logging.error("Error when parsing P4Info")
raise
req.config.p4_device_config = f2.read()
return self.stub.SetForwardingPipelineConfig(req)
def update_config(self):
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = self.device_id
request.election_id.high = 0
request.election_id.low = 1
config = request.config
with open(args.p4info, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
device_config = build_bmv2_config(args.json)
config.p4_device_config = device_config.SerializeToString()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
self.stub.SetForwardingPipelineConfig(request)
except Exception as e:
print "Error during SetForwardingPipelineConfig"
print str(e)
return False
return True
def set_forwarding_pipeline_config(self, device_config):
logger.info('Setting Forwarding Pipeline Config on switch - [%s] ',
self.grpc_addr)
logger.debug('P4Info - [%s] ', self.p4info_helper.p4info)
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.election_id.low = 1
request.device_id = self.device_id
config = request.config
config.p4info.CopyFrom(self.p4info_helper.p4info)
config.p4_device_config = device_config.SerializeToString()
request.action = \
p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
logger.info('Request for SetForwardingPipelineConfig to device - [%s]',
self.name)
self.client_stub.SetForwardingPipelineConfig(request)
logger.info('Completed SetForwardingPipelineConfig to device - [%s]',
request.device_id)
def update_config(config_path, p4info_path, grpc_addr, device_id):
'''
Performs a SetForwardingPipelineConfig on the device with provided
P4Info and binary device config
'''
channel = grpc.insecure_channel(grpc_addr)
stub = p4runtime_pb2.P4RuntimeStub(channel)
print("Sending P4 config")
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = device_id
config = request.config
with open(p4info_path, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
with open(config_path, 'rb') as config_f:
config.p4_device_config = config_f.read()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
response = stub.SetForwardingPipelineConfig(request)
except Exception as e:
print("Error during SetForwardingPipelineConfig")
print(str(e))
return False
return True
def update_config(self):
print("Setting Forwarding Pipeline")
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = self.device_id
election_id = request.election_id
election_id.high = 0
election_id.low = self.election_id
request.role_id = self.role_id
config = request.config
with open(self.p4info_path, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
if self.device == "bmv2":
device_config = self.build_bmv2_config()
else:
device_config = self.build_tofino_config("name", self.config_path,
self.ctx_json_path)
config.p4_device_config = device_config.SerializeToString()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
response = self.stub.SetForwardingPipelineConfig(request)
except Exception as e:
raise
return False
return True
def update_config(p4info_path, bmv2_json_path, grpc_addr, device_id):
"""
Performs a SetForwardingPipelineConfig on the device
"""
channel = grpc.insecure_channel(grpc_addr)
stub = p4runtime_pb2_grpc.P4RuntimeStub(channel)
debug("Sending P4 config")
# Send master arbitration via stream channel
# This should go in library, to be re-used also by base_test.py.
stream_out_q = Queue.Queue()
stream_in_q = Queue.Queue()
def stream_req_iterator():
while True:
p = stream_out_q.get()
if p is None:
break
yield p
def stream_recv(stream):
for p in stream:
stream_in_q.put(p)
def get_stream_packet(type_, timeout=1):
start = time.time()
try:
while True:
remaining = timeout - (time.time() - start)
if remaining < 0:
break
msg = stream_in_q.get(timeout=remaining)
if not msg.HasField(type_):
continue
return msg
except: # timeout expired
pass
return None
stream = stub.StreamChannel(stream_req_iterator())
stream_recv_thread = threading.Thread(target=stream_recv, args=(stream, ))
stream_recv_thread.start()
req = p4runtime_pb2.StreamMessageRequest()
arbitration = req.arbitration
arbitration.device_id = device_id
election_id = arbitration.election_id
election_id.high = 0
election_id.low = 1
stream_out_q.put(req)
rep = get_stream_packet("arbitration", timeout=5)
if rep is None:
error("Failed to establish handshake")
return False
try:
# Set pipeline config.
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = device_id
election_id = request.election_id
election_id.high = 0
election_id.low = 1
config = request.config
with open(p4info_path, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
config.p4_device_config = build_bmv2_config(bmv2_json_path)
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
stub.SetForwardingPipelineConfig(request)
except Exception as e:
error("Error during SetForwardingPipelineConfig")
error(str(e))
return False
return True
finally:
stream_out_q.put(None)
stream_recv_thread.join()
def update_config(p4info_path,
bmv2_json_path,
tofino_bin_path,
tofino_cxt_json_path,
grpc_addr,
device_id,
generate_tv=False):
"""
Performs a SetForwardingPipelineConfig on the device
"""
# Build pipeline config request
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = device_id
election_id = request.election_id
election_id.high = 0
election_id.low = 1
config = request.config
with open(p4info_path, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
if bmv2_json_path is not None:
device_config = build_bmv2_config(bmv2_json_path)
else:
device_config = build_tofino_config("name", tofino_bin_path,
tofino_cxt_json_path)
config.p4_device_config = device_config
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
if generate_tv:
# Create new target proto object for testvectors
if bmv2_json_path is not None:
tv_target = targetutils.get_new_target(grpc_addr, target_id="bmv2")
else:
tv_target = targetutils.get_new_target(grpc_addr,
target_id="tofino")
# Write the target proto object to testvectors/target.pb.txt
targetutils.write_to_file(tv_target, os.getcwd())
# Create new testvector for set pipeline config and write to testvectors/PipelineConfig.pb.txt
tv = tvutils.get_new_testvector()
tv_name = "PipelineConfig"
tc = tvutils.get_new_testcase(tv, tv_name)
tvutils.add_pipeline_config_operation(tc, request)
tvutils.write_to_file(tv, os.getcwd(), tv_name)
return True
channel = grpc.insecure_channel(grpc_addr)
stub = p4runtime_pb2_grpc.P4RuntimeStub(channel)
info("Sending P4 config")
# Send master arbitration via stream channel
# This should go in library, to be re-used also by base_test.py.
stream_out_q = Queue.Queue()
stream_in_q = Queue.Queue()
def stream_req_iterator():
while True:
p = stream_out_q.get()
if p is None:
break
yield p
def stream_recv(stream):
for p in stream:
stream_in_q.put(p)
def get_stream_packet(type_, timeout=1):
start = time.time()
try:
while True:
remaining = timeout - (time.time() - start)
if remaining < 0:
break
msg = stream_in_q.get(timeout=remaining)
if not msg.HasField(type_):
continue
return msg
except: # timeout expired
pass
return None
stream = stub.StreamChannel(stream_req_iterator())
stream_recv_thread = threading.Thread(target=stream_recv, args=(stream, ))
stream_recv_thread.start()
req = p4runtime_pb2.StreamMessageRequest()
arbitration = req.arbitration
arbitration.device_id = device_id
election_id = arbitration.election_id
election_id.high = 0
election_id.low = 1
stream_out_q.put(req)
rep = get_stream_packet("arbitration", timeout=5)
if rep is None:
error("Failed to establish handshake")
return False
try:
try:
stub.SetForwardingPipelineConfig(request)
except Exception as e:
error("Error during SetForwardingPipelineConfig")
error(str(e))
return False
return True
finally:
stream_out_q.put(None)
stream_recv_thread.join()
def update_config(p4info_path, bmv2_json_path, tofino_bin_path,
tofino_cxt_json_path, grpc_addr, device_id):
"""
Performs a SetForwardingPipelineConfig on the device
"""
channel = grpc.insecure_channel(grpc_addr)
stub = p4runtime_pb2.P4RuntimeStub(channel)
info("Sending P4 config")
# Send master arbitration via stream channel
# This should go in library, to be re-used also by base_test.py.
stream_out_q = Queue.Queue()
def stream_req_iterator():
while True:
p = stream_out_q.get()
if p is None:
break
yield p
def stream_recv(s):
pass
stream = stub.StreamChannel(stream_req_iterator())
stream_recv_thread = threading.Thread(target=stream_recv, args=(stream,))
stream_recv_thread.start()
req = p4runtime_pb2.StreamMessageRequest()
arbitration = req.arbitration
arbitration.device_id = device_id
election_id = arbitration.election_id
election_id.high = 0
election_id.low = 1
stream_out_q.put(req)
try:
# Set pipeline config.
request = p4runtime_pb2.SetForwardingPipelineConfigRequest()
request.device_id = device_id
election_id = request.election_id
election_id.high = 0
election_id.low = 1
config = request.config
with open(p4info_path, 'r') as p4info_f:
google.protobuf.text_format.Merge(p4info_f.read(), config.p4info)
if bmv2_json_path is not None:
device_config = build_bmv2_config(bmv2_json_path)
else:
device_config = build_tofino_config("name", tofino_bin_path,
tofino_cxt_json_path)
config.p4_device_config = device_config.SerializeToString()
request.action = p4runtime_pb2.SetForwardingPipelineConfigRequest.VERIFY_AND_COMMIT
try:
stub.SetForwardingPipelineConfig(request)
except Exception as e:
error("Error during SetForwardingPipelineConfig")
error(str(e))
return False
return True
finally:
stream_out_q.put(None)
stream_recv_thread.join()
