MongoCollectionInfo::MongoCollectionInfo(mongo::BSONObj stats)
{
_ns = MongoNamespace(QString::fromStdString(stats.getStringField("ns")));
_sizeBytes = stats.getIntField("size");
_count = stats.getIntField("count");
_storageSizeBytes = stats.getIntField("storageSize");
}
//-----------------------------------------------------------------------------
bool joint_c::fetch( Reveal::Core::joint_ptr joint, mongo::BSONObj bson ) {
assert( joint );
joint->id = bson.getField( FIELD_ID ).String();
mongo::BSONObj bson_q = bson.getObjectField( FIELD_STATE_POSITION );
std::vector<mongo::BSONElement> v_q;
bson_q.elems( v_q );
for( unsigned i = 0; i < v_q.size(); i++ )
joint->state.q( i, v_q[i].Double() );
mongo::BSONObj bson_dq = bson.getObjectField( FIELD_STATE_VELOCITY );
std::vector<mongo::BSONElement> v_dq;
bson_dq.elems( v_dq );
for( unsigned i = 0; i < v_dq.size(); i++ )
joint->state.dq( i, v_dq[i].Double() );
mongo::BSONObj bson_u = bson.getObjectField( FIELD_CONTROL );
std::vector<mongo::BSONElement> v_u;
bson_u.elems( v_u );
for( unsigned i = 0; i < v_u.size(); i++ )
joint->control.u( i, v_u[i].Double() );
return true;
}
mongo::BSONObj JSSleep(const mongo::BSONObj &args){
assert( args.nFields() == 1 );
assert( args.firstElement().isNumber() );
int ms = int( args.firstElement().number() );
sleepms( ms );
return undefined_;
}
RepoBSON::RepoBSON(
const mongo::BSONObj &obj,
const std::unordered_map<std::string, std::pair<std::string, std::vector<uint8_t>>> &binMapping)
: mongo::BSONObj(obj),
bigFiles(binMapping)
{
std::vector<std::pair<std::string, std::string>> existingFiles;
if (bigFiles.size() > 0)
{
mongo::BSONObjBuilder builder, arrbuilder;
for (const auto & pair : bigFiles)
{
//append field name :file name
arrbuilder << pair.first << pair.second.first;
}
if (obj.hasField(REPO_LABEL_OVERSIZED_FILES))
{
arrbuilder.appendElementsUnique(obj.getObjectField(REPO_LABEL_OVERSIZED_FILES));
}
builder.append(REPO_LABEL_OVERSIZED_FILES, arrbuilder.obj());
builder.appendElementsUnique(obj);
*this = builder.obj();
bigFiles = binMapping;
}
}
Datum return_bson(const mongo::BSONObj& b)
{
std::size_t bson_size = b.objsize() + VARHDRSZ;
bytea* new_bytea = (bytea *) palloc(bson_size);
SET_VARSIZE(new_bytea, bson_size);
std::memcpy(VARDATA(new_bytea), b.objdata(), b.objsize());
PG_RETURN_BYTEA_P(new_bytea);
}
MongoCollectionInfo::MongoCollectionInfo(mongo::BSONObj stats):_ns(QString::fromStdString(stats.getStringField("ns")))
{
// if "size" and "storageSize" are of type Int32 or Int64, they
// will be converted to double by "numberDouble()" function.
_sizeBytes = stats.getField("size").numberDouble();
_storageSizeBytes = stats.getField("storageSize").numberDouble();
_count = stats.getIntField("count");
}
static BSONObj native_sleep( const mongo::BSONObj& args, void* data ) {
uassert( 16259,
"sleep takes a single numeric argument -- sleep(milliseconds)",
args.nFields() == 1 && args.firstElement().isNumber() );
sleepmillis( static_cast<long long>( args.firstElement().number() ) );
BSONObjBuilder b;
b.appendUndefined( "" );
return b.obj();
}
//-----------------------------------------------------------------------------
bool trial_c::map( Reveal::Core::trial_ptr& trial, mongo::BSONObj obj ) {
trial = Reveal::Core::trial_ptr( new Reveal::Core::trial_c() );
trial->scenario_id = obj.getField( "scenario_id" ).String();
trial->t = obj.getField( "t" ).Double();
model_c::fetch( trial, obj );
return true;
}
/** Good if one primary and rest secondaries and arbiters */
static bool goodReplStatus (mongo::BSONObj &info) {
if (!info.getField("ok").trueValue()) return false;
vector<mongo::BSONElement> ms = info.getField("members").Array();
bool primary = false;
for (unsigned i = 0; i < ms.size(); i++) {
int state = ms[i].Obj().getIntField("state");
if (state == 1) {primary = true; continue;}
if (state != 2 && state != 7) return false;
}
return primary;
}
std::list<mongo::BSONObj> TransformComputable::compute_transform(mongo::BSONObj query, std::string collection)
{
//get positions in other frames
BSONObjBuilder query_other_frames;
query_other_frames.appendElements(query.removeField("frame").removeField("allow_tf"));
query_other_frames.append("frame", fromjson("{$exists:true}"));
QResCursor cur = robot_memory_->query(query_other_frames.obj(), collection);
//transform them is possible
std::list<mongo::BSONObj> res;
std::string target_frame = query.getField("frame").String();
while(cur->more())
{
BSONObj pos = cur->next();
if(pos.hasField("frame") && pos.hasField("translation") && pos.hasField("rotation"))
{
std::string src_frame = pos.getField("frame").String();
Time now(0, 0);
if(tf_->can_transform(target_frame.c_str(), src_frame.c_str(), now))
{
BSONObjBuilder res_pos;
std::vector<BSONElement> src_trans = pos.getField("translation").Array();
std::vector<BSONElement> src_rot = pos.getField("rotation").Array();
fawkes::tf::Transform pose_tf(fawkes::tf::Quaternion(src_rot[0].Double(), src_rot[1].Double(), src_rot[2].Double(), src_rot[3].Double()),
fawkes::tf::Vector3(src_trans[0].Double(), src_trans[1].Double(), src_trans[2].Double()));
fawkes::tf::Stamped<fawkes::tf::Pose> src_stamped_pose(pose_tf, Time(0, 0), src_frame.c_str());
fawkes::tf::Stamped<fawkes::tf::Pose> res_stamped_pose;
tf_->transform_pose(target_frame.c_str(), src_stamped_pose, res_stamped_pose);
res_pos.appendElements(pos.removeField("frame").removeField("translation").removeField("rotation").removeField("_id"));
res_pos.append("frame", target_frame);
res_pos.append("allow_tf", true);
BSONArrayBuilder arrb_trans;
arrb_trans.append(res_stamped_pose.getOrigin().x());
arrb_trans.append(res_stamped_pose.getOrigin().y());
arrb_trans.append(res_stamped_pose.getOrigin().z());
res_pos.append("translation", arrb_trans.arr());
BSONArrayBuilder arrb_rot;
arrb_rot.append(res_stamped_pose.getRotation().x());
arrb_rot.append(res_stamped_pose.getRotation().y());
arrb_rot.append(res_stamped_pose.getRotation().z());
arrb_rot.append(res_stamped_pose.getRotation().w());
res_pos.append("rotation", arrb_rot.arr());
res.push_back(res_pos.obj());
}
// else
// {
// logger_->log_info(name_, "Cant transform %s to %s", src_frame.c_str(), target_frame.c_str());
// }
}
}
return res;
}
void Processer::DoHost(const std::string& grid,const std::string& cluster,mongo::BSONObj& host)
{
std::string host_id;
std::cout << host << std::endl;
if(host.hasField("host_ID") && host.hasField("heartbeat"))
{
//deal the record with host level
//do not need to cut it off
DBModules::iterator iter = db_modules_.begin();
for(;iter!=db_modules_.end();++iter)
{
iter->handler(host.objdata(),host.objsize(),NULL);
}
// host_id = host.getStringField("host_ID");
// std::vector<mongo::BSONElement> ele;
// host.elems(ele);
// for(int i=0;i<ele.size();i++)
// {
// if((!strcmp(ele[i].fieldName(),"host_ID")) ||
// (!strcmp(ele[i].fieldName(),"heartbeat")))
// {
// continue;
// }
// else
// {
// std::string ds_name = ele[i].fieldName();
// std::string path;
// if(grid!="")
// path = grid + '/' + cluster + '/' + host_id;
// else
// path = cluster + '/' + host_id;
// mongo::BSONObj obj = ele[i].wrap();
// std::cout << obj << std::endl;
// std::list<void(*)(const char*,int,const char*)>::iterator iter;
// iter = callback_[ds_name].begin();
// for(;iter!=callback_[ds_name].end();++iter)
// {
// (*iter)(obj.objdata(),obj.objsize(),path.c_str());
// }
// }
// }
}
else
{
std::stringstream oss;
oss << "This data is illegal! Drop!!";
LOG4CXX_WARN(log_,oss.str());
}
}
//-----------------------------------------------------------------------------
bool solution_c::map( Reveal::Core::solution_ptr& solution, mongo::BSONObj obj, Reveal::Core::solution_c::type_e type ) {
solution = Reveal::Core::solution_ptr( new Reveal::Core::solution_c( type ) );
if( type == Reveal::Core::solution_c::CLIENT )
solution->experiment_id = obj.getField( "experiment_id" ).String();
solution->scenario_id = obj.getField( "scenario_id" ).String();
solution->t = obj.getField( "t" ).Double();
if( type == Reveal::Core::solution_c::CLIENT )
solution->real_time = obj.getField( "real_time" ).Double();
model_c::fetch( solution, obj );
return true;
}
std::string CjsonExporter::toCjson(const mongo::BSONObj &mongoChemObj)
{
// Follow the database link and convert to CJSON.
MongoDatabase *db = MongoDatabase::instance();
if (!db)
return "";
mongo::BSONObj structure = mongoChemObj.getObjectField("3dStructure");
if (!structure.hasField("$ref") || !structure.hasField("$id")
|| !structure.getField("$id").isSimpleType()) {
return "";
}
std::auto_ptr<mongo::DBClientCursor> cursor =
db->query(db->databaseName() + "." + structure.getStringField("$ref"),
QUERY("_id" << structure.getField("$id").OID()), 1);
mongo::BSONObj object;
if (cursor->more())
object = cursor->next();
else
return "";
std::vector<std::string> toCopy;
toCopy.push_back("name");
toCopy.push_back("inchi");
toCopy.push_back("formula");
toCopy.push_back("properties");
mongo::BSONObjBuilder builder;
for (size_t i = 0; i < toCopy.size(); i++) {
mongo::BSONElement field = mongoChemObj.getField(toCopy[i]);
if (!field.eoo())
builder.append(field);
}
toCopy.clear();
toCopy.push_back("atoms");
toCopy.push_back("bonds");
for (size_t i = 0; i < toCopy.size(); i++) {
mongo::BSONElement field = object.getField(toCopy[i]);
if (!field.eoo())
builder.append(field);
}
// Add the chemical JSON version field.
builder.append("chemical json", 0);
mongo::BSONObj obj = builder.obj();
return obj.jsonString(mongo::Strict);
}
stitch_support_v1_update(mongo::ServiceContext::UniqueClient client,
mongo::BSONObj updateExpr,
mongo::BSONArray arrayFilters,
stitch_support_v1_matcher* matcher,
stitch_support_v1_collator* collator)
: client(std::move(client)),
opCtx(this->client->makeOperationContext()),
updateExpr(updateExpr.getOwned()),
arrayFilters(arrayFilters.getOwned()),
matcher(matcher),
updateDriver(new mongo::ExpressionContext(
opCtx.get(), collator ? collator->collator.get() : nullptr)) {
std::vector<mongo::BSONObj> arrayFilterVector;
for (auto&& filter : this->arrayFilters) {
arrayFilterVector.push_back(filter.embeddedObject());
}
this->parsedFilters = uassertStatusOK(mongo::ParsedUpdate::parseArrayFilters(
arrayFilterVector, this->opCtx.get(), collator ? collator->collator.get() : nullptr));
// Initializing the update as single-document allows document-replacement updates.
bool multi = false;
updateDriver.parse(this->updateExpr, parsedFilters, multi);
uassert(51037,
"Updates with a positional operator require a matcher object.",
matcher || !updateDriver.needMatchDetails());
}
void CMetadata::_objBsonToJson(rapidjson::Value& json, mongo::BSONObj& bson)
{
std::vector<mongo::BSONElement> values;
bson.elems(values);
for (uint i = 0; i<values.size(); ++i) {
this->_fieldBsonToJson(json, values[i].fieldName(), bson);
}
}
void CMetadata::fromBson(mongo::BSONObj& bson)
{
std::vector<mongo::BSONElement> elements;
bson.elems(elements);
for (uint i = 0; i<elements.size(); ++i) {
this->_fieldBsonToJson(m_members, elements[i].fieldName(), bson);
}
}
stitch_support_v1_matcher(mongo::ServiceContext::UniqueClient client,
const mongo::BSONObj& filterBSON,
stitch_support_v1_collator* collator)
: client(std::move(client)),
opCtx(this->client->makeOperationContext()),
matcher(filterBSON.getOwned(),
new mongo::ExpressionContext(opCtx.get(),
collator ? collator->collator.get() : nullptr)){};
repo::core::RepoNodeTexture::RepoNodeTexture(const mongo::BSONObj &obj)
: RepoNodeAbstract(obj)
, data(NULL)
{
//
// Width
//
if (obj.hasField(REPO_LABEL_WIDTH))
width = obj.getField(REPO_LABEL_WIDTH).numberInt();
//
// Height
//
if (obj.hasField(REPO_LABEL_HEIGHT))
height = obj.getField(REPO_LABEL_HEIGHT).numberInt();
//
// Format
//
if (obj.hasField(REPO_NODE_LABEL_EXTENSION)) {
extension = obj.getField(REPO_NODE_LABEL_EXTENSION).str();
name += "." + extension; // assimp needs full names with extension
}
//
// Bit depth
//
//if (obj.hasField(REPO_NODE_LABEL_BIT_DEPTH))
// bitDepth = obj.getField(REPO_NODE_LABEL_BIT_DEPTH).numberInt();
//
// Data
//
if (obj.hasField(REPO_LABEL_DATA) &&
obj.hasField(REPO_NODE_LABEL_DATA_BYTE_COUNT))
{
std::cerr << "Texture" << std::endl;
data = new std::vector<char>();
RepoTranscoderBSON::retrieve(
obj.getField(REPO_LABEL_DATA),
obj.getField(REPO_NODE_LABEL_DATA_BYTE_COUNT).numberInt(),
data);
}
}
MongoCollectionInfo::MongoCollectionInfo(mongo::BSONObj stats) : _ns(stats.getStringField("ns"))
{
// if "size" and "storageSize" are of type Int32 or Int64, they
// will be converted to double by "numberDouble()" function.
_sizeBytes = BsonUtils::getField<mongo::NumberDouble>(stats,"size");
_storageSizeBytes = BsonUtils::getField<mongo::NumberDouble>(stats,"storageSize");
// NumberLong because of mongodb can have very big collections
_count = BsonUtils::getField<mongo::NumberLong>(stats,"count");
}
void CMetadata::fromBson(mongo::BSONObj& bson, std::string key)
{
rapidjson::Value& member = this->getFieldVal(m_members, key);
std::vector<mongo::BSONElement> elements;
bson.elems(elements);
for (uint i = 0; i<elements.size(); ++i) {
this->_fieldBsonToJson(member, elements[i].fieldName(), bson);
}
}
void MongoClient::saveDocument(const mongo::BSONObj &obj, const MongoNamespace &ns)
{
mongo::BSONElement id = obj.getField("_id");
mongo::BSONObjBuilder builder;
builder.append(id);
mongo::BSONObj bsonQuery = builder.obj();
mongo::Query query(bsonQuery);
_dbclient->update(ns.toString(), query, obj, true, false);
checkLastErrorAndThrow(ns.databaseName());
}
void MongoClient::saveDocument(const mongo::BSONObj &obj, const MongoNamespace &ns)
{
mongo::BSONElement id = obj.getField("_id");
mongo::BSONObjBuilder builder;
builder.append(id);
mongo::BSONObj bsonQuery = builder.obj();
mongo::Query query(bsonQuery);
_dbclient->update(ns.toString(), query, obj, true, false);
//_dbclient->save(ns.toString().toStdString(), obj);
}
void Processer::Handle(mongo::BSONObj& bson)
{
//handle the bson
//maybe grid-bosn;maybe cluster-bson
std::string grid_id;
if(bson.hasField("grid_ID") && bson.hasField("cluster_data"))
{
grid_id = bson.getStringField("grid_ID");
std::vector<mongo::BSONElement> c_ele = bson["cluster_data"].Array();
for(int i=0;i<c_ele.size();i++)
{
mongo::BSONObj obj = c_ele[i].Obj();
DoCluster(grid_id,obj);
}
}
else
{
grid_id = "";
DoCluster(grid_id,bson);
}
}
template <> acl::UserData Unserialize<acl::UserData>(const mongo::BSONObj& obj)
{
try
{
acl::UserData user;
user.id = obj["uid"].Int();
user.name = obj["name"].String();
UnserializeContainer(obj["ip masks"].Array(), user.ipMasks);
user.password = obj["password"].String();
user.salt = obj["salt"].String();
user.flags = obj["flags"].String();
user.primaryGid = obj["primary gid"].Int();
UnserializeContainer(obj["secondary gids"].Array(), user.secondaryGids);
UnserializeContainer(obj["gadmin gids"].Array(), user.gadminGids);
user.creator = obj["creator"].Int();
mongo::BSONElement oid;
obj.getObjectID(oid);
user.created = ToGregDate(oid.OID().asDateT());
user.homeDir = obj["home dir"].String();
user.startUpDir = obj["startup dir"].String();
user.idleTime = obj["idle time"].Int();
if (obj["expires"].type() != mongo::jstNULL)
user.expires.reset(ToGregDate(obj["expires"].Date()));
user.numLogins = obj["num logins"].Int();
user.comment = obj["comment"].String();
user.tagline = obj["tagline"].String();
user.maxDownSpeed = obj["max down speed"].Long();
user.maxUpSpeed = obj["max up speed"].Long();
user.maxSimDown = obj["max sim down"].Int();
user.maxSimUp = obj["max sim up"].Int();
user.loggedIn = obj["logged in"].Int();
if (obj["last login"].type() != mongo::jstNULL)
user.lastLogin.reset(ToPosixTime(obj["last login"].Date()));
UnserializeMap(obj["ratio"].Array(), "section", "value", user.ratio);
UnserializeMap(obj["credits"].Array(), "section", "value", user.credits);
UnserializeMap(obj["weekly allotment"].Array(), "section", "value", user.weeklyAllotment);
return user;
}
catch (const mongo::DBException& e)
{
LogException("Unserialize user", e, obj);
throw e;
}
}
void Processer::DoCluster(const std::string& grid,mongo::BSONObj& cluster)
{
std::string cluster_id;
if(cluster.hasField("cluster_ID") && cluster.hasField("host_data"))
{
cluster_id = cluster.getStringField("cluster_ID");
std::vector<mongo::BSONElement> h_ele = cluster["host_data"].Array();
for(int i=0;i<h_ele.size();i++)
{
mongo::BSONObj obj = h_ele[i].Obj();
DoHost(grid,cluster_id,obj);
}
}
else
{
std::stringstream oss;
oss << "This data is illegal! Drop!!";
LOG4CXX_WARN(log_,oss.str());
std::cout << cluster << std::endl;
}
}
MongoUser::MongoUser(const float version, const mongo::BSONObj &obj) :
_version(version), _readOnly(false)
{
_id = obj.getField("_id").OID();
_name = BsonUtils::getField<mongo::String>(obj, "user");
_passwordHash = BsonUtils::getField<mongo::String>(obj, "pwd");
if (_version<minimumSupportedVersion) {
_readOnly = BsonUtils::getField<mongo::Bool>(obj, "readOnly");
}
else {
_userSource = BsonUtils::getField<mongo::String>(obj, "userSource");
std::vector<mongo::BSONElement> roles = BsonUtils::getField<mongo::Array>(obj, "roles");
for (std::vector<mongo::BSONElement>::const_iterator it = roles.begin(); it != roles.end(); ++it)
{
_role.push_back(BsonUtils::bsonelement_cast<std::string>(*it));
}
}
}
static BSONObj native_tostrictjson(const mongo::BSONObj& args, void* data) {
uassert(40275,
"tostrictjson takes a single BSON object argument, and on optional boolean argument "
"for prettyPrint -- tostrictjson(obj, prettyPrint = false)",
args.nFields() >= 1 && args.firstElement().isABSONObj() &&
(args.nFields() == 1 || (args.nFields() == 2 && args["1"].isBoolean())));
bool prettyPrint = false;
if (args.nFields() == 2) {
prettyPrint = args["1"].boolean();
}
return BSON("" << tojson(args.firstElement().embeddedObject(), Strict, prettyPrint));
}
stitch_support_v1_projection(mongo::ServiceContext::UniqueClient client,
const mongo::BSONObj& pattern,
stitch_support_v1_matcher* matcher,
stitch_support_v1_collator* collator)
: client(std::move(client)),
opCtx(this->client->makeOperationContext()),
projectionExec(opCtx.get(),
pattern.getOwned(),
matcher ? matcher->matcher.getMatchExpression() : nullptr,
collator ? collator->collator.get() : nullptr),
matcher(matcher) {
uassert(51050,
"Projections with a positional operator require a matcher",
matcher || !projectionExec.projectRequiresQueryExpression());
uassert(51051,
"$textScore, $sortKey, $recordId, $geoNear and $returnKey are not allowed in this "
"context",
!projectionExec.hasMetaFields() && !projectionExec.returnKey());
}
//-----------------------------------------------------------------------------
bool joint_c::fetch( Reveal::Core::model_ptr model, mongo::BSONObj bson_model ) {
Reveal::Core::joint_ptr joint;
mongo::BSONObj bson_joints;
std::vector<mongo::BSONElement> v_joints;
bson_joints = bson_model.getObjectField( DOCUMENT );
bson_joints.elems( v_joints );
for( unsigned i = 0; i < v_joints.size(); i++ ) {
joint = Reveal::Core::joint_ptr( new Reveal::Core::joint_c() );
fetch( joint, v_joints[i].Obj() );
model->joints.push_back( joint );
}
return true;
}
int MongoSchema::extractBSON(mongo::BSONObj bo, int& depth, std::string parent){
if(depth >= m_depth){
return 0;
}
depth++;
for( BSONObj::iterator i = bo.begin(); i.more(); ) {
BSONElement e = i.next();
if(skipField(e.fieldName())){
continue;
}
std::string fieldname = parent ;
fieldname.append(".");
fieldname.append(e.fieldName());
if(e.isSimpleType()){
hashmap::const_iterator keyexsit = m_map.find(fieldname);
SchemaModel* sm = new SchemaModel();
if(keyexsit != m_map.end()){
sm = &m_map[fieldname];
sm->count ++;
}else{
sm->count = 1;
sm->datatype = getType(e);
m_map[fieldname] = *sm;
}
}else if(e.isABSONObj()){
extractBSON(e.Obj(), depth, fieldname);
}
}
return 0;
}
