1
0
Fork 0
arangodb/arangod/RestHandler/RestCursorHandler.cpp

505 lines
16 KiB
C++

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed under the Apache License, Version 2.0 (the "License");
/// you may not use this file except in compliance with the License.
/// You may obtain a copy of the License at
///
/// http://www.apache.org/licenses/LICENSE-2.0
///
/// Unless required by applicable law or agreed to in writing, software
/// distributed under the License is distributed on an "AS IS" BASIS,
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/// See the License for the specific language governing permissions and
/// limitations under the License.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Jan Steemann
////////////////////////////////////////////////////////////////////////////////
#include "RestCursorHandler.h"
#include "Aql/Query.h"
#include "Aql/QueryRegistry.h"
#include "Basics/Exceptions.h"
#include "Basics/json.h"
#include "Basics/MutexLocker.h"
#include "Basics/ScopeGuard.h"
#include "Basics/VelocyPackHelper.h"
#include "Utils/Cursor.h"
#include "Utils/CursorRepository.h"
#include "V8Server/ApplicationV8.h"
#include <velocypack/Iterator.h>
#include <velocypack/Value.h>
#include <velocypack/velocypack-aliases.h>
using namespace triagens::arango;
using namespace triagens::rest;
RestCursorHandler::RestCursorHandler(
HttpRequest* request, std::pair<triagens::arango::ApplicationV8*,
triagens::aql::QueryRegistry*>* pair)
: RestVocbaseBaseHandler(request),
_applicationV8(pair->first),
_queryRegistry(pair->second),
_queryLock(),
_query(nullptr),
_queryKilled(false) {}
////////////////////////////////////////////////////////////////////////////////
/// {@inheritDoc}
////////////////////////////////////////////////////////////////////////////////
HttpHandler::status_t RestCursorHandler::execute() {
// extract the sub-request type
HttpRequest::HttpRequestType type = _request->requestType();
if (type == HttpRequest::HTTP_REQUEST_POST) {
createCursor();
return status_t(HANDLER_DONE);
}
if (type == HttpRequest::HTTP_REQUEST_PUT) {
modifyCursor();
return status_t(HANDLER_DONE);
}
if (type == HttpRequest::HTTP_REQUEST_DELETE) {
deleteCursor();
return status_t(HANDLER_DONE);
}
generateError(HttpResponse::METHOD_NOT_ALLOWED,
TRI_ERROR_HTTP_METHOD_NOT_ALLOWED);
return status_t(HANDLER_DONE);
}
////////////////////////////////////////////////////////////////////////////////
/// {@inheritDoc}
////////////////////////////////////////////////////////////////////////////////
bool RestCursorHandler::cancel() { return cancelQuery(); }
////////////////////////////////////////////////////////////////////////////////
/// @brief processes the query and returns the results/cursor
/// this method is also used by derived classes
////////////////////////////////////////////////////////////////////////////////
void RestCursorHandler::processQuery(VPackSlice const& slice) {
if (!slice.isObject()) {
generateError(HttpResponse::BAD, TRI_ERROR_QUERY_EMPTY);
return;
}
VPackSlice const querySlice = slice.get("query");
if (!querySlice.isString()) {
generateError(HttpResponse::BAD, TRI_ERROR_QUERY_EMPTY);
return;
}
VPackSlice const bindVars = slice.get("bindVars");
if (!bindVars.isNone()) {
if (!bindVars.isObject() && !bindVars.isNull()) {
generateError(HttpResponse::BAD, TRI_ERROR_TYPE_ERROR,
"expecting object for <bindVars>");
return;
}
}
VPackBuilder optionsBuilder = buildOptions(slice);
VPackSlice options = optionsBuilder.slice();
VPackValueLength l;
char const* queryString = querySlice.getString(l);
triagens::aql::Query query(
_applicationV8, false, _vocbase, queryString, static_cast<size_t>(l),
(!bindVars.isNone()
? triagens::basics::VelocyPackHelper::velocyPackToJson(bindVars)
: nullptr),
triagens::basics::VelocyPackHelper::velocyPackToJson(options),
triagens::aql::PART_MAIN);
registerQuery(&query);
auto queryResult = query.execute(_queryRegistry);
unregisterQuery();
if (queryResult.code != TRI_ERROR_NO_ERROR) {
if (queryResult.code == TRI_ERROR_REQUEST_CANCELED ||
(queryResult.code == TRI_ERROR_QUERY_KILLED && wasCanceled())) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_REQUEST_CANCELED);
}
THROW_ARANGO_EXCEPTION_MESSAGE(queryResult.code, queryResult.details);
}
TRI_ASSERT(TRI_IsArrayJson(queryResult.json));
{
createResponse(HttpResponse::CREATED);
_response->setContentType("application/json; charset=utf-8");
triagens::basics::Json extra = buildExtra(queryResult);
size_t batchSize =
triagens::basics::VelocyPackHelper::getNumericValue<size_t>(
options, "batchSize", 1000);
size_t const n = TRI_LengthArrayJson(queryResult.json);
if (n <= batchSize) {
// result is smaller than batchSize and will be returned directly. no need
// to create a cursor
triagens::basics::Json result(triagens::basics::Json::Object, 7);
result.set("result",
triagens::basics::Json(TRI_UNKNOWN_MEM_ZONE, queryResult.json,
triagens::basics::Json::AUTOFREE));
queryResult.json = nullptr;
result.set("hasMore", triagens::basics::Json(false));
if (triagens::basics::VelocyPackHelper::getBooleanValue(options, "count",
false)) {
result.set("count", triagens::basics::Json(static_cast<double>(n)));
}
result.set("cached", triagens::basics::Json(queryResult.cached));
if (queryResult.cached) {
result.set("extra",
triagens::basics::Json(triagens::basics::Json::Object));
} else {
result.set("extra", extra);
}
result.set("error", triagens::basics::Json(false));
result.set("code", triagens::basics::Json(
static_cast<double>(_response->responseCode())));
result.dump(_response->body());
return;
}
// result is bigger than batchSize, and a cursor will be created
auto cursors = static_cast<triagens::arango::CursorRepository*>(
_vocbase->_cursorRepository);
TRI_ASSERT(cursors != nullptr);
double ttl = triagens::basics::VelocyPackHelper::getNumericValue<double>(
options, "ttl", 30);
bool count = triagens::basics::VelocyPackHelper::getBooleanValue(
options, "count", false);
// steal the query JSON, cursor will take over the ownership
auto j = queryResult.json;
triagens::arango::JsonCursor* cursor = cursors->createFromJson(
j, batchSize, extra.steal(), ttl, count, queryResult.cached);
queryResult.json = nullptr;
try {
_response->body().appendChar('{');
cursor->dump(_response->body());
_response->body().appendText(",\"error\":false,\"code\":");
_response->body().appendInteger(
static_cast<uint32_t>(_response->responseCode()));
_response->body().appendChar('}');
cursors->release(cursor);
} catch (...) {
cursors->release(cursor);
throw;
}
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief register the currently running query
////////////////////////////////////////////////////////////////////////////////
void RestCursorHandler::registerQuery(triagens::aql::Query* query) {
MUTEX_LOCKER(_queryLock);
TRI_ASSERT(_query == nullptr);
_query = query;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief unregister the currently running query
////////////////////////////////////////////////////////////////////////////////
void RestCursorHandler::unregisterQuery() {
MUTEX_LOCKER(_queryLock);
_query = nullptr;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief cancel the currently running query
////////////////////////////////////////////////////////////////////////////////
bool RestCursorHandler::cancelQuery() {
MUTEX_LOCKER(_queryLock);
if (_query != nullptr) {
_query->killed(true);
_queryKilled = true;
return true;
}
return false;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief whether or not the query was canceled
////////////////////////////////////////////////////////////////////////////////
bool RestCursorHandler::wasCanceled() {
MUTEX_LOCKER(_queryLock);
return _queryKilled;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief build options for the query as JSON
////////////////////////////////////////////////////////////////////////////////
VPackBuilder RestCursorHandler::buildOptions(VPackSlice const& slice) const {
VPackBuilder options;
options.openObject();
VPackSlice count = slice.get("count");
if (count.isBool()) {
options.add("count", count);
} else {
options.add("count", VPackValue(false));
}
VPackSlice batchSize = slice.get("batchSize");
if (batchSize.isNumber()) {
if ((batchSize.isDouble() && batchSize.getDouble() == 0.0) ||
(batchSize.isInteger() && batchSize.getUInt() == 0)) {
THROW_ARANGO_EXCEPTION_MESSAGE(
TRI_ERROR_TYPE_ERROR, "expecting non-zero value for <batchSize>");
}
options.add("batchSize", batchSize);
} else {
options.add("batchSize", VPackValue(1000));
}
bool hasCache = false;
VPackSlice cache = slice.get("cache");
if (cache.isBool()) {
hasCache = true;
options.add("cache", cache);
}
VPackSlice opts = slice.get("options");
if (opts.isObject()) {
for (auto const& it : VPackObjectIterator(opts)) {
if (!it.key.isString() || it.value.isNone()) {
continue;
}
std::string keyName = it.key.copyString();
if (keyName != "count" && keyName != "batchSize") {
if (keyName == "cache" && hasCache) {
continue;
}
options.add(keyName, it.value);
}
}
}
VPackSlice ttl = slice.get("ttl");
if (ttl.isNumber()) {
options.add("ttl", ttl);
} else {
options.add("ttl", VPackValue(30));
}
options.close();
return options;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief builds the "extra" attribute values from the result.
/// note that the "extra" object will take ownership from the result for
/// several values
////////////////////////////////////////////////////////////////////////////////
triagens::basics::Json RestCursorHandler::buildExtra(
triagens::aql::QueryResult& queryResult) const {
// build "extra" attribute
triagens::basics::Json extra(triagens::basics::Json::Object);
VPackSlice stats = queryResult.stats.slice();
if (!stats.isNone()) {
extra.set("stats",
triagens::basics::Json(
TRI_UNKNOWN_MEM_ZONE,
triagens::basics::VelocyPackHelper::velocyPackToJson(stats),
triagens::basics::Json::AUTOFREE));
}
if (queryResult.profile != nullptr) {
extra.set("profile",
triagens::basics::Json(TRI_UNKNOWN_MEM_ZONE, queryResult.profile,
triagens::basics::Json::AUTOFREE));
queryResult.profile = nullptr;
}
if (queryResult.warnings == nullptr) {
extra.set("warnings",
triagens::basics::Json(triagens::basics::Json::Array));
} else {
extra.set("warnings",
triagens::basics::Json(TRI_UNKNOWN_MEM_ZONE, queryResult.warnings,
triagens::basics::Json::AUTOFREE));
queryResult.warnings = nullptr;
}
return extra;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JSF_post_api_cursor
////////////////////////////////////////////////////////////////////////////////
void RestCursorHandler::createCursor() {
std::vector<std::string> const& suffix = _request->suffix();
if (suffix.size() != 0) {
generateError(HttpResponse::BAD, TRI_ERROR_HTTP_BAD_PARAMETER,
"expecting POST /_api/cursor");
return;
}
try {
bool parseSuccess = true;
VPackOptions options;
std::shared_ptr<VPackBuilder> parsedBody =
parseVelocyPackBody(&options, parseSuccess);
if (!parseSuccess) {
return;
}
VPackSlice body = parsedBody.get()->slice();
processQuery(body);
} catch (triagens::basics::Exception const& ex) {
unregisterQuery();
generateError(HttpResponse::responseCode(ex.code()), ex.code(), ex.what());
} catch (std::bad_alloc const&) {
unregisterQuery();
generateError(HttpResponse::SERVER_ERROR, TRI_ERROR_OUT_OF_MEMORY);
} catch (std::exception const& ex) {
unregisterQuery();
generateError(HttpResponse::SERVER_ERROR, TRI_ERROR_INTERNAL, ex.what());
} catch (...) {
unregisterQuery();
generateError(HttpResponse::SERVER_ERROR, TRI_ERROR_INTERNAL);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JSF_post_api_cursor_identifier
////////////////////////////////////////////////////////////////////////////////
void RestCursorHandler::modifyCursor() {
std::vector<std::string> const& suffix = _request->suffix();
if (suffix.size() != 1) {
generateError(HttpResponse::BAD, TRI_ERROR_HTTP_BAD_PARAMETER,
"expecting PUT /_api/cursor/<cursor-id>");
return;
}
std::string const& id = suffix[0];
auto cursors = static_cast<triagens::arango::CursorRepository*>(
_vocbase->_cursorRepository);
TRI_ASSERT(cursors != nullptr);
auto cursorId = static_cast<triagens::arango::CursorId>(
triagens::basics::StringUtils::uint64(id));
bool busy;
auto cursor = cursors->find(cursorId, busy);
if (cursor == nullptr) {
if (busy) {
generateError(HttpResponse::responseCode(TRI_ERROR_CURSOR_BUSY),
TRI_ERROR_CURSOR_BUSY);
} else {
generateError(HttpResponse::responseCode(TRI_ERROR_CURSOR_NOT_FOUND),
TRI_ERROR_CURSOR_NOT_FOUND);
}
return;
}
try {
createResponse(HttpResponse::OK);
_response->setContentType("application/json; charset=utf-8");
_response->body().appendChar('{');
cursor->dump(_response->body());
_response->body().appendText(",\"error\":false,\"code\":");
_response->body().appendInteger(
static_cast<uint32_t>(_response->responseCode()));
_response->body().appendChar('}');
cursors->release(cursor);
} catch (triagens::basics::Exception const& ex) {
cursors->release(cursor);
generateError(HttpResponse::responseCode(ex.code()), ex.code(), ex.what());
} catch (...) {
cursors->release(cursor);
generateError(HttpResponse::SERVER_ERROR, TRI_ERROR_INTERNAL);
}
}
////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JSF_post_api_cursor_delete
////////////////////////////////////////////////////////////////////////////////
void RestCursorHandler::deleteCursor() {
std::vector<std::string> const& suffix = _request->suffix();
if (suffix.size() != 1) {
generateError(HttpResponse::BAD, TRI_ERROR_HTTP_BAD_PARAMETER,
"expecting DELETE /_api/cursor/<cursor-id>");
return;
}
std::string const& id = suffix[0];
auto cursors = static_cast<triagens::arango::CursorRepository*>(
_vocbase->_cursorRepository);
TRI_ASSERT(cursors != nullptr);
auto cursorId = static_cast<triagens::arango::CursorId>(
triagens::basics::StringUtils::uint64(id));
bool found = cursors->remove(cursorId);
if (!found) {
generateError(HttpResponse::NOT_FOUND, TRI_ERROR_CURSOR_NOT_FOUND);
return;
}
createResponse(HttpResponse::ACCEPTED);
_response->setContentType("application/json; charset=utf-8");
triagens::basics::Json json(triagens::basics::Json::Object);
json.set("id", triagens::basics::Json(id)); // id as a string!
json.set("error", triagens::basics::Json(false));
json.set("code", triagens::basics::Json(
static_cast<double>(_response->responseCode())));
json.dump(_response->body());
}