C++ http_request::to_string方法代码示例

//
// A GET of the dealer resource produces a list of existing tables.
// 
void BlackJackDealer::handle_get(http_request message)
{
    ucout <<  message.to_string() << endl;

    auto paths = http::uri::split_path(http::uri::decode(message.relative_uri().path()));
    if (paths.empty())
    {
        message.reply(status_codes::OK, TablesAsJSON(U("Available Tables"), s_tables));
        return;
    }

    utility::string_t wtable_id = paths[0];
    const utility::string_t table_id = wtable_id;

    // Get information on a specific table.
    auto found = s_tables.find(table_id);
    if (found == s_tables.end())
    {
        message.reply(status_codes::NotFound);
    }
    else
    {
        message.reply(status_codes::OK, found->second->AsJSON());
    }
};

void MetaCDNReceiver::handle_delete(http_request message) {
	/*
	Use cases:
	1. when CDN deletes a file from itself to store some other file because of its limited capacity

	JSON Format
	Request
	{
		"FileName": "a.txt",
		"CdnId" : 2
	}

	Response: status OK or Forbidden (no json object included)
	*/
	try {
		int result;
		if(message.headers().content_type()==U("application/json")) {
			cout << endl << "---------------"<< endl;
			cout << message.to_string() << endl <<endl;

			json::value jsonObj = message.extract_json().get();
			int cdnId = jsonObj.at(U("CdnId")).as_integer();
			string fileName = utility::conversions::to_utf8string(jsonObj.at(U("FileName")).as_string());
			result = m_meta->deleteCdnFromMetaEntry(fileName, cdnId);
			message.reply(status_codes::OK, result==0? U("Deleted successfully") : U("Delete failed"));
		} else {
			message.reply(status_codes::Forbidden, U("Json object is required"));
		}
	} catch(json::json_exception &e) {
		message.reply(status_codes::Forbidden, U("Invalid json object"));
		return;
	}
}

//
// A POST of the dealer resource creates a new table and returns a resource for
// that table.
// 
void BlackJackDealer::handle_post(http_request message)
{
    ucout <<  message.to_string() << endl;

    auto paths = uri::split_path(uri::decode(message.relative_uri().path()));
    
    if (paths.empty())
    {
        utility::ostringstream_t nextIdString;
        nextIdString << nextId;

        std::shared_ptr<DealerTable> tbl = std::make_shared<DealerTable>(nextId, 8, 6);
        s_tables[nextIdString.str()] = tbl;
        nextId += 1;

        message.reply(status_codes::OK, BJPutResponse(ST_PlaceBet, tbl->AsJSON()).AsJSON());
        return;
    }
    utility::string_t wtable_id = paths[0];
    const utility::string_t table_id = wtable_id;

    // Join an existing table.
    auto found = s_tables.find(table_id);
    if (found == s_tables.end())
    {
        message.reply(status_codes::NotFound);
        return;
    }

    auto table = std::static_pointer_cast<DealerTable>(found->second);

    if ( table->Players.size() < table->Capacity )
    {
        std::map<utility::string_t, utility::string_t> query = uri::split_query(uri::decode(message.request_uri().query()));

        auto cntEntry = query.find(QUERY_NAME);

        if (cntEntry != query.end() && !cntEntry->second.empty())
        {
            table->AddPlayer(Player(cntEntry->second));
            message.reply(status_codes::OK, BJPutResponse(ST_PlaceBet, table->AsJSON()).AsJSON());
        }
        else
        {
            message.reply(status_codes::Forbidden, U("Player name is required in query"));
        }
    }
    else
    {
        utility::ostringstream_t os;
        os << U("Table ") << table->Id << U(" is full");
        message.reply(status_codes::Forbidden, os.str());
    }
};

//
// A PUT to a table resource makes a card request (hit / stay).
// 
void BlackJackDealer::handle_put(http_request message)
{
    ucout <<  message.to_string() << endl;

    auto paths = uri::split_path(uri::decode(message.relative_uri().path()));
    auto query = uri::split_query(uri::decode(message.relative_uri().query()));
    auto queryItr = query.find(REQUEST);
    if (paths.empty() || queryItr == query.end())
    {
        message.reply(status_codes::Forbidden, U("TableId and request are required."));
    }
    utility::string_t wtable_id = paths[0];
    utility::string_t request = queryItr->second;
    const utility::string_t table_id = wtable_id;

    // Get information on a specific table.
    auto found = s_tables.find(table_id);
    if ( found == s_tables.end() )
    {
        message.reply(status_codes::NotFound);
    }

    auto table = std::static_pointer_cast<DealerTable>(found->second);

    if ( request == BET )
    {
        table->Bet(message);
    }
    else if ( request == DOUBLE )
    {
        table->DoubleDown(message);
    }
    else if ( request == INSURE )
    {
        table->Insure(message);
    }
    else if ( request == HIT )
    {
        table->Hit(message);
    }
    else if ( request == STAY )
    {
        table->Stay(message);
    }
    else if ( request == REFRESH )
    {
        table->Wait(message);
    }
    else 
    {
        message.reply(status_codes::Forbidden, U("Unrecognized request"));
    }
};

void MetaCDNReceiver::handle_register(http_request message) {
	/*
	-when a new CDN joins, it has to register itself to Meta Server

	JSON Format
	Request
	{
		"Type": 0, //0=for cdn, 1=for fss
		"IP": "1.1.1.1:4000", //the sender CDN's IP address + port(listening to incoming requests)
		"Lat": 23.00, //the sender CDN's location
		"Lng": 148.12
	}
	Response
	{
		"CdnId": 1 //the assigned id for the cdn
	}

	*/
	try {

		int assignedId = -1;
		if(message.headers().content_type()==U("application/json")) {
			cout << endl << "---------------"<< endl;
			cout << message.to_string() << endl <<endl;

			json::value jsonObj = message.extract_json().get();
			if(jsonObj.at(U("Type")).as_integer() == 0) {
				string ipAddr = utility::conversions::to_utf8string(jsonObj.at(U("IP")).as_string());
				//TODO: validate ip address
				Address cdnAddr(make_pair(jsonObj.at(U("Lat")).as_double(), jsonObj.at(U("Lng")).as_double()), ipAddr);
				assignedId = m_meta->registerCdn(cdnAddr);
				json::value respFinal = json::value::object();
				respFinal[U("CdnId")] = json::value::number(assignedId);
				message.reply(assignedId!=-1? status_codes::OK : status_codes::NotFound, respFinal);
			} else if(jsonObj.at(U("Type")).as_integer() == 1){
				string ipAddr = utility::conversions::to_utf8string(jsonObj.at(U("IP")).as_string());
				//TODO: validate ip address
				Address fssAddr(make_pair(jsonObj.at(U("Lat")).as_double(), jsonObj.at(U("Lng")).as_double()), ipAddr);
				m_meta->setFssAddr(fssAddr);
				message.reply(status_codes::OK, "FSS registration complete");
			} else {
				message.reply(status_codes::Forbidden, U("Invalid type"));
			}
		} else {
			message.reply(status_codes::Forbidden, U("Json object is required"));
		}
	} catch(json::json_exception &e) {
		message.reply(status_codes::Forbidden, U("Invalid json object"));
		return;
	}
}

//
// A DELETE of the player resource leaves the table.
// 
void BlackJackDealer::handle_delete(http_request message)
{
    ucout <<  message.to_string() << endl;

    auto paths = uri::split_path(uri::decode(message.relative_uri().path()));
    
    if (paths.empty())
    {
        message.reply(status_codes::Forbidden, U("TableId is required."));
        return;
    }
    utility::string_t wtable_id = paths[0];

    const utility::string_t table_id = wtable_id;

    // Get information on a specific table.
    auto found = s_tables.find(table_id);
    if (found == s_tables.end())
    {
        message.reply(status_codes::NotFound);
        return;
    }

    auto table = std::static_pointer_cast<DealerTable>(found->second);

    std::map<utility::string_t, utility::string_t> query = uri::split_query(uri::decode(message.request_uri().query()));

    auto cntEntry = query.find(QUERY_NAME);

    if ( cntEntry != query.end() )
    {
        if ( table->RemovePlayer(cntEntry->second) )
        {
            message.reply(status_codes::OK);
        }
        else
        {
            message.reply(status_codes::NotFound);
        }
    }
    else
    {
        message.reply(status_codes::Forbidden, U("Player name is required in query"));
    }
};

void details::http_listener_impl::handle_trace(http_request message)
{
    utility::string_t data = message.to_string();
    message.reply(status_codes::OK, data, U("message/http"));
}

void MetaCDNReceiver::handle_update(http_request message) {
	/*
	Use cases:
	0. when CDN pulls a file from FSS (syncdown flow)
	1. when CDN updates an existing file (syncup flow; need invalidation process)
	2. when CDN creates a new file and stores in FSS and itself

	JSON Format
	Request
	{
		"Type": 0, // 0=CDN pulls a file from FSS, 1=CDN updates a file (+invalidation process), 2=CDN creates a new file and stores in FSS
		"FileName": "a.txt",
		"FileHash": "ahash", //could be empty string when Type=0 //only for type 1,2
		"CdnId": 1
		"TimeStamp": "12312312312" //REQUIRED for use case 1 and 2
	}

	Response: status OK or Forbidden (no json object included)
	*/

	try {
		if(message.headers().content_type()==U("application/json")) {
			cout << endl << "---------------"<< endl;
			cout << message.to_string() << endl <<endl;

			json::value jsonObj = message.extract_json().get();
			int cdnId = jsonObj.at(U("CdnId")).as_integer();
			string fileName = utility::conversions::to_utf8string(jsonObj.at(U("FileName")).as_string());
			
			int result;
			if(jsonObj.at(U("Type")).as_integer() == 0) {
				result = m_meta->addCdnToMetaEntry(fileName, cdnId);
			} else if(jsonObj.at(U("Type")).as_integer() == 1) {
				string fileHash = utility::conversions::to_utf8string(jsonObj.at(U("FileHash")).as_string());
				vector<int> newCdnList;
				newCdnList.push_back(cdnId);
				result = m_meta->updateMetaEntry(fileName, fileHash, newCdnList);
				if(result == 0) {
					result = m_meta->updateTimeStamp(fileName, jsonObj.at(U("TimeStamp")).as_string());
				} else {
					cout<<"MetaCDNReceiver::handle_update() - failed to update meta entry"<<endl;
					return;
				}

				//now, send invalidation msgs to other cdns
				unordered_map<int, Address>::const_iterator itr = m_meta->getCdnIdToAddrMap().begin();
				while(itr != m_meta->getCdnIdToAddrMap().end()) {
					if(itr->first == cdnId) {
						++itr;
						continue;
					}
					http_client cdn_client = http_client("http://" + itr->second.ipAddr);
					http_response resp = cdn_client.request(methods::DEL, "cdn/cache"+fileName).get();
					if (resp.status_code() != status_codes::OK) {
						cout<<"MetaCDNReceiver::handle_update() - failed to send invalidation message to "+itr->second.ipAddr<<endl;
					}
					++itr;
				}

			} else if(jsonObj.at(U("Type")).as_integer() == 2) {
				string fileHash = utility::conversions::to_utf8string(jsonObj.at(U("FileHash")).as_string());
				vector<int> newCdnList;
				newCdnList.push_back(cdnId);
				result = m_meta->addNewMetaEntry(fileName, fileHash, newCdnList);
				if(result == 0)
					result = m_meta->addNewTimeStamp(fileName, jsonObj.at(U("TimeStamp")).as_string());
			} else {
				message.reply(status_codes::Forbidden, U("Undefined Type"));
				return;
			}
			message.reply(result==0? status_codes::OK : status_codes::NotFound, result==0? U("Updated successfully") : U("Update failed"));

		} else {
			message.reply(status_codes::Forbidden, U("Json object is required"));
		}
	} catch(json::json_exception &e) {
		message.reply(status_codes::Forbidden, U("Invalid json object"));
		return;
	}
}