/**********************************************************
*see readFromDB in FileRec, similar structure
*
***********************************************************/
void VersionRec::readFromDB(mongo::DBClientConnection& conn, string versionID) {
auto_ptr<mongo::DBClientCursor> cursor =
conn.query("fileRecords.FileVersion", MONGO_QUERY("_id" << mongo::OID(versionID)));
if (cursor->more()) {
//convert to VersionRec
BSONObj record = cursor->next();
this->versionid = versionID;
this->tmpname = record.getStringField("Tempname");
this->filehash = record.getStringField("filehash");
this->length = record.getIntField("length");
this->modifytime.tv_nsec = record.getField("Mtnsec").numberLong();
this->modifytime.tv_sec = record.getField("mtsec").numberLong();
this->versionnumber = record.getIntField("Version");
//similar to the comments collection in readfromDB in FileRec
vector<BSONElement> hashes(record.getField("Blktable").Array());
for (vector<BSONElement>::iterator it = hashes.begin(); it != hashes.end(); ++it) {
BSONObj blockdata = it->Obj();
BSONElement blocknum = blockdata.getField("Blknum");
BSONElement blockhash = blockdata.getField("hash");
VersionDiffBlock tmp;
tmp.blockNo = blocknum.Int();
tmp.blockHash = blockhash.String();
changesAppend(tmp);
}
}
else{
cout << "could not find version " << versionID << endl;
}
}
void printIfAge(mongo::DBClientConnection& c, int age) {
std::auto_ptr<mongo::DBClientCursor> cursor =
c.query("test.test", MONGO_QUERY("age" << age));
while (cursor->more()) {
mongo::BSONObj p = cursor->next();
std::cout << p.getStringField("name") << std::endl;
}
}
void run(mongo::DBClientConnection& c) {
std::auto_ptr<DBClientCursor> cursor = c.query("hackdb.transactions", BSONObj());
int i = 0;
while (cursor->more()){
i++;
std::cout << cursor->next().toString() << std::endl;
}
debug_lib::log( "read %d records", i );
}
acl::GroupID LookupGID(mongo::DBClientConnection& conn, const std::string& group)
{
auto query = QUERY("name" << group);
auto cursor = conn.query(config->Database().Name() + ".groups", query, 1);
db::LastErrorToException(conn);
if (!cursor.get()) throw mongo::DBException("Connection failure", 0);
if (!cursor->more()) throw util::RuntimeError("Group doesn't exist: " + group);
return cursor->next()["gid"].Int();
}
/**********************************************************
*convert FileRec to bson, then write to db
*
***********************************************************/
void FileRec::writeToDB(mongo::DBClientConnection &conn) {
BSONObjBuilder record; //build BSONObj
record.append("filename", this->filename);
record.append("Tempname", this->tempname);
record.append("curhash", this->recentHash);
record.append("ovhash", this->origHash);
record.append("length", this->length);
record.append("nversions", this->versionCount);
/* love you */ long long time = this->modifytime.tv_nsec;
record.append("Mtnsec", time);
time = this->modifytime.tv_sec;
record.append("mtsec", time);
record.append("currentversion", this->refNum);
mongo::BSONArrayBuilder bArr; //arrays to store multiple objects inside main object
mongo::BSONArrayBuilder Comments;
for (vector<string>::iterator it = blockhashes.begin(); it != blockhashes.end(); ++it) {
bArr.append(*it);
}
for (vector<comment>::iterator it = comments.begin(); it != comments.end(); ++it) {
BSONObjBuilder comment;
comment.append("version", it->version); //
comment.append("comment", it->comment);
Comments.append(comment.obj());
}
if (!versions.empty()) { //if there are id's in the versions collection
mongo::BSONArrayBuilder Version; //store the id's in an BSONarray
for (vector<string>::iterator it = versions.begin(); it != versions.end(); ++it) {
BSONObjBuilder version;
version.append("id", (*it));
Version.append(version.obj());
}
record.append("versionrec", Version.arr());
}
record.append("FileBlkHashes", bArr.arr()); //adding arrays to main record
record.append("comments", Comments.arr());
BSONObj result = record.obj();
auto_ptr<mongo::DBClientCursor> cursor = conn.query("fileRecords.Filerec", MONGO_QUERY("filename" << filename));
if (cursor->more()) {//already file rec in db so update
conn.update("fileRecords.Filerec", MONGO_QUERY("filename" << filename), result);
} else {
conn.insert("fileRecords.Filerec", result); //must be new record
}
string e = conn.getLastError();
if (!e.empty()) {
cout << "something failed failed: " << e << std::endl;
sleep(1);
exit(1);
}
else{
cout << "record " << this->refNum << " successfully written to database" << endl;
}
}
void
get_domains(set<string> &domains) {
auto_ptr<mongo::DBClientCursor> cur = mongo_conn.query("HTTP.trunc_hosts",
mongo::BSONObj());
while (cur->more()) {
mongo::BSONObj p = cur->next();
domains.insert(p.getStringField("value"));
}
}
/**********************************************************
*similar to writetodb in FileRec
*
***********************************************************/
void VersionRec::writeToDB(mongo::DBClientConnection& conn) {
BSONObjBuilder record;
if (this->versionid.empty()) { //if no id has been read in because it is a new version
record.genOID();//create one
} else {
mongo::OID theoid(this->versionid); //use current id
record.append("_id", theoid);
}
//convert to BSON
record.append("Tempname", this->tmpname);
record.append("filehash", this->filehash);
record.append("length", this->length);
record.append("Version", this->versionnumber);
/* love you */ long long time = this->modifytime.tv_nsec;
record.append("Mtnsec", time);
time = this->modifytime.tv_sec;
record.append("mtsec", time);
mongo::BSONArrayBuilder Version;
for (vector<VersionDiffBlock>::iterator it = changes.begin(); it != changes.end(); ++it) {
BSONObjBuilder version;
version.append("Blknum", (*it).blockNo);
version.append("hash", (*it).blockHash);
Version.append(version.obj());
}
record.append("Blktable", Version.arr());
BSONObj result = record.obj();
if (this->versionid.empty()) {
mongo::BSONElement thing;
result.getObjectID(thing);
mongo::OID anoid = thing.OID();
this->versionid = anoid.toString();
}
auto_ptr<mongo::DBClientCursor> cursor = conn.query("fileRecords.FileVersion", MONGO_QUERY("_id" << mongo::OID(this->versionid)));
if (cursor->more()) {//already a version with same id, update
conn.update("fileRecords.FileVersion", MONGO_QUERY("_id" << mongo::OID(this->versionid)), result);
} else { //new version
conn.insert("fileRecords.FileVersion", result);
}
string e = conn.getLastError();
if (!e.empty()) {
cout << "something failed failed: " << e << std::endl;
sleep(1);
exit(1);
}
else{
cout << "Version " << this->versionnumber << " successfully written to database" << endl;
}
}
/**********************************************************
*reads from db and converts bson to FileRec object
*
***********************************************************/
void FileRec::readFromDB(mongo::DBClientConnection& conn, string filename) {
boost::filesystem::path p(filename); //get filename from path
string file(p.filename().c_str());
auto_ptr<mongo::DBClientCursor> cursor = conn.query("fileRecords.Filerec", MONGO_QUERY("filename" << file));
if (cursor->more()) {
BSONObj record = cursor->next();
//get data from db and store in the FileRec
this->filename = record.getStringField("filename");
this->tempname = record.getStringField("Tempname");
this->recentHash = record.getStringField("curhash");
this->origHash = record.getStringField("ovhash");
this->length = record.getIntField("length");
this->versionCount = record.getIntField("nversions");
this->modifytime.tv_nsec = record.getField("Mtnsec").numberLong();
this->modifytime.tv_sec = record.getField("mtsec").numberLong();
this->refNum = record.getIntField("currentversion");
vector<BSONElement> hashes(record.getField("FileBlkHashes").Array());
for (vector<BSONElement>::iterator it = hashes.begin(); it != hashes.end(); ++it) {
appendBlock((*it).String());
}
//comments is an array of objects so it takes a bit of nesting to convert
vector<BSONElement> array = record["comments"].Array(); //convert to array
for (vector<BSONElement>::iterator ar = array.begin(); ar != array.end(); ++ar) {
BSONObj commentdata = ar->Obj(); //store object at array[x] into BSONObj
BSONElement version = commentdata.getField("version"); //convert
BSONElement commentdb = commentdata.getField("comment");
comment data;
data.comment = commentdb.String();
data.version = version.Int();
appendComment(data);
}
if (record.hasElement("versionrec")) { //again an array of objects
vector<BSONElement> array = record["versionrec"].Array();
for (vector<BSONElement>::iterator it = array.begin(); it != array.end(); ++it) {
BSONObj versionRecord = it->Obj();
BSONElement id = versionRecord.getField("id");
appendVersion(id.String());
}
}
}
}
int query_record(mongo::DBClientConnection &conn, const string &fu_name, const string &field_name, const T &field_value){
mongo::BSONObjBuilder query;
query.append( field_name, field_value);
std::auto_ptr<mongo::DBClientCursor> cursor = conn.query( fu_name, query.obj() );
if (!cursor.get()) {
cout << "query failure" << endl;
return 0;
}
int count=0;
while ( cursor->more() ) {
mongo::BSONObj obj = cursor->next();
count++;
//cout << "\t" << obj.jsonString() << endl;
}
return count;
}
mongo::auto_ptr<mongo::DBClientCursor> find(std::string collection, mongo::BSONObj criteria) {
return msci.query("db." + collection, criteria);
}