/***************************
* get all streams
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdGetAllStreams::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
bool get_pkt = parse_bool(params, "get_pkt", result);
std::vector <TrexStream *> streams;
port->get_object_list(streams);
Json::Value streams_json = Json::objectValue;
for (auto stream : streams) {
Json::Value j = stream->get_stream_json();
/* should we include the packet as well ? */
if (!get_pkt) {
j.removeMember("packet");
}
std::stringstream ss;
ss << stream->m_stream_id;
streams_json[ss.str()] = j;
}
result["result"]["streams"] = streams_json;
return (TREX_RPC_CMD_OK);
}
/************************* messages from DP to CP **********************/
bool
TrexDpPortEventMsg::handle() {
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(m_port_id);
port->get_dp_events().on_core_reporting_in(m_event_id, m_thread_id, get_status());
return (true);
}
/***************************
* get stream by id
* on a specific port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdGetStream::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
bool get_pkt = parse_bool(params, "get_pkt", result);
uint32_t stream_id = parse_int(params, "stream_id", result);
TrexStream *stream = port->get_stream_by_id(stream_id);
if (!stream) {
std::stringstream ss;
ss << "stream id " << stream_id << " on port " << (int)port_id << " does not exists";
generate_execute_err(result, ss.str());
}
/* return the stored stream json (instead of decoding it all over again) */
Json::Value j = stream->get_stream_json();
if (!get_pkt) {
j.removeMember("packet");
}
result["result"]["stream"] = j;
return (TREX_RPC_CMD_OK);
}
/**
* push a remote PCAP on a port
*
*/
trex_rpc_cmd_rc_e
TrexRpcCmdPushRemote::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
std::string pcap_filename = parse_string(params, "pcap_filename", result);
double ipg_usec = parse_double(params, "ipg_usec", result);
double speedup = parse_double(params, "speedup", result);
uint32_t count = parse_uint32(params, "count", result);
double duration = parse_double(params, "duration", result);
bool is_dual = parse_bool(params, "is_dual", result, false);
std::string slave_handler = parse_string(params, "slave_handler", result, "");
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
/* for dual mode - make sure slave_handler matches */
if (is_dual) {
TrexStatelessPort *slave = get_stateless_obj()->get_port_by_id(port_id ^ 0x1);
if (!slave->get_owner().verify(slave_handler)) {
generate_execute_err(result, "incorrect or missing slave port handler");
}
}
try {
port->push_remote(pcap_filename, ipg_usec, speedup, count, duration, is_dual);
} catch (const TrexException &ex) {
generate_execute_err(result, ex.what());
}
result["result"] = Json::objectValue;
return (TREX_RPC_CMD_OK);
}
/***************************
* start traffic on port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdStartTraffic::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
double duration = parse_double(params, "duration", result);
/* multiplier */
const Json::Value &mul_obj = parse_object(params, "mul", result);
std::string type = parse_choice(mul_obj, "type", TrexPortMultiplier::g_types, result);
std::string op = parse_string(mul_obj, "op", result);
double value = parse_double(mul_obj, "value", result);
if (op != "abs") {
generate_parse_err(result, "start message can only specify absolute speed rate");
}
TrexPortMultiplier mul(type, op, value);
try {
port->start_traffic(mul, duration);
} catch (const TrexRpcException &ex) {
generate_execute_err(result, ex.what());
}
result["result"]["multiplier"] = port->get_multiplier();
return (TREX_RPC_CMD_OK);
}
/***************************
* remove stream
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdRemoveStream::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
uint32_t stream_id = parse_int(params, "stream_id", result);
TrexStream *stream = port->get_stream_by_id(stream_id);
if (!stream) {
std::stringstream ss;
ss << "stream " << stream_id << " does not exists";
generate_execute_err(result, ss.str());
}
try {
port->remove_stream(stream);
} catch (const TrexRpcException &ex) {
generate_execute_err(result, ex.what());
}
delete stream;
result["result"] = Json::objectValue;
return (TREX_RPC_CMD_OK);
}
/************************* messages from DP to CP **********************/
bool
TrexDpPortEventMsg::handle() {
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(m_port_id);
port->get_dp_events().handle_event(m_event_type, m_thread_id, m_event_id);
return (true);
}
/***************************
* remove stream
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdRemoveStream::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_byte(params, "port_id", result);
uint32_t stream_id = parse_int(params, "stream_id", result);
if (port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
TrexStream *stream = port->get_stream_table()->get_stream_by_id(stream_id);
if (!stream) {
std::stringstream ss;
ss << "stream " << stream_id << " does not exists";
generate_execute_err(result, ss.str());
}
port->get_stream_table()->remove_stream(stream);
delete stream;
result["result"] = "ACK";
return (TREX_RPC_CMD_OK);
}
/***************************
* get all streams configured
* on a specific port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdGetStreamList::_run(const Json::Value ¶ms, Json::Value &result) {
std::vector<uint32_t> stream_list;
uint8_t port_id = parse_byte(params, "port_id", result);
if (port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
port->get_stream_table()->get_id_list(stream_list);
Json::Value json_list = Json::arrayValue;
for (auto stream_id : stream_list) {
json_list.append(stream_id);
}
result["result"] = json_list;
return (TREX_RPC_CMD_OK);
}
void
TrexRpcCmdAddStream::validate_stream(const TrexStream *stream, Json::Value &result) {
/* check packet size */
if ( (stream->m_pkt.len < TrexStream::MIN_PKT_SIZE_BYTES) || (stream->m_pkt.len > TrexStream::MAX_PKT_SIZE_BYTES) ) {
std::stringstream ss;
ss << "bad packet size provided: should be between " << TrexStream::MIN_PKT_SIZE_BYTES << " and " << TrexStream::MAX_PKT_SIZE_BYTES;
delete stream;
generate_execute_err(result, ss.str());
}
/* port id should be between 0 and count - 1 */
if (stream->m_port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
delete stream;
generate_execute_err(result, ss.str());
}
/* add the stream to the port's stream table */
TrexStatelessPort * port = get_stateless_obj()->get_port_by_id(stream->m_port_id);
/* does such a stream exists ? */
if (port->get_stream_table()->get_stream_by_id(stream->m_stream_id)) {
std::stringstream ss;
ss << "stream " << stream->m_stream_id << " already exists";
delete stream;
generate_execute_err(result, ss.str());
}
}
/***************************
* update traffic
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdUpdateTraffic::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
/* multiplier */
const Json::Value &mul_obj = parse_object(params, "mul", result);
std::string type = parse_choice(mul_obj, "type", TrexPortMultiplier::g_types, result);
std::string op = parse_choice(mul_obj, "op", TrexPortMultiplier::g_ops, result);
double value = parse_double(mul_obj, "value", result);
TrexPortMultiplier mul(type, op, value);
try {
port->update_traffic(mul);
} catch (const TrexRpcException &ex) {
generate_execute_err(result, ex.what());
}
result["result"]["multiplier"] = port->get_multiplier();
return (TREX_RPC_CMD_OK);
}
/**
* get system info
*
*/
trex_rpc_cmd_rc_e
TrexRpcCmdGetSysInfo::_run(const Json::Value ¶ms, Json::Value &result) {
string hostname;
TrexStateless * main = get_stateless_obj();
Json::Value §ion = result["result"];
get_hostname(hostname);
section["hostname"] = hostname;
section["uptime"] = TrexRpcServer::get_server_uptime();
/* FIXME: core count */
section["dp_core_count"] = main->get_dp_core_count();
section["core_type"] = get_cpu_model();
/* ports */
section["port_count"] = main->get_port_count();
section["ports"] = Json::arrayValue;
for (int i = 0; i < main->get_port_count(); i++) {
string driver;
TrexPlatformApi::driver_speed_e speed;
TrexStatelessPort *port = main->get_port_by_id(i);
port->get_properties(driver, speed);
section["ports"][i]["index"] = i;
section["ports"][i]["driver"] = driver;
switch (speed) {
case TrexPlatformApi::SPEED_1G:
section["ports"][i]["speed"] = 1;
break;
case TrexPlatformApi::SPEED_10G:
section["ports"][i]["speed"] = 10;
break;
case TrexPlatformApi::SPEED_40G:
section["ports"][i]["speed"] = 40;
break;
default:
/* unknown value */
section["ports"][i]["speed"] = 0;
break;
}
}
return (TREX_RPC_CMD_OK);
}
/***************************
* add new stream
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdAddStream::_run(const Json::Value ¶ms, Json::Value &result) {
const Json::Value §ion = parse_object(params, "stream", result);
/* get the type of the stream */
const Json::Value &mode = parse_object(section, "mode", result);
string type = parse_string(mode, "type", result);
/* allocate a new stream based on the type */
TrexStream *stream = allocate_new_stream(section, result);
/* some fields */
stream->m_enabled = parse_bool(section, "enabled", result);
stream->m_self_start = parse_bool(section, "self_start", result);
/* inter stream gap */
stream->m_isg_usec = parse_double(section, "Is", result);
stream->m_next_stream_id = parse_int(section, "next_stream_id", result);
const Json::Value &pkt = parse_array(section, "packet", result);
/* fetch the packet from the message */
stream->m_pkt_len = pkt.size();
stream->m_pkt = new uint8_t[pkt.size()];
if (!stream->m_pkt) {
generate_internal_err(result, "unable to allocate memory");
}
/* parse the packet */
for (int i = 0; i < pkt.size(); i++) {
stream->m_pkt[i] = parse_byte(pkt, i, result);
}
/* parse RX info */
const Json::Value &rx = parse_object(section, "rx_stats", result);
stream->m_rx_check.m_enable = parse_bool(rx, "enabled", result);
/* if it is enabled - we need more fields */
if (stream->m_rx_check.m_enable) {
stream->m_rx_check.m_stream_id = parse_int(rx, "stream_id", result);
stream->m_rx_check.m_seq_enabled = parse_bool(rx, "seq_enabled", result);
stream->m_rx_check.m_latency = parse_bool(rx, "latency", result);
}
/* make sure this is a valid stream to add */
validate_stream(stream, result);
TrexStatelessPort *port = get_trex_stateless()->get_port_by_id(stream->m_port_id);
port->get_stream_table()->add_stream(stream);
result["result"] = "ACK";
return (TREX_RPC_CMD_OK);
}
/**
* returns the current owner of the device
*
* @author imarom (08-Sep-15)
*
* @param params
* @param result
*
* @return trex_rpc_cmd_rc_e
*/
trex_rpc_cmd_rc_e
TrexRpcCmdGetOwner::_run(const Json::Value ¶ms, Json::Value &result) {
Json::Value §ion = result["result"];
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
section["owner"] = port->get_owner().get_name();
return (TREX_RPC_CMD_OK);
}
/**
* fetch the port status
*
* @author imarom (09-Dec-15)
*
* @param params
* @param result
*
* @return trex_rpc_cmd_rc_e
*/
trex_rpc_cmd_rc_e
TrexRpcCmdGetPortStatus::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
result["result"]["owner"] = (port->get_owner().is_free() ? "" : port->get_owner().get_name());
result["result"]["state"] = port->get_state_as_string();
result["result"]["max_stream_id"] = port->get_max_stream_id();
return (TREX_RPC_CMD_OK);
}
/***************************
* remove all streams
* for a port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdRemoveAllStreams::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_byte(params, "port_id", result);
if (port_id >= get_trex_stateless()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_trex_stateless()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_trex_stateless()->get_port_by_id(port_id);
port->get_stream_table()->remove_and_delete_all_streams();
result["result"] = "ACK";
}
void
TrexRpcCommand::verify_ownership(const Json::Value ¶ms, Json::Value &result) {
std::string handler = parse_string(params, "handler", result);
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
if (port->get_owner().is_free()) {
generate_execute_err(result, "please acquire the port before modifying port state");
}
if (!port->get_owner().verify(handler)) {
generate_execute_err(result, "port is not owned by you or your current executing session");
}
}
/**
* get port stats
*
*/
trex_rpc_cmd_rc_e
TrexRpcCmdGetPortStats::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
try {
port->encode_stats(result["result"]);
} catch (const TrexException &ex) {
generate_execute_err(result, ex.what());
}
return (TREX_RPC_CMD_OK);
}
/***************************
* resume traffic
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdResumeTraffic::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
try {
port->resume_traffic();
} catch (const TrexRpcException &ex) {
generate_execute_err(result, ex.what());
}
result["result"] = Json::objectValue;
return (TREX_RPC_CMD_OK);
}
/**
* configures a port in L3 mode
*
*/
trex_rpc_cmd_rc_e
TrexRpcCmdSetL3::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
const std::string src_ipv4_str = parse_string(params, "src_addr", result);
const std::string dst_ipv4_str = parse_string(params, "dst_addr", result);
uint32_t src_ipv4;
if (!utl_ipv4_to_uint32(src_ipv4_str.c_str(), src_ipv4)) {
std::stringstream ss;
ss << "invalid source IPv4 address: '" << src_ipv4_str << "'";
generate_parse_err(result, ss.str());
}
uint32_t dst_ipv4;
if (!utl_ipv4_to_uint32(dst_ipv4_str.c_str(), dst_ipv4)) {
std::stringstream ss;
ss << "invalid destination IPv4 address: '" << dst_ipv4_str << "'";
generate_parse_err(result, ss.str());
}
/* did we get a resolved MAC as well ? */
if (params["resolved_mac"] != Json::Value::null) {
const std::string resolved_mac = parse_string(params, "resolved_mac", result);
uint8_t mac[6];
if (!utl_str_to_macaddr(resolved_mac, mac)) {
std::stringstream ss;
ss << "'invalid MAC address: '" << resolved_mac << "'";
generate_parse_err(result, ss.str());
}
port->set_l3_mode(src_ipv4, dst_ipv4, mac);
} else {
port->set_l3_mode(src_ipv4, dst_ipv4);
}
return (TREX_RPC_CMD_OK);
}
/***************************
* start traffic on port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdStopTraffic::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_byte(params, "port_id", result);
if (port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
port->stop_traffic();
result["result"] = "ACK";
return (TREX_RPC_CMD_OK);
}
/***************************
* start traffic on port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdStartTraffic::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_byte(params, "port_id", result);
double duration = parse_double(params, "duration", result);
if (port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
const Json::Value &mul = parse_object(params, "mul", result);
std::string mul_type = parse_string(mul, "type", result);
/* dispatch according to type of multiplier */
try {
if (mul_type == "raw") {
double m = parse_double(mul, "factor", result);
port->start_traffic(m, duration);
} else if (mul_type == "max_bps") {
double max_bps = parse_double(mul, "max", result);
port->start_traffic_max_bps(max_bps, duration);
} else if (mul_type == "max_pps") {
double max_pps = parse_double(mul, "max", result);
port->start_traffic_max_pps(max_pps, duration);
}
} catch (const TrexRpcException &ex) {
generate_execute_err(result, ex.what());
}
result["result"] = "ACK";
return (TREX_RPC_CMD_OK);
}
/***************************
* validate
*
* checks that the port
* attached streams are
* valid as a program
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdValidate::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
const TrexStreamsGraphObj *graph = NULL;
try {
graph = port->validate();
}
catch (const TrexException &ex) {
generate_execute_err(result, ex.what());
}
result["result"]["rate"]["max_bps"] = graph->get_max_bps();
result["result"]["rate"]["max_pps"] = graph->get_max_pps();
result["result"]["rate"]["max_line_util"] = graph->get_max_bps() / port->get_port_speed_bps();
result["result"]["graph"]["expected_duration"] = graph->get_duration();
result["result"]["graph"]["events_count"] = (int)graph->get_events().size();
result["result"]["graph"]["events"] = Json::arrayValue;
Json::Value &events_json = result["result"]["graph"]["events"];
int index = 0;
for (const auto &ev : graph->get_events()) {
Json::Value ev_json;
ev_json["time_usec"] = ev.time;
ev_json["diff_bps"] = ev.diff_bps;
ev_json["diff_pps"] = ev.diff_pps;
ev_json["stream_id"] = ev.stream_id;
events_json.append(ev_json);
index++;
if (index >= 100) {
break;
}
}
return (TREX_RPC_CMD_OK);
}
/***************************
* get all streams configured
* on a specific port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdGetStreamList::_run(const Json::Value ¶ms, Json::Value &result) {
std::vector<uint32_t> stream_list;
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
port->get_id_list(stream_list);
Json::Value json_list = Json::arrayValue;
for (auto stream_id : stream_list) {
json_list.append(stream_id);
}
result["result"] = json_list;
return (TREX_RPC_CMD_OK);
}
/**
* configures a port in L2 mode
*
*/
trex_rpc_cmd_rc_e
TrexRpcCmdSetL2::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
const std::string dst_mac_str = parse_string(params, "dst_mac", result);
uint8_t dst_mac[6];
if (!utl_str_to_macaddr(dst_mac_str, dst_mac)) {
std::stringstream ss;
ss << "'invalid MAC address: '" << dst_mac_str << "'";
generate_parse_err(result, ss.str());
}
port->set_l2_mode(dst_mac);
return (TREX_RPC_CMD_OK);
}
/**
* set port commands
*
* @author imarom (24-Feb-16)
*
* @param params
* @param result
*
* @return trex_rpc_cmd_rc_e
*/
trex_rpc_cmd_rc_e
TrexRpcCmdSetPortAttr::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
const Json::Value &attr = parse_object(params, "attr", result);
/* iterate over all attributes in the dict */
for (const std::string &name : attr.getMemberNames()) {
/* handle promiscuous */
if (name == "promiscuous") {
bool enabled = parse_bool(attr[name], "enabled", result);
port->set_promiscuous(enabled);
}
}
result["result"] = Json::objectValue;
return (TREX_RPC_CMD_OK);
}
/**
* acquire device
*
*/
trex_rpc_cmd_rc_e
TrexRpcCmdAcquire::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
const string &new_owner = parse_string(params, "user", result);
bool force = parse_bool(params, "force", result);
uint32_t session_id = parse_uint32(params, "session_id", result);
/* if not free and not you and not force - fail */
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
try {
port->acquire(new_owner, session_id, force);
} catch (const TrexException &ex) {
generate_execute_err(result, ex.what());
}
result["result"] = port->get_owner().get_handler();
return (TREX_RPC_CMD_OK);
}
/***************************
* remove all streams
* for a port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdRemoveAllStreams::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_byte(params, "port_id", result);
if (port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
try {
port->remove_and_delete_all_streams();
} catch (const TrexRpcException &ex) {
generate_execute_err(result, ex.what());
}
result["result"] = "ACK";
return (TREX_RPC_CMD_OK);
}
/***************************
* start traffic on port
*
**************************/
trex_rpc_cmd_rc_e
TrexRpcCmdStartTraffic::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_byte(params, "port_id", result);
double mul = parse_double(params, "mul", result);
if (port_id >= get_stateless_obj()->get_port_count()) {
std::stringstream ss;
ss << "invalid port id - should be between 0 and " << (int)get_stateless_obj()->get_port_count() - 1;
generate_execute_err(result, ss.str());
}
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
TrexStatelessPort::rc_e rc = port->start_traffic(mul);
if (rc == TrexStatelessPort::RC_OK) {
result["result"] = "ACK";
} else {
std::stringstream ss;
switch (rc) {
case TrexStatelessPort::RC_ERR_BAD_STATE_FOR_OP:
ss << "bad state for operations: port is either transmitting traffic or down";
break;
case TrexStatelessPort::RC_ERR_NO_STREAMS:
ss << "no active streams on that port";
break;
default:
ss << "failed to start traffic";
break;
}
generate_execute_err(result, ss.str());
}
return (TREX_RPC_CMD_OK);
}
trex_rpc_cmd_rc_e
TrexRpcCmdGetRxQueuePkts::_run(const Json::Value ¶ms, Json::Value &result) {
uint8_t port_id = parse_port(params, result);
TrexStatelessPort *port = get_stateless_obj()->get_port_by_id(port_id);
try {
const RXPacketBuffer *pkt_buffer = port->get_rx_queue_pkts();
if (pkt_buffer) {
result["result"]["pkts"] = pkt_buffer->to_json();
delete pkt_buffer;
} else {
result["result"]["pkts"] = Json::arrayValue;
}
} catch (const TrexException &ex) {
generate_execute_err(result, ex.what());
}
return (TREX_RPC_CMD_OK);
}
