Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge branch 'mjmh' of https://github.com/triAGENS/ArangoDB into mjmh

This commit is contained in:
Jan Steemann 2014-05-20 14:21:20 +02:00
parent cdad1f19fe 0dab3706c5
commit 22e0290b06
8 changed files with 409 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
arangod/Wal/Slot.h
View File

@ -29,6 +29,7 @@
#define TRIAGENS_WAL_LOG_SLOT_H 1
#include "Basics/Common.h"
#include "ShapedJson/Legends.h"
#include "Wal/Logfile.h"
extern "C" {

2
js/apps/system/aardvark/frontend/js/bootstrap/errors.js
View File

@ -38,6 +38,8 @@
"ERROR_CANNOT_CREATE_TEMP_FILE" : { "code" : 20, "message" : "cannot create temporary file" },
"ERROR_REQUEST_CANCELED" : { "code" : 21, "message" : "canceled request" },
"ERROR_DEBUG" : { "code" : 22, "message" : "intentional debug error" },
"ERROR_AID_NOT_FOUND" : { "code" : 23, "message" : "internal error with attribute ID in shaper" },
"ERROR_LEGEND_INCOMPLETE" : { "code" : 24, "message" : "internal error if a legend could not be created" },
"ERROR_HTTP_BAD_PARAMETER" : { "code" : 400, "message" : "bad parameter" },
"ERROR_HTTP_UNAUTHORIZED" : { "code" : 401, "message" : "unauthorized" },
"ERROR_HTTP_FORBIDDEN" : { "code" : 403, "message" : "forbidden" },

2
js/common/bootstrap/errors.js
View File

@ -38,6 +38,8 @@
"ERROR_CANNOT_CREATE_TEMP_FILE" : { "code" : 20, "message" : "cannot create temporary file" },
"ERROR_REQUEST_CANCELED" : { "code" : 21, "message" : "canceled request" },
"ERROR_DEBUG" : { "code" : 22, "message" : "intentional debug error" },
"ERROR_AID_NOT_FOUND" : { "code" : 23, "message" : "internal error with attribute ID in shaper" },
"ERROR_LEGEND_INCOMPLETE" : { "code" : 24, "message" : "internal error if a legend could not be created" },
"ERROR_HTTP_BAD_PARAMETER" : { "code" : 400, "message" : "bad parameter" },
"ERROR_HTTP_UNAUTHORIZED" : { "code" : 401, "message" : "unauthorized" },
"ERROR_HTTP_FORBIDDEN" : { "code" : 403, "message" : "forbidden" },

2
lib/BasicsC/errors.dat
View File

@ -25,6 +25,8 @@ ERROR_CANNOT_CREATE_DIRECTORY,19,"cannot create directory","Will be raised when
ERROR_CANNOT_CREATE_TEMP_FILE,20,"cannot create temporary file","Will be raised when an attempt to create a temporary file fails."
ERROR_REQUEST_CANCELED,21,"canceled request","Will be raised when a request is canceled by the user."
ERROR_DEBUG,22,"intentional debug error","Will be raised intentionally during debugging."
ERROR_AID_NOT_FOUND,23,"internal error with attribute ID in shaper","Will be raised if an attribute ID is not found in the shaper but should have been."
ERROR_LEGEND_INCOMPLETE,24,"internal error if a legend could not be created","Will be raised if the legend generator was only given access to the shape and some sids are in the data object (inhomogeneous lists)."
################################################################################
## HTTP standard errors

2
lib/BasicsC/voc-errors.c
View File

@ -34,6 +34,8 @@ void TRI_InitialiseErrorMessages (void) {
REG_ERROR(ERROR_CANNOT_CREATE_TEMP_FILE, "cannot create temporary file");
REG_ERROR(ERROR_REQUEST_CANCELED, "canceled request");
REG_ERROR(ERROR_DEBUG, "intentional debug error");
REG_ERROR(ERROR_AID_NOT_FOUND, "internal error with attribute ID in shaper");
REG_ERROR(ERROR_LEGEND_INCOMPLETE, "internal error if a legend could not be created");
REG_ERROR(ERROR_HTTP_BAD_PARAMETER, "bad parameter");
REG_ERROR(ERROR_HTTP_UNAUTHORIZED, "unauthorized");
REG_ERROR(ERROR_HTTP_FORBIDDEN, "forbidden");

28
lib/BasicsC/voc-errors.h
View File

@ -57,6 +57,12 @@ extern "C" {
/// Will be raised when a request is canceled by the user.
/// - 22: @LIT{intentional debug error}
/// Will be raised intentionally during debugging.
/// - 23: @LIT{internal error with attribute ID in shaper}
/// Will be raised if an attribute ID is not found in the shaper but should
/// have been.
/// - 24: @LIT{internal error if a legend could not be created}
/// Will be raised if the legend generator was only given access to the shape
/// and some sids are in the data object (inhomogeneous lists).
/// - 400: @LIT{bad parameter}
/// Will be raised when the HTTP request does not fulfill the requirements.
/// - 401: @LIT{unauthorized}
@ -760,6 +766,28 @@ void TRI_InitialiseErrorMessages (void);
#define TRI_ERROR_DEBUG (22)
////////////////////////////////////////////////////////////////////////////////
/// @brief 23: ERROR_AID_NOT_FOUND
///
/// internal error with attribute ID in shaper
///
/// Will be raised if an attribute ID is not found in the shaper but should
/// have been.
////////////////////////////////////////////////////////////////////////////////
#define TRI_ERROR_AID_NOT_FOUND (23)
////////////////////////////////////////////////////////////////////////////////
/// @brief 24: ERROR_LEGEND_INCOMPLETE
///
/// internal error if a legend could not be created
///
/// Will be raised if the legend generator was only given access to the shape
/// and some sids are in the data object (inhomogeneous lists).
////////////////////////////////////////////////////////////////////////////////
#define TRI_ERROR_LEGEND_INCOMPLETE (24)
////////////////////////////////////////////////////////////////////////////////
/// @brief 400: ERROR_HTTP_BAD_PARAMETER
///

240
lib/ShapedJson/Legends.cpp Normal file
View File

@ -0,0 +1,240 @@
////////////////////////////////////////////////////////////////////////////////
/// @brief legends for shaped JSON objects to make them self-contained
///
/// @file
/// Code for legends.
///
/// DISCLAIMER
///
/// 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 triAGENS GmbH, Cologne, Germany
///
/// @author Max Neunhoeffer
/// @author Copyright 2014-2014, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "ShapedJson/Legends.h"
using namespace std;
using namespace triagens;
using namespace triagens::basics;
void JsonLegend::clear () {
_have_attribute.clear();
_attribs.clear();
_att_data.clear();
_have_shape.clear();
_shapes.clear();
_shape_data.clear();
}
int JsonLegend::addAttributeId (TRI_shape_aid_t aid) {
unordered_set<TRI_shape_aid_t>::const_iterator it = _have_attribute.find(aid);
if (it != _have_attribute.end()) {
return TRI_ERROR_NO_ERROR;
}
char const* p = _shaper->lookupAttributeId(_shaper, aid);
if (0 == p) {
return TRI_ERROR_AID_NOT_FOUND;
}
_have_attribute.insert(aid);
size_t len = strlen(p);
_attribs.emplace_back(aid, _att_data.length());
_att_data.appendText(p, len+1); // including the zero byte
return TRI_ERROR_NO_ERROR;
}
int JsonLegend::addShape (TRI_shape_sid_t sid,
char const* data, uint32_t len) {
// data can be 0, then no data is associated, note that if the shape
// contains an inhomogeneous list as one of its subobjects, then the
// shape legend could be incomplete, because the actual shapes of
// the subobject(s) are held only in the data and not in the shaper.
// In this case this method includes all shapes it can but then
// returns TRI_ERROR_LEGEND_INCOMPLETE.
int res = TRI_ERROR_NO_ERROR;
TRI_shape_t const* shape = 0;
// First the trivial cases:
if (sid < TRI_FirstCustomShapeIdShaper()) {
shape = TRI_LookupSidBasicShapeShaper(sid);
}
else {
shape = _shaper->lookupShapeId(_shaper, sid);
if (0 == shape) {
return TRI_ERROR_LEGEND_INCOMPLETE;
}
unordered_set<TRI_shape_sid_t>::const_iterator it = _have_shape.find(sid);
if (it == _have_shape.end()) {
_have_shape.insert(sid);
Shape sh(sid, _shape_data.length(), shape->_size);
_shapes.push_back(sh);
_shape_data.appendText( reinterpret_cast<char const*>(shape),
shape->_size );
}
}
// Now we have to add all attribute IDs and all shapes used by this
// one recursively, note that the data of this object is in a
// consistent state, such that we can call ourselves recursively.
if (shape->_type == TRI_SHAPE_HOMOGENEOUS_SIZED_LIST) {
// Handle a homogeneous list with equal size entries:
// Subobjects have fixed size, so in particular no subobject can
// contain any inhomogeneous list as one of its subobjects,
// therefore we do not have to hand down actual shaped JSON data.
TRI_homogeneous_sized_list_shape_t const* shape_spec
= reinterpret_cast<TRI_homogeneous_sized_list_shape_t const*>
(shape);
res = addShape(shape_spec->_sidEntry, 0, 0);
}
else if (shape->_type == TRI_SHAPE_HOMOGENEOUS_LIST) {
// Handle a homogeneous list:
// Only one sid, but one of the subobjects could be an
// inhomogeneous list. We first scan the shape without data, if this
// goes well, there was no subshape containing an inhomogeneous
// list! Otherwise, we have to scan all entries of the list.
TRI_homogeneous_list_shape_t const* shape_spec
= reinterpret_cast<TRI_homogeneous_list_shape_t const*>
(shape);
res = addShape(shape_spec->_sidEntry, 0, 0);
if (res == TRI_ERROR_LEGEND_INCOMPLETE) {
// The subdocuments contain inhomogeneous lists, so we have to
// scan them all:
res = TRI_ERROR_NO_ERROR; // just in case the length is 0
TRI_shape_length_list_t const* len
= reinterpret_cast<TRI_shape_length_list_t const*>(data);
TRI_shape_size_t const* offsets
= reinterpret_cast<TRI_shape_size_t const*>(len+1);
TRI_shape_length_list_t i;
for (i = 0;i < *len;i++) {
res = addShape(shape_spec->_sidEntry, data + offsets[i],
offsets[i+1]-offsets[i]);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
}
}
}
else if (shape->_type == TRI_SHAPE_LIST) {
// Handle an inhomogeneous list:
// We have to scan recursively all entries of the list since they
// contain sids in the data area.
TRI_shape_length_list_t const* len
= reinterpret_cast<TRI_shape_length_list_t const*>(data);
TRI_shape_sid_t const* sids
= reinterpret_cast<TRI_shape_sid_t const*>(len+1);
TRI_shape_size_t const* offsets
= reinterpret_cast<TRI_shape_size_t const*>(sids + *len);
TRI_shape_length_list_t i;
for (i = 0;i < *len;i++) {
res = addShape(sids[i], data + offsets[i], offsets[i+1]-offsets[i]);
if (res != TRI_ERROR_NO_ERROR) {
break;
}
}
}
else if (shape->_type == TRI_SHAPE_ARRAY) {
// Handle an array:
// Distinguish between fixed size subobjects and variable size
// subobjects. The fixed ones cannot contain inhomogeneous lists.
TRI_array_shape_t const* shape_spec
= reinterpret_cast<TRI_array_shape_t const*> (shape);
TRI_shape_sid_t const* sids
= reinterpret_cast<TRI_shape_sid_t const*>(shape_spec+1);
TRI_shape_aid_t const* aids
= reinterpret_cast<TRI_shape_aid_t const*>
(sids + (shape_spec->_fixedEntries + shape_spec->_variableEntries));
TRI_shape_size_t const* offsets
= reinterpret_cast<TRI_shape_size_t const*>
(aids + (shape_spec->_fixedEntries + shape_spec->_variableEntries));
uint64_t i;
for (i = 0; res == TRI_ERROR_NO_ERROR &&
i < shape_spec->_fixedEntries + shape_spec->_variableEntries;
i++) {
res = addAttributeId(aids[i]);
}
for (i = 0; res == TRI_ERROR_NO_ERROR && i < shape_spec->_fixedEntries;
i++) {
// Fixed size subdocs cannot have inhomogeneous lists as subdocs:
res = addShape(sids[i], 0, 0);
}
for (i = 0; res == TRI_ERROR_NO_ERROR && i < shape_spec->_variableEntries;
i++) {
addShape(sids[i + shape_spec->_fixedEntries],
data + offsets[i], offsets[i+1] - offsets[i]);
}
}
return res;
}
static inline TRI_shape_size_t roundup8(TRI_shape_size_t x) {
return (x + 7) - ((x + 7) & 7);
}
size_t JsonLegend::getSize () {
// Add string pool size and shape pool size and add space for header
// and tables in bytes.
return sizeof(TRI_shape_size_t) // number of aids
+ sizeof(AttributeId) * _attribs.size() // aid entries
+ sizeof(TRI_shape_size_t) // number of sids
+ sizeof(Shape) * _shapes.size() // sid entries
+ roundup8(_att_data.length()) // string data, padded
+ roundup8(_shape_data.length()); // shape data, padded
}
void JsonLegend::dump (void* buf) {
// Dump the resulting legend to a given buffer.
// First sort the aids in ascending order:
sort(_attribs.begin(), _attribs.end(), AttributeComparerObject);
// Then sort the sids in ascending order:
sort(_shapes.begin(), _shapes.end(), ShapeComparerObject);
TRI_shape_size_t* p = reinterpret_cast<TRI_shape_size_t*>(buf);
TRI_shape_size_t i;
*p++ = _attribs.size();
AttributeId* a = reinterpret_cast<AttributeId*>(p);
for (i = 0; i < _attribs.size(); i++) {
*a++ = _attribs[i];
}
p = reinterpret_cast<TRI_shape_size_t*>(a);
*p++ = _shapes.size();
Shape* s = reinterpret_cast<Shape*>(p);
for (i = 0; i < _shapes.size(); i++) {
*s++ = _shapes[i];
}
char* c = reinterpret_cast<char*>(s);
memcpy(c, _att_data.c_str(), _att_data.length());
i = roundup8(_att_data.length());
if (i > _att_data.length()) {
memset( c + _att_data.length(), 0, i-_att_data.length());
}
c += i;
memcpy(c, _shape_data.c_str(), _shape_data.length());
i = roundup8(_shape_data.length());
if (i > _shape_data.length()) {
memset( c + _shape_data.length(), 0, i-_shape_data.length());
}
}

132
lib/ShapedJson/Legends.h Normal file
View File

@ -0,0 +1,132 @@
////////////////////////////////////////////////////////////////////////////////
/// @brief legends for shaped JSON objects to make them self-contained
///
/// @file
/// Declaration for legends.
///
/// DISCLAIMER
///
/// 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 triAGENS GmbH, Cologne, Germany
///
/// @author Max Neunhoeffer
/// @author Copyright 2014-2014, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#ifndef TRIAGENS_SHAPED_JSON_LEGENDS_H
#define TRIAGENS_SHAPED_JSON_LEGENDS_H 1
#include "BasicsC/common.h"
#include "Basics/Common.h"
#include "BasicsC/structures.h"
#include "Basics/StringBuffer.h"
#include "ShapedJson/shaped-json.h"
#include "ShapedJson/json-shaper.h"
namespace triagens {
namespace basics {
class JsonLegend {
public:
JsonLegend (TRI_shaper_t* shaper)
: _shaper(shaper), _att_data(TRI_UNKNOWN_MEM_ZONE),
_shape_data(TRI_UNKNOWN_MEM_ZONE) {
}
~JsonLegend () {
};
void reset (TRI_shaper_t* shaper) {
clear();
_shaper = shaper;
}
void clear ();
int addAttributeId (TRI_shape_aid_t aid);
int addShape (TRI_shaped_json_t const* sh_json) {
return addShape(sh_json->_sid, sh_json->_data.data,
sh_json->_data.length);
}
int addShape (TRI_shape_sid_t sid, TRI_blob_t const* blob) {
return addShape(sid, blob->data, blob->length);
}
int addShape (TRI_shape_sid_t sid, char const* data, uint32_t len);
size_t getSize ();
void dump (void* buf);
private:
TRI_shaper_t* _shaper;
struct AttributeId {
TRI_shape_aid_t aid;
TRI_shape_size_t offset;
AttributeId (TRI_shape_aid_t a, TRI_shape_size_t o)
: aid(a), offset(o) {}
};
static struct AttributeComparerClass {
bool operator() (AttributeId const& a, AttributeId const& b) {
return a.aid < b.aid;
}
} AttributeComparerObject;
struct Shape {
TRI_shape_sid_t sid;
TRI_shape_size_t offset;
TRI_shape_size_t size;
Shape (TRI_shape_sid_t sid, TRI_shape_size_t o, TRI_shape_size_t siz)
: sid(sid), offset(o), size(siz) {}
};
static struct ShapeComparerClass {
bool operator() (Shape const& a, Shape const& b) {
return a.sid < b.sid;
}
} ShapeComparerObject;
unordered_set<TRI_shape_aid_t> _have_attribute;
vector<AttributeId> _attribs;
StringBuffer _att_data;
unordered_set<TRI_shape_sid_t> _have_shape;
vector<Shape> _shapes;
StringBuffer _shape_data;
};
}
}
#endif
// Local Variables:
// mode: outline-minor
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @addtogroup\\|/// @page\\|// --SECTION--\\|/// @\\}"
// End: