char * match_routes(req_header * header){
int i;
for(i = 0; i < NUM_ROUTES; i++){
if(!strcmp(routes[i].route, extract_path(header->path))){
printf("Routing to %s\n", extract_path(header->path));
char * content = handle_route(header, i);
content = wrap_header(header, content);
printf("%s\n", content);
return content;
}
}
//printf("did not find any matching routes...\n");
return return404();
}
char * match_routes(req_header * header){
int i;
int return_code = 200;
for(i = 0; i < NUM_ROUTES; i++){
if(!strcmp(routes[i].route, extract_path(header->path))){
char * content = handle_route(header, i, &return_code);
//if( == NULL){
// return return404();
//}
content = wrap_header(header, content);
printf("%s", content);
return content;
}
}
return return404();
}
int replay(int argc, char **argv)
{
//swss::Logger::getInstance().setMinPrio(swss::Logger::SWSS_DEBUG);
SWSS_LOG_ENTER();
if (argc < 2)
{
fprintf(stderr, "ERR: need to specify filename\n");
return -1;
}
char* filename = argv[argc - 1];
SWSS_LOG_NOTICE("using file: %s", filename);
std::ifstream infile(filename);
if (!infile.is_open())
{
SWSS_LOG_ERROR("failed to open file %s", filename);
return -1;
}
std::string line;
while (std::getline(infile, line))
{
// std::cout << "processing " << line << std::endl;
sai_common_api_t api = SAI_COMMON_API_CREATE;
auto p = line.find_first_of("|");
char op = line[p+1];
switch (op)
{
case 'a':
{
std::string response;
do
{
// this line may be notification, we need to skip
if (!std::getline(infile, response))
{
SWSS_LOG_THROW("failed to read next file from file, previous: %s", line.c_str());
}
}
while (response[response.find_first_of("|") + 1] == 'n');
performNotifySyncd(line, response);
}
continue;
case '@':
performSleep(line);
continue;
case 'c':
api = SAI_COMMON_API_CREATE;
break;
case 'r':
api = SAI_COMMON_API_REMOVE;
break;
case 's':
api = SAI_COMMON_API_SET;
break;
case 'S':
processBulk((sai_common_api_t)SAI_COMMON_API_BULK_SET, line);
continue;
case 'g':
api = SAI_COMMON_API_GET;
break;
case '#':
case 'n':
continue; // skip comment and notification
default:
SWSS_LOG_THROW("unknown op %c on line %s", op, line.c_str());
}
// timestamp|action|objecttype:objectid|attrid=value,...
auto fields = swss::tokenize(line, '|');
// objecttype:objectid (object id may contain ':')
auto start = fields[2].find_first_of(":");
auto str_object_type = fields[2].substr(0, start);
auto str_object_id = fields[2].substr(start + 1);
sai_object_type_t object_type = deserialize_object_type(str_object_type);
auto values = get_values(fields);
SaiAttributeList list(object_type, values, false);
sai_attribute_t *attr_list = list.get_attr_list();
uint32_t attr_count = list.get_attr_count();
SWSS_LOG_DEBUG("attr count: %u", list.get_attr_count());
if (api != SAI_COMMON_API_GET)
{
translate_local_to_redis(object_type, attr_count, attr_list);
}
sai_status_t status;
auto info = sai_metadata_get_object_type_info(object_type);
switch (object_type)
{
case SAI_OBJECT_TYPE_FDB_ENTRY:
status = handle_fdb(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_NEIGHBOR_ENTRY:
status = handle_neighbor(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_ROUTE_ENTRY:
status = handle_route(str_object_id, api, attr_count, attr_list);
break;
default:
if (info->isnonobjectid)
{
SWSS_LOG_THROW("object %s:%s is non object id, but not handled, FIXME",
sai_serialize_object_type(object_type).c_str(),
str_object_id.c_str());
}
status = handle_generic(object_type, str_object_id, api, attr_count, attr_list);
break;
}
if (status != SAI_STATUS_SUCCESS)
{
SWSS_LOG_THROW("failed to execute api: %c: %s", op, sai_serialize_status(status).c_str());
}
if (api == SAI_COMMON_API_GET)
{
std::string response;
do
{
// this line may be notification, we need to skip
std::getline(infile, response);
}
while (response[response.find_first_of("|") + 1] == 'n');
try
{
handle_get_response(object_type, attr_count, attr_list, response);
}
catch (const std::exception &e)
{
SWSS_LOG_NOTICE("line: %s", line.c_str());
SWSS_LOG_NOTICE("resp: %s", response.c_str());
exit(EXIT_FAILURE);
}
}
}
infile.close();
SWSS_LOG_NOTICE("finished replaying %s with SUCCESS", filename);
return 0;
}
sai_status_t processEvent(swss::ConsumerTable &consumer)
{
std::lock_guard<std::mutex> lock(g_mutex);
SWSS_LOG_ENTER();
swss::KeyOpFieldsValuesTuple kco;
consumer.pop(kco);
const std::string &key = kfvKey(kco);
const std::string &op = kfvOp(kco);
std::string str_object_type = key.substr(0, key.find(":"));
std::string str_object_id = key.substr(key.find(":")+1);
SWSS_LOG_INFO("key: %s op: %s", key.c_str(), op.c_str());
sai_common_api_t api = SAI_COMMON_API_MAX;
if (op == "create")
api = SAI_COMMON_API_CREATE;
else if (op == "remove")
api = SAI_COMMON_API_REMOVE;
else if (op == "set")
api = SAI_COMMON_API_SET;
else if (op == "get")
api = SAI_COMMON_API_GET;
else
{
if (op != "delget")
SWSS_LOG_ERROR("api %s is not implemented", op.c_str());
return SAI_STATUS_NOT_SUPPORTED;
}
std::stringstream ss;
int index = 0;
sai_object_type_t object_type;
sai_deserialize_primitive(str_object_type, index, object_type);
if (object_type >= SAI_OBJECT_TYPE_MAX)
{
SWSS_LOG_ERROR("undefined object type %d", object_type);
return SAI_STATUS_NOT_SUPPORTED;
}
const std::vector<swss::FieldValueTuple> &values = kfvFieldsValues(kco);
SaiAttributeList list(object_type, values, false);
if (api != SAI_COMMON_API_GET)
translate_vid_to_rid_list(object_type, list.get_attr_count(), list.get_attr_list());
sai_attribute_t *attr_list = list.get_attr_list();
uint32_t attr_count = list.get_attr_count();
sai_status_t status;
switch (object_type)
{
case SAI_OBJECT_TYPE_FDB:
status = handle_fdb(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_SWITCH:
status = handle_switch(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_NEIGHBOR:
status = handle_neighbor(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_ROUTE:
status = handle_route(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_VLAN:
status = handle_vlan(str_object_id, api, attr_count, attr_list);
break;
case SAI_OBJECT_TYPE_TRAP:
status = handle_trap(str_object_id, api, attr_count, attr_list);
break;
default:
status = handle_generic(object_type, str_object_id, api, attr_count, attr_list);
break;
}
if (api == SAI_COMMON_API_GET)
{
internal_syncd_get_send(object_type, status, attr_count, attr_list);
}
else if (status != SAI_STATUS_SUCCESS)
{
SWSS_LOG_ERROR("failed to execute api: %s: %d", op.c_str(), status);
exit(EXIT_FAILURE);
}
return status;
}