bool run(const char *ns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool){
string dbName = getDBName( ns );
string collection = cmdObj.firstElement().valuestrsafe();
string fullns = dbName + "." + collection;
BSONObj filter = cmdObj["query"].embeddedObject();
DBConfig * conf = grid.getDBConfig( dbName , false );
if ( ! conf || ! conf->isShardingEnabled() || ! conf->isSharded( fullns ) ){
ScopedDbConnection conn( conf->getPrimary() );
result.append( "n" , (double)conn->count( fullns , filter ) );
conn.done();
result.append( "ok" , 1 );
return true;
}
ChunkManager * cm = conf->getChunkManager( fullns );
massert( "how could chunk manager be null!" , cm );
vector<Chunk*> chunks;
cm->getChunksForQuery( chunks , filter );
unsigned long long total = 0;
for ( vector<Chunk*>::iterator i = chunks.begin() ; i != chunks.end() ; i++ ){
Chunk * c = *i;
total += c->countObjects();
}
result.append( "n" , (double)total );
result.append( "ok" , 1 );
return true;
}
void TorrentFile::updateNumDownloadedChunks(ChunkManager & cman)
{
const BitSet & bs = cman.getBitSet();
Uint32 old_chunk_count = num_chunks_downloaded;
num_chunks_downloaded = 0;
Uint32 preview_range = cman.previewChunkRangeSize(*this);
bool prev = preview;
preview = true;
for (Uint32 i = first_chunk;i <= last_chunk;i++)
{
if (bs.get(i))
{
num_chunks_downloaded++;
}
else if (preview_range > 0 && i >= first_chunk && i < first_chunk + preview_range)
{
preview = false;
}
}
preview = isMultimedia() && preview;
if (num_chunks_downloaded != old_chunk_count)
tor->filePercentageChanged(this,getDownloadPercentage());
if (prev != preview)
tor->filePreviewChanged(this,preview);
}
bool run(const char *ns, BSONObj& cmdObj, string& errmsg, BSONObjBuilder& result, bool){
string dbName = getDBName( ns );
string collection = cmdObj.firstElement().valuestrsafe();
string fullns = dbName + "." + collection;
DBConfig * conf = grid.getDBConfig( dbName , false );
if ( ! conf || ! conf->isShardingEnabled() || ! conf->isSharded( fullns ) ){
return passthrough( conf , cmdObj , result );
}
ChunkManager * cm = conf->getChunkManager( fullns );
massert( "how could chunk manager be null!" , cm );
vector<Chunk*> chunks;
cm->getChunksForQuery( chunks , BSONObj() );
set<BSONObj,BSONObjCmp> all;
int size = 32;
for ( vector<Chunk*>::iterator i = chunks.begin() ; i != chunks.end() ; i++ ){
Chunk * c = *i;
ScopedDbConnection conn( c->getShard() );
BSONObj res;
bool ok = conn->runCommand( conf->getName() , cmdObj , res );
conn.done();
if ( ! ok ){
result.appendElements( res );
return false;
}
BSONObjIterator it( res["values"].embeddedObjectUserCheck() );
while ( it.more() ){
BSONElement nxt = it.next();
BSONObjBuilder temp(32);
temp.appendAs( nxt , "x" );
all.insert( temp.obj() );
}
}
BSONObjBuilder b( size );
int n=0;
for ( set<BSONObj,BSONObjCmp>::iterator i = all.begin() ; i != all.end(); i++ ){
b.appendAs( i->firstElement() , b.numStr( n++ ).c_str() );
}
result.appendArray( "values" , b.obj() );
result.append( "ok" , 1 );
return true;
}
void run() {
ChunkManager chunkManager;
chunkManager.setShardKey( shardKey() );
chunkManager.setSingleChunkForShards( splitPointsVector() );
set<Shard> shards;
chunkManager.getShardsForQuery( shards, query() );
BSONArrayBuilder b;
for( set<Shard>::const_iterator i = shards.begin(); i != shards.end(); ++i ) {
b << i->getName();
}
ASSERT_EQUALS( expectedShardNames(), b.arr() );
}
void draw(RenderWindow *window) {
window->setView(view);
window->clear(Color(143, 178, 255));
chunkManager.draw(window);
window->draw(player);
window->display();
}
Uint32 PeerUploader::handleRequests(ChunkManager & cman)
{
Uint32 ret = uploaded;
uploaded = 0;
// if we have choked the peer do not upload
if (peer->areWeChoked())
return ret;
while (requests.size() > 0)
{
Request r = requests.front();
Chunk* c = cman.getChunk(r.getIndex());
if (c && c->getStatus() == Chunk::ON_DISK)
{
if (!peer->sendChunk(r.getIndex(),r.getOffset(),r.getLength(),c))
{
if (peer->getStats().fast_extensions)
peer->sendReject(r);
}
}
else
{
// remove requests we can't satisfy
Out(SYS_CON|LOG_DEBUG) << "Cannot satisfy request" << endl;
if (peer->getStats().fast_extensions)
peer->sendReject(r);
}
requests.pop_front();
}
return ret;
}
void DistributionStatus::populateShardToChunksMap(const vector<Shard>& allShards,
const ChunkManager& chunkMgr,
ShardToChunksMap* shardToChunksMap) {
// Makes sure there is an entry in shardToChunksMap for every shard.
for (vector<Shard>::const_iterator it = allShards.begin();
it != allShards.end(); ++it) {
OwnedPointerVector<ChunkType>*& chunkList =
(*shardToChunksMap)[it->getName()];
if (chunkList == NULL) {
chunkList = new OwnedPointerVector<ChunkType>();
}
}
const ChunkMap& chunkMap = chunkMgr.getChunkMap();
for (ChunkMap::const_iterator it = chunkMap.begin(); it != chunkMap.end(); ++it) {
const ChunkPtr chunkPtr = it->second;
auto_ptr<ChunkType> chunk(new ChunkType());
chunk->setNS(chunkPtr->getns());
chunk->setMin(chunkPtr->getMin().getOwned());
chunk->setMax(chunkPtr->getMax().getOwned());
chunk->setJumbo(chunkPtr->isJumbo()); // TODO: is this reliable?
const string shardName(chunkPtr->getShard().getName());
chunk->setShard(shardName);
(*shardToChunksMap)[shardName]->push_back(chunk.release());
}
}
void handleInput(RenderWindow *window) {
// Mouse input
if (Mouse::isButtonPressed(Mouse::Left)) {
Vector2i globalMousePosition = Mouse::getPosition(*window)
+ Vector2i(view.getCenter().x - (screenSizeX / 2)
, view.getCenter().y - (screenSizeY / 2));
chunkManager.hitTile(globalMousePosition);
}
// Keyboard input
if (Keyboard::isKeyPressed(Keyboard::W)
|| Keyboard::isKeyPressed(Keyboard::Up)) {
player.walker->jump();
}
if (Keyboard::isKeyPressed(Keyboard::Space)) {
player.walker->jump();
}
if (Keyboard::isKeyPressed(Keyboard::S)
|| Keyboard::isKeyPressed(Keyboard::Down)) {
}
if (Keyboard::isKeyPressed(Keyboard::A)
|| Keyboard::isKeyPressed(Keyboard::Left)) {
player.walker->walk(false);
}
if (Keyboard::isKeyPressed(Keyboard::D)
|| Keyboard::isKeyPressed(Keyboard::Right)) {
player.walker->walk(true);
}
}
int main(int argc, const char** argv)
{
ChunkManager<uint32_t> storage;
vector<size_t> p(33);
for (int i = 1; i < p.size(); ++i) {
p[i] = storage.allocate(i);
cerr << "(" << p[i] << " " << storage.global_address(p[i]) << ") ";
}
cerr << endl;
vector< vector<size_t> > p2(33);
for (int i = 1; i < p2.size(); ++i) {
p2[i].resize(7);
for (int j = 0; j < p2[i].size(); ++j) {
p2[i][j] = storage.allocate(i);
cerr << "(" << p2[i][j] << " " << storage.global_address(p2[i][j]) << ") ";
}
cerr << endl;
}
for (int i = 1; i < p.size(); ++i) {
*reinterpret_cast<char*>(storage.global_address(p[i])) = i;
}
for (int i = 1; i < p.size(); ++i) {
cerr << *reinterpret_cast<int*>(storage.global_address(p[i])) << " ";
}
cerr << endl;
cerr << "deallocate" <<endl;
for (int i = 1; i < p2.size(); ++i) {
for (int j = 0; j < p2[i].size(); j+=2) {
cerr << i << " " << p2[i][j] << ", ";
storage.deallocate(p2[i][j]);
}
}
cerr << "p3:" << endl;
vector< vector<size_t> > p3(33);
for (int i = 1; i < p3.size(); ++i) {
p3[i].resize(10);
for (int j = 0; j < p3[i].size(); ++j) {
p3[i][j] = storage.allocate(i);
cerr << p3[i][j] << " ";
}
cerr << endl;
}
}
void handleIndexWrite( int op , Request& r ) {
DbMessage& d = r.d();
if ( op == dbInsert ) {
while( d.moreJSObjs() ) {
BSONObj o = d.nextJsObj();
const char * ns = o["ns"].valuestr();
if ( r.getConfig()->isSharded( ns ) ) {
BSONObj newIndexKey = o["key"].embeddedObjectUserCheck();
uassert( 10205 , (string)"can't use unique indexes with sharding ns:" + ns +
" key: " + o["key"].embeddedObjectUserCheck().toString() ,
IndexDetails::isIdIndexPattern( newIndexKey ) ||
! o["unique"].trueValue() ||
r.getConfig()->getChunkManager( ns )->getShardKey().uniqueAllowd( newIndexKey ) );
ChunkManager * cm = r.getConfig()->getChunkManager( ns );
assert( cm );
for ( int i=0; i<cm->numChunks(); i++)
doWrite( op , r , cm->getChunk(i)->getShard() );
}
else {
doWrite( op , r , r.primaryShard() );
}
r.gotInsert();
}
}
else if ( op == dbUpdate ) {
throw UserException( 8050 , "can't update system.indexes" );
}
else if ( op == dbDelete ) {
// TODO
throw UserException( 8051 , "can't delete indexes on sharded collection yet" );
}
else {
log() << "handleIndexWrite invalid write op: " << op << endl;
throw UserException( 8052 , "handleIndexWrite invalid write op" );
}
}
void DistributionStatus::populateShardToChunksMap(const ShardStatisticsVector& allShards,
const ChunkManager& chunkMgr,
ShardToChunksMap* shardToChunksMap) {
// Makes sure there is an entry in shardToChunksMap for every shard.
for (const auto& stat : allShards) {
(*shardToChunksMap)[stat.shardId];
}
const ChunkMap& chunkMap = chunkMgr.getChunkMap();
for (ChunkMap::const_iterator it = chunkMap.begin(); it != chunkMap.end(); ++it) {
const ChunkPtr chunkPtr = it->second;
ChunkType chunk;
chunk.setNS(chunkMgr.getns());
chunk.setMin(chunkPtr->getMin().getOwned());
chunk.setMax(chunkPtr->getMax().getOwned());
chunk.setJumbo(chunkPtr->isJumbo()); // TODO: is this reliable?
const string shardName(chunkPtr->getShardId());
chunk.setShard(shardName);
(*shardToChunksMap)[shardName].push_back(chunk);
}
}
void setupChunkManager() {
ChunkSettings chunkSettings;
chunkSettings.chunkSize = Vector2i(64, 64);
chunkSettings.tileSize = Vector2i(16, 16);
chunkSettings.tileTexSize = Vector2f(16, 16);
chunkSettings.tilesPerWidthTex = 4;
chunkSettings.scale = SCALE;
chunkSettings.world = &world;
WorldSettings worldSettings;
worldSettings.worldSize = Vector2i(16, 8);
worldSettings.chunkTexture = &blocksTexture;
worldSettings.chunkSettings = chunkSettings;
worldSizeX = chunkSettings.chunkSize.x * chunkSettings.tileSize.x * worldSettings.worldSize.x;
worldSizeY = chunkSettings.chunkSize.y * chunkSettings.tileSize.y * worldSettings.worldSize.y;
chunkManager.initialize(worldSettings);
}
void ChunkManager::_UpdatingChunksThread(void* pData)
{
ChunkManager* lpChunkManager = (ChunkManager*)pData;
lpChunkManager->UpdatingChunksThread();
}
virtual void queryOp( Request& r ){
QueryMessage q( r.d() );
log(3) << "shard query: " << q.ns << " " << q.query << endl;
if ( q.ntoreturn == 1 && strstr(q.ns, ".$cmd") )
throw UserException( 8010 , "something is wrong, shouldn't see a command here" );
ChunkManager * info = r.getChunkManager();
assert( info );
Query query( q.query );
vector<Chunk*> shards;
info->getChunksForQuery( shards , query.getFilter() );
set<ServerAndQuery> servers;
map<string,int> serverCounts;
for ( vector<Chunk*>::iterator i = shards.begin(); i != shards.end(); i++ ){
servers.insert( ServerAndQuery( (*i)->getShard() , (*i)->getFilter() ) );
int& num = serverCounts[(*i)->getShard()];
num++;
}
if ( logLevel > 4 ){
StringBuilder ss;
ss << " shard query servers: " << servers.size() << "\n";
for ( set<ServerAndQuery>::iterator i = servers.begin(); i!=servers.end(); i++ ){
const ServerAndQuery& s = *i;
ss << " " << s.toString() << "\n";
}
log() << ss.str();
}
ClusteredCursor * cursor = 0;
BSONObj sort = query.getSort();
if ( sort.isEmpty() ){
// 1. no sort, can just hit them in serial
cursor = new SerialServerClusteredCursor( servers , q );
}
else {
int shardKeyOrder = info->getShardKey().canOrder( sort );
if ( shardKeyOrder ){
// 2. sort on shard key, can do in serial intelligently
set<ServerAndQuery> buckets;
for ( vector<Chunk*>::iterator i = shards.begin(); i != shards.end(); i++ ){
Chunk * s = *i;
buckets.insert( ServerAndQuery( s->getShard() , s->getFilter() , s->getMin() ) );
}
cursor = new SerialServerClusteredCursor( buckets , q , shardKeyOrder );
}
else {
// 3. sort on non-sharded key, pull back a portion from each server and iterate slowly
cursor = new ParallelSortClusteredCursor( servers , q , sort );
}
}
assert( cursor );
log(5) << " cursor type: " << cursor->type() << endl;
ShardedClientCursor * cc = new ShardedClientCursor( q , cursor );
if ( ! cc->sendNextBatch( r ) ){
delete( cursor );
return;
}
log(6) << "storing cursor : " << cc->getId() << endl;
cursorCache.store( cc );
}
// TODO: Should this go in chunkManager?
bool castRay(const Camera& camera, const ChunkManager& chunkManager, Coordinate& currentBlock, Coordinate& lastBlock)
{
glm::vec3 current = camera.eye;
glm::vec3 gaze = camera.gaze();
currentBlock = current;
glm::vec3 fractional = glm::fract(current);
// The direction of travel, in block coordinates
Coordinate step(glm::sign(gaze));
// The distance along gaze between consecutive blocks boundary
glm::vec3 delta = glm::length(gaze) / glm::abs(gaze);
// The distance along gaze to the first block boundary
glm::vec3 distance;
distance.x = gaze.x < 0 ? fractional.x : 1 - fractional.x;
distance.y = gaze.y < 0 ? fractional.y : 1 - fractional.y;
distance.z = gaze.z < 0 ? fractional.z : 1 - fractional.z;
distance *= delta;
do
{
// Travel the smallest distance necessary to hit the next block
// Intersects x-wall first
if (distance.x <= distance.y && distance.x <= distance.z)
{
lastBlock = currentBlock;
current += distance.x * gaze;
currentBlock.x += step.x;
distance -= glm::vec3(distance.x);
distance.x = delta.x;
}
else if (distance.y <= distance.x && distance.y <= distance.z)
{
lastBlock = currentBlock;
current += distance.y * gaze;
currentBlock.y += step.y;
distance -= glm::vec3(distance.y);
distance.y = delta.y;
}
else if (distance.z <= distance.x && distance.z <= distance.y)
{
lastBlock = currentBlock;
current += distance.z * gaze;
currentBlock.z += step.z;
distance -= glm::vec3(distance.z);
distance.z = delta.z;
}
else
{
// Numerical error?
assert(false);
}
// Only look for intersections within a certain range of the camera
if (glm::length(current - camera.eye) > MAX_TARGET_DISTANCE)
return false;
} while (chunkManager.isTransparent(currentBlock));
return true;
}
bool ChunkManager::compatibleWith(const ChunkManager& other, const string& shardName) const {
// Return true if the shard version is the same in the two chunk managers
// TODO: This doesn't need to be so strong, just major vs
return other.getVersion(shardName).equals(getVersion(shardName));
}
void update(RenderWindow *window) {
chunkManager.update(&view);
player.update();
view.setCenter(player.getPosition());
}
void ChunkManager::_UpdateChunksThread(void* pData) {
ChunkManager* chunkManager = (ChunkManager*)pData;
chunkManager->UpdateChunksThread();
}
void Player::update(float32 deltaSeconds)
{
const static float32 JUMP_POWER = 7.0f;
const static float32 SPEED = 5.0f;
const static float32 ROTATE_SPEED = 0.01f;
const static int MAX_JUMP_FRAMES = 15;
m_currentPosition = glm::vec3(transform.xPos, transform.yPos, transform.zPos);
m_lastPosition = m_currentPosition;
// Get current chunk
ChunkManager* cm = ChunkManager::instance();
m_chunkValid = cm->getChunkHandle(cm->getCurrentChunk(m_currentPosition), m_currentChunk);
// DONT UPDATE ME IF MY CHUNK ISNT VALID YET GOOOSH
if (!m_chunkValid) {
return;
}
static bool hasLanded = false;
float32 dx = 0;
float32 dy = 0;
float32 dz = 0;
if (m_forwardPressed) {
--dz;
}
if (m_backwardPressed) {
++dz;
}
if (m_leftPressed) {
--dx;
}
if (m_rightPressed) {
++dx;
}
glm::vec3 displacement = glm::rotate(transform.rotation, glm::vec3(dx, 0, dz));
displacement.y = 0;
displacement = glm::normalize(displacement);
displacement *= SPEED * deltaSeconds;
// Numerical approximation via Euler Integration
dy = m_velocityY * deltaSeconds;
m_velocityY += GRAVITY * deltaSeconds;
//displacement.y = dy;
//transform.translate(displacement);
if (dx || dz) {
transform.translate(displacement);
}
if (!m_glueToGround) {
transform.translate(0, dy, 0);
}
if (dx || (dy && !m_glueToGround) || dz) {
m_movedDuringFrame = true;
}
else {
m_movedDuringFrame = false;
}
//transform.translateLocal(dx, 0, dz);
//transform.translate(0, dy, 0);
// Apply jump
if (m_jumpPressed) {
// Apply impulse and cancel gravity
m_velocityY = JUMP_POWER;
m_jumpPressed = false;
m_glueToGround = false;
}
//if (m_jumpPressed) {
// if (!m_isJumping && hasLanded)
// {
// m_isJumping = true;
// hasLanded = false;
// }
//}
//
//if(m_ready && !m_isJumping)
// dy += GRAVITY * deltaSeconds;
//else if (m_ready && m_isJumping)
//{
// dy -= GRAVITY * deltaSeconds;
// m_jumpedFrames++;
//
// if (m_jumpedFrames > MAX_JUMP_FRAMES)
// {
// m_jumpedFrames = 0;
// m_isJumping = false;
// }
//}
glm::vec3 deltaPos(dx, dy, dz);
deltaPos = (glm::normalize(deltaPos) * SPEED * deltaSeconds);
// if you are in the water (below it), move half as much per frame
if (m_currentPosition.y < m_swimY)
deltaPos = glm::clamp(deltaPos, -0.45f, 0.45f);
else
deltaPos = glm::clamp(deltaPos, -0.9f, 0.9f);
//Check if the chunk you are in has changed
//checkChunk();
//
//glm::vec3 newPosition = glm::vec3(transform.xPos + deltaPos.x, transform.yPos + deltaPos.y, transform.zPos + deltaPos.z);
//
//Collision coll = checkForSurroundingBlocks(newPosition);
//
//switch (coll)
//{
//case(Collision::Colliding):
// std::cout << "Colliding" << std::endl;
// hasLanded = true;
// break;
//case(Collision::NoCollision):
// if (dx != 0 || dy != 0 || dz != 0)
// transform.translateLocal(deltaPos.x, deltaPos.y, deltaPos.z);
// break;
//case(Collision::CollidingNotY):
// if (dx != 0 || dz != 0)
// transform.translateLocal(deltaPos.x, 0.0f, deltaPos.z);
// hasLanded = true;
// break;
//case(Collision::NoCollisionUpOne):
// if (dx != 0 || dz != 0)
// transform.translateLocal(deltaPos.x, 1.0f, deltaPos.z);
// hasLanded = true;
// break;
//}
/*
Collision coll = checkForShubbery(newPosition);
if (coll)
{
// congrats you hit a tree...
switch (coll)
{
case(Collision::Colliding):
hasLanded = true;
break;
case(Collision::CollidingXZ):
if (dy != 0)
transform.translateLocal(0.0f, deltaPos.y, 0.0f);
break;
}
}
else
{
coll = checkForSurroundingBlocks(newPosition);
switch (coll)
{
case(Collision::Colliding):
std::cout << "Colliding" << std::endl;
hasLanded = true;
break;
case(Collision::NoCollision):
if (dx != 0 || dy != 0 || dz != 0)
transform.translateLocal(deltaPos.x, deltaPos.y, deltaPos.z);
break;
case(Collision::CollidingNotY):
if (dx != 0 || dz != 0)
transform.translateLocal(deltaPos.x, 0.0f, deltaPos.z);
hasLanded = true;
break;
case(Collision::NoCollisionUpOne):
if (dx != 0 || dz != 0)
transform.translateLocal(deltaPos.x, 1.0f, deltaPos.z);
hasLanded = true;
break;
}
}
*/
// update the camera's transform
m_camera->transform.xPos = transform.xPos;
m_camera->transform.yPos = transform.yPos + 1.0f;
m_camera->transform.zPos = transform.zPos;
glm::vec2 mouseAxis = getMouseAxis() * ROTATE_SPEED;
if (true) {
if (abs(mouseAxis.x) > abs(mouseAxis.y)) {
mouseAxis.y = 0;
}
else {
mouseAxis.x = 0;
}
transform.rotate(0, -mouseAxis.x, 0);
m_camera->transform.rotateLocal(mouseAxis.y, 0, 0);
m_camera->transform.rotate(0, -mouseAxis.x, 0);
}
m_currentPosition = glm::vec3(transform.xPos, transform.yPos, transform.zPos);
if (m_movedDuringFrame) {
processCollision();
}
}
