class C {}
int main() {
class C c1, c2;
c1 = newC();
c2 = newC();
c1 = c2;
return 0;
}
class C {
int a;
int m(int b) {
return this.a + b;
}
}
int main() {
class C c;
int d;
c = newC();
c.a = 1;
d = c.m(1);
return 0;
}
bool ChunkManager::_load(ChunkMap& chunkMap,
set<ShardId>& shardIds,
ShardVersionMap* shardVersions,
const ChunkManager* oldManager) {
// Reset the max version, but not the epoch, when we aren't loading from the oldManager
_version = ChunkVersion(0, 0, _version.epoch());
// If we have a previous version of the ChunkManager to work from, use that info to reduce
// our config query
if (oldManager && oldManager->getVersion().isSet()) {
// Get the old max version
_version = oldManager->getVersion();
// Load a copy of the old versions
*shardVersions = oldManager->_shardVersions;
// Load a copy of the chunk map, replacing the chunk manager with our own
const ChunkMap& oldChunkMap = oldManager->getChunkMap();
// Could be v.expensive
// TODO: If chunks were immutable and didn't reference the manager, we could do more
// interesting things here
for (const auto& oldChunkMapEntry : oldChunkMap) {
shared_ptr<Chunk> oldC = oldChunkMapEntry.second;
shared_ptr<Chunk> newC(new Chunk(
this, oldC->getMin(), oldC->getMax(), oldC->getShardId(), oldC->getLastmod()));
newC->setBytesWritten(oldC->getBytesWritten());
chunkMap.insert(make_pair(oldC->getMax(), newC));
}
LOG(2) << "loading chunk manager for collection " << _ns
<< " using old chunk manager w/ version " << _version.toString() << " and "
<< oldChunkMap.size() << " chunks";
}
// Attach a diff tracker for the versioned chunk data
CMConfigDiffTracker differ(this);
differ.attach(_ns, chunkMap, _version, *shardVersions);
// Diff tracker should *always* find at least one chunk if collection exists
// Get the diff query required
auto diffQuery = differ.configDiffQuery();
std::vector<ChunkType> chunks;
uassertStatusOK(
grid.catalogManager()->getChunks(diffQuery.query, diffQuery.sort, boost::none, &chunks));
int diffsApplied = differ.calculateConfigDiff(chunks);
if (diffsApplied > 0) {
LOG(2) << "loaded " << diffsApplied << " chunks into new chunk manager for " << _ns
<< " with version " << _version;
// Add all existing shards we find to the shards set
for (ShardVersionMap::iterator it = shardVersions->begin(); it != shardVersions->end();) {
shared_ptr<Shard> shard = grid.shardRegistry()->getShard(it->first);
if (shard) {
shardIds.insert(it->first);
++it;
} else {
shardVersions->erase(it++);
}
}
return true;
} else if (diffsApplied == 0) {
// No chunks were found for the ns
warning() << "no chunks found when reloading " << _ns << ", previous version was "
<< _version;
// Set all our data to empty
chunkMap.clear();
shardVersions->clear();
_version = ChunkVersion(0, 0, OID());
return true;
} else { // diffsApplied < 0
bool allInconsistent = (differ.numValidDiffs() == 0);
if (allInconsistent) {
// All versions are different, this can be normal
warning() << "major change in chunk information found when reloading " << _ns
<< ", previous version was " << _version;
} else {
// Inconsistent load halfway through (due to yielding cursor during load)
// should be rare
warning() << "inconsistent chunks found when reloading " << _ns
<< ", previous version was " << _version << ", this should be rare";
}
// Set all our data to empty to be extra safe
chunkMap.clear();
shardVersions->clear();
_version = ChunkVersion(0, 0, OID());
return allInconsistent;
}
}
