// This test sends a GET request to the executor HTTP endpoint instead // of a POST. The call should return a MethodNotAllowed response. TEST_F(ExecutorHttpApiTest, GetRequest) { Try<PID<Master>> master = StartMaster(); ASSERT_SOME(master); Future<Nothing> __recover = FUTURE_DISPATCH(_, &Slave::__recover); Try<PID<Slave>> slave = StartSlave(); ASSERT_SOME(slave); AWAIT_READY(__recover); // Wait for recovery to be complete. Clock::pause(); Clock::settle(); Future<Response> response = process::http::get( slave.get(), "api/v1/executor"); AWAIT_READY(response); AWAIT_EXPECT_RESPONSE_STATUS_EQ(MethodNotAllowed().status, response); Shutdown(); }
void HttpHandler::HandleRequest(const HttpRequest* req, HttpResponse* resp) { switch (req->Method()) { case HttpRequest::METHOD_HEAD: HandleHead(req, resp); break; case HttpRequest::METHOD_GET: HandleGet(req, resp); break; case HttpRequest::METHOD_POST: HandlePost(req, resp); break; case HttpRequest::METHOD_PUT: HandlePut(req, resp); break; case HttpRequest::METHOD_DELETE: HandleDelete(req, resp); break; case HttpRequest::METHOD_OPTIONS: HandleOptions(req, resp); break; case HttpRequest::METHOD_TRACE: HandleTrace(req, resp); break; case HttpRequest::METHOD_CONNECT: HandleConnect(req, resp); break; default: MethodNotAllowed(req, resp); break; } }
TEST_F(SchedulerHttpApiTest, GetRequest) { Try<Owned<cluster::Master>> master = StartMaster(); ASSERT_SOME(master); Future<Response> response = process::http::get( master.get()->pid, "api/v1/scheduler", None(), createBasicAuthHeaders(DEFAULT_CREDENTIAL)); AWAIT_READY(response); AWAIT_EXPECT_RESPONSE_STATUS_EQ(MethodNotAllowed({"POST"}).status, response); }
// This test sends a GET request to the executor HTTP endpoint instead // of a POST. The call should return a MethodNotAllowed response. TEST_F(ExecutorHttpApiTest, GetRequest) { Try<Owned<cluster::Master>> master = StartMaster(); ASSERT_SOME(master); Future<Nothing> __recover = FUTURE_DISPATCH(_, &Slave::__recover); Owned<MasterDetector> detector = master.get()->createDetector(); Try<Owned<cluster::Slave>> slave = StartSlave(detector.get()); ASSERT_SOME(slave); AWAIT_READY(__recover); // Wait for recovery to be complete. Clock::pause(); Clock::settle(); Future<Response> response = process::http::get( slave.get()->pid, "api/v1/executor"); AWAIT_READY(response); AWAIT_EXPECT_RESPONSE_STATUS_EQ(MethodNotAllowed({"POST"}).status, response); }
void HttpHandler::HandleConnect(const HttpRequest* req, HttpResponse* resp) { MethodNotAllowed(req, resp); }
Future<http::Response> ResourceProviderManagerProcess::api( const http::Request& request, const Option<Principal>& principal) { if (request.method != "POST") { return MethodNotAllowed({"POST"}, request.method); } v1::resource_provider::Call v1Call; // TODO(anand): Content type values are case-insensitive. Option<string> contentType = request.headers.get("Content-Type"); if (contentType.isNone()) { return BadRequest("Expecting 'Content-Type' to be present"); } if (contentType.get() == APPLICATION_PROTOBUF) { if (!v1Call.ParseFromString(request.body)) { return BadRequest("Failed to parse body into Call protobuf"); } } else if (contentType.get() == APPLICATION_JSON) { Try<JSON::Value> value = JSON::parse(request.body); if (value.isError()) { return BadRequest("Failed to parse body into JSON: " + value.error()); } Try<v1::resource_provider::Call> parse = ::protobuf::parse<v1::resource_provider::Call>(value.get()); if (parse.isError()) { return BadRequest("Failed to convert JSON into Call protobuf: " + parse.error()); } v1Call = parse.get(); } else { return UnsupportedMediaType( string("Expecting 'Content-Type' of ") + APPLICATION_JSON + " or " + APPLICATION_PROTOBUF); } Call call = devolve(v1Call); Option<Error> error = validate(call); if (error.isSome()) { return BadRequest( "Failed to validate resource_provider::Call: " + error->message); } ContentType acceptType; if (request.acceptsMediaType(APPLICATION_JSON)) { acceptType = ContentType::JSON; } else if (request.acceptsMediaType(APPLICATION_PROTOBUF)) { acceptType = ContentType::PROTOBUF; } else { return NotAcceptable( string("Expecting 'Accept' to allow ") + "'" + APPLICATION_PROTOBUF + "' or '" + APPLICATION_JSON + "'"); } switch(call.type()) { case Call::UNKNOWN: { return NotImplemented(); } case Call::SUBSCRIBE: { Pipe pipe; OK ok; ok.headers["Content-Type"] = stringify(acceptType); ok.type = http::Response::PIPE; ok.reader = pipe.reader(); HttpConnection http(pipe.writer(), acceptType); subscribe(http, call.subscribe()); return ok; } case Call::UPDATE: { if (!resourceProviders.contains(call.resource_provider_id())) { return BadRequest("Resource provider cannot be found"); } auto resourceProvider = resourceProviders.at(call.resource_provider_id()); update(&resourceProvider, call.update()); return Accepted(); } } UNREACHABLE(); }