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

pplx::task<http_response> client::http_client::request(http_request request, pplx::cancellation_token token)
{
    if(!request.headers().has(header_names::user_agent))
    {
        request.headers().add(header_names::user_agent, USERAGENT);
    }

    request._set_base_uri(base_uri());
    request._set_cancellation_token(token);
    return m_pipeline->propagate(request);
}

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;
	}
}

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;
	}
}

boost::tribool request_parser::parse_line(http_request &request, const std::string &line)
{
	if (line.empty() || line[line.size() - 1] != '\r')
		return false;

	const bool is_empty_line = line.compare(0, line.size(), "\r", 1) == 0;

	switch (m_state_new) {
		case request_line: {
			if (is_empty_line) {
				// Ignore CRLF characters between requests in Keep-Alive connection
				return boost::indeterminate;
			}

			const auto first_space = line.find(' ');
			if (first_space == std::string::npos)
				return false;

			request.set_method(line.substr(0, first_space));

			const auto second_space = line.find(' ', first_space + 1);
			if (second_space == std::string::npos)
				return false;

			request.set_url(line.substr(first_space + 1, second_space - first_space - 1));

			if (line.compare(second_space + 1, 5, "HTTP/", 5) != 0)
				return false;

			const auto version_major_start = second_space + 1 + 5;
			const auto dot = line.find('.', version_major_start);
			if (dot == std::string::npos)
				return false;

			const auto version_minor_end = line.find('\r', dot);

			if (version_minor_end == std::string::npos)
				return false;

			boost::tribool result = boost::indeterminate;
			const auto major_version = parse_int(line.data() + version_major_start, line.data() + dot, result);
			const auto minor_version = parse_int(line.data() + dot + 1, line.data() + version_minor_end, result);
			request.set_http_version(major_version, minor_version);

			m_state_new = header_line;
			return result;
		}
		case header_line: {
			if (!m_header.first.empty() && (line[0] == ' ' || line[0] == '\t')) {
				// any number of LWS is allowed after field, rfc 2068
				auto begin = line.begin() + 1;
				auto end = line.end();
				trim_line(begin, end);

				m_header.second += ' ';
				m_header.second.append(begin, end);

				return boost::indeterminate;
			}

			if (!m_header.first.empty()) {
				request.headers().add(m_header);
				m_header.first.resize(0);
				m_header.second.resize(0);
			}

			if (is_empty_line) {
				return true;
			}

			const auto colon = line.find(':');
			if (colon == std::string::npos)
				return false;

			auto name_begin = line.begin();
			auto name_end = line.begin() + colon;
			trim_line(name_begin, name_end);
			m_header.first.assign(name_begin, name_end);

			auto value_begin = line.begin() + colon + 1;
			auto value_end = line.end();
			trim_line(value_begin, value_end);
			m_header.second.assign(value_begin, value_end);

			return boost::indeterminate;
		}
	}

	return false;
}

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;
	}
}

    // Handler to process HTTP::GET requests.
    // Replies to the request with data.
    void odata_test_service::handle_get(http_request message)
    {
        try
        {
            bool is_async = false;
            auto prefer_header = message.headers().find(U("Prefer"));
            if (prefer_header != message.headers().end())
            {
                if (prefer_header->second.find(U("respond-async")) != ::odata::utility::string_t::npos)
                {
                    is_async = true;
                }
            }


            auto parsed_uri = m_uri_parser->parse_uri(message.relative_uri());

            odata_message_writer writer(m_model, m_service_root);
            odata_context_url_builder context_url_builder(m_model, m_service_root);
            odata_metadata_builder metadata_builder(m_model, m_service_root);
            ::odata::utility::string_t content;
            if (parsed_uri->is_service_document())
            {
                // Write service document
                content = writer.write_service_document(m_service_document);
            }
            else if (parsed_uri->is_metadata_document())
            {
                // Write metadata document
                content = writer.write_metadata_document();
            }
            else
            {
                if (parsed_uri->path()->size() >= 1)
                {
                    if (parsed_uri->path()->segment_at(0)->segment_type() == odata_path_segment_type::EntitySet)
                    {
                        auto entity_set_segment = parsed_uri->path()->segment_at(0)->as<odata_entity_set_segment>();
                        if (entity_set_segment->entity_set()->get_name() == U("People"))
                        {
                            if (parsed_uri->path()->size() == 1)
                            {
                                auto people = get_people();
                                auto context_url = context_url_builder.get_context_uri_for_collection_of_entities(entity_set_segment->entity_set());
                                people->set_context_url(context_url);
                   
                                if (is_async)
                                {
                                    std::unordered_map<string_t, string_t> headers;
                                    headers[U("OData-Version")] = U("4.0");
                                    headers[U("Content-Type")] = U("application/json;odata.metadata=full");

                                    content = writer.write_asynchronous_odata_value(people, 200, U("OK"), headers);
                                }
                                else
                                {
                                    content = writer.write_odata_value(people);
                                }
                            }
                            else if (parsed_uri->path()->segment_at(1)->segment_type() == odata_path_segment_type::Key)
                            {
                                auto key_segment = parsed_uri->path()->segment_at(1)->as<odata_key_segment>();
                                auto key = key_segment->keys()[0].second->as<::odata::utility::string_t>();

                                auto single_person = get_single_people(key);
                                single_person->set_is_top_level(true);
                                auto context_url = context_url_builder.get_context_uri_for_entity(entity_set_segment->entity_set());
                                single_person->set_context_url(context_url);
                                
                                auto id = metadata_builder.get_entity_id(single_person, entity_set_segment->entity_set());
                                single_person->set_id(id);

                                auto read_link = metadata_builder.get_read_link(single_person, entity_set_segment->entity_set());
                                single_person->set_read_link(read_link);

                                auto edit_link = metadata_builder.get_edit_link(single_person, entity_set_segment->entity_set());
                                single_person->set_edit_link(edit_link);



                                content = writer.write_odata_value(single_person);
                            }
                        }
                    }
                }
            }

            message.reply(status_codes::OK, content).then(std::bind(&handle_error, std::placeholders::_1));
        }
        catch (::odata::core::odata_exception &e)
        {
            message.reply(status_codes::BadRequest, U("Exception: ") + e.what()).then(std::bind(&handle_error, std::placeholders::_1));
        }
        ////Get odata objects from resorce and odata_path
        //

    }

void
RestEngineUri::handle_post(http_request request)
{
    std::cout << request.method() << " : " << request.absolute_uri().path() << std::endl;
    std::cout << request.method() << " : " << request.headers()["Cookie"] << std::endl;
    int rc = 0;
    std::string resultstr;
    std::pair<bool, std::string> result {true, std::string()};

    std::string cookie = request.headers()["Cookie"];

    if (cookie != "session_cookie=" +  _active_session_token)
    {
        //http_response response(status_codes::Locked);
        //make_response(response, resultstr, result);
        //request.reply(response);
        //return;
    }

    if (!is_session_owner(request))
    {
        send_busy_response(request);
        return;
    }

    ostringstream o;
    o << "COOKIE:" << cookie << std::endl;
    o << "ACTIVE COOKIE:" << _active_session_token << std::endl;
    std::cout << o.str();
    log (m_s.masterlogfile,o.str());

    char json[1024];

    // extract json from request
    snprintf(json, sizeof(json), "%s", request.extract_string(true).get().c_str());
    std::cout << "JSON:\n" << json << std::endl;

    rapidjson::Document document;
    if (document.Parse(json).HasParseError())
    {
        rc = 1;
        resultstr += "document invalid";
    }

    rapidjson::SchemaValidator validator(*_schema);
    if (!document.Accept(validator)) {
        rc = 1;
        resultstr += get_schema_validation_error(&validator);
    }

    std::string select_str;
    std::string hosts_list;

    const Value& hosts = document["hosts"];
    json_to_host_list(hosts, hosts_list);

    const Value& select = document["select"];
    json_to_select_str(select, select_str);

    // Execute Ivy Engine command
    if (rc == 0)
    {
        std::unique_lock<std::mutex> u_lk(goStatementMutex);

        std::string outputfolder = m_s.get("output_folder_root").second;
        std::string testname = m_s.get("test_name").second;

        result = m_s.startup(outputfolder, testname, m_s.ivyscript_filename, hosts_list, select_str);
    }

    http_response response(status_codes::OK);
    make_response(response, resultstr, result);
    request.reply(response);
}