Status MultiIndexBlock::insertAllDocumentsInCollection(std::set<DiskLoc>* dupsOut) {
const char* curopMessage = _buildInBackground ? "Index Build (background)" : "Index Build";
ProgressMeter* progress = _txn->setMessage(curopMessage,
curopMessage,
_collection->numRecords(_txn));
Timer t;
unsigned long long n = 0;
scoped_ptr<PlanExecutor> exec(InternalPlanner::collectionScan(_txn,
_collection->ns().ns(),
_collection));
BSONObj objToIndex;
DiskLoc loc;
while (PlanExecutor::ADVANCED == exec->getNext(&objToIndex, &loc)) {
{
bool shouldCommitWUnit = true;
WriteUnitOfWork wunit(_txn);
Status ret = insert(objToIndex, loc);
if (!ret.isOK()) {
if (dupsOut && ret.code() == ErrorCodes::DuplicateKey) {
// If dupsOut is non-null, we should only fail the specific insert that
// led to a DuplicateKey rather than the whole index build.
dupsOut->insert(loc);
shouldCommitWUnit = false;
}
else {
return ret;
}
}
if (shouldCommitWUnit)
wunit.commit();
}
n++;
progress->hit();
if (_allowInterruption)
_txn->checkForInterrupt();
progress->setTotalWhileRunning( _collection->numRecords(_txn) );
}
progress->finished();
Status ret = doneInserting(dupsOut);
if (!ret.isOK())
return ret;
log() << "build index done. scanned " << n << " total records. "
<< t.seconds() << " secs" << endl;
return Status::OK();
}
optional<string> FileSharing::download(const string& filename, const string& dir, ProgressMeter& meter) {
progressFun = [&] (double p) { meter.setProgress(p);};
if (CURL *curl = curl_easy_init()) {
string path = dir + "/" + filename;
Debug() << "Downloading to " << path;
if (FILE *fp = fopen(path.c_str(), "wb")) {
curl_easy_setopt(curl, CURLOPT_URL, escapeUrl(uploadUrl + "/uploads/" + filename).c_str());
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeToFile);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
// Internal CURL progressmeter must be disabled if we provide our own callback
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, false);
// Install the callback function
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, progressFunction);
curl_easy_setopt(curl, CURLOPT_FAILONERROR, true);
CURLcode res = curl_easy_perform(curl);
string ret;
if(res != CURLE_OK)
ret = string("Upload failed: ") + curl_easy_strerror(res);
curl_easy_cleanup(curl);
fclose(fp);
if (!ret.empty()) {
remove(path.c_str());
return ret;
} else
return none;
} else
return string("Failed to open file: " + path);
} else
return string("Failed to initialize libcurl");
}
void lookForRunsBelowTargetWeight(const KeccakFPropagation& DCorLC, ostream& out,
unsigned int targetWeight, ParityAsRuns& parity, ProgressMeter& progress, bool verbose)
{
unsigned int lowerBound;
unsigned int weightBoundBasedOnTotalHammingWeight = getBoundOfTotalWeightGivenTotalHammingWeight(DCorLC,
parity.getLowerBoundTotalHammingWeight(DCorLC));
if (weightBoundBasedOnTotalHammingWeight <= targetWeight) {
unsigned int minActiveRows = parity.getLowerBoundTotalActiveRowsUsingOnlyAC(DCorLC);
lowerBound = max(minActiveRows*2, weightBoundBasedOnTotalHammingWeight);
}
else
lowerBound = weightBoundBasedOnTotalHammingWeight;
if (lowerBound <= targetWeight) {
unsigned int thisOneLowerBound = parity.getLowerBoundTotalActiveRows(DCorLC)*2;
if (thisOneLowerBound <= targetWeight) {
vector<RowValue> C, D;
parity.toParityAndParityEffect(DCorLC, C, D);
unsigned int thisOneLowerBoundAgain = getLowerBoundTotalActiveRows(DCorLC, C, D)*2;
if (thisOneLowerBoundAgain <= targetWeight) {
if (verbose) {
displayParity(cout, C, D);
cout << "Lower bound = " << dec << max(thisOneLowerBound, thisOneLowerBoundAgain) << endl;
cout << endl;
}
vector<RowValue> Cmin;
getSymmetricMinimum(C, Cmin);
writeParity(out, Cmin);
}
}
progress.stack("Adding runs to "+parity.display());
for(unsigned int tStart=parity.runs.back().tStart+parity.runs.back().length+1;
tStart<DCorLC.laneSize*5; tStart++) {
unsigned int maxLength = DCorLC.laneSize*5-1-tStart+parity.runs[0].tStart;
for(unsigned int length=1; length<=maxLength; length++) {
Run run;
run.tStart = tStart;
run.length = length;
parity.runs.push_back(run);
lookForRunsBelowTargetWeight(DCorLC, out, targetWeight, parity, progress, verbose);
parity.runs.pop_back();
++progress;
}
}
progress.unstack();
}
}
void lookForRunsBelowTargetWeight(const KeccakFPropagation& DCorLC, ostream& out, unsigned int targetWeight, bool verbose)
{
ProgressMeter progress;
progress.stack("Initial run starting point", 5);
for(unsigned int tStart=0; tStart<5; tStart++) {
progress.stack("Initial run length", DCorLC.laneSize*5-1);
for(unsigned int length=1; length<=DCorLC.laneSize*5-1; length++) {
ParityAsRuns parity;
Run run;
run.tStart = tStart;
run.length = length;
parity.runs.push_back(run);
lookForRunsBelowTargetWeight(DCorLC, out, targetWeight, parity, progress, verbose);
++progress;
}
progress.unstack();
++progress;
}
progress.unstack();
}
optional<string> FileSharing::uploadSite(const string& path, ProgressMeter& meter) {
if (!options.getBoolValue(OptionId::ONLINE))
return none;
static ProgressCallback callback = [&] (double p) { meter.setProgress(p);};
return curlUpload(path.c_str(), (uploadUrl + "/upload_site.php").c_str(), &callback, 0);
}
virtual void subthread(int tnumber) {
Client::initThread("mongomutextest");
const ServiceContext::UniqueOperationContext txnPtr = cc().makeOperationContext();
OperationContext& txn = *txnPtr;
sleepmillis(0);
for (int i = 0; i < N; i++) {
int x = std::rand();
bool sometimes = (x % 15 == 0);
if (i % 7 == 0) {
Lock::GlobalRead r(txn.lockState()); // nested test
Lock::GlobalRead r2(txn.lockState());
} else if (i % 7 == 1) {
Lock::GlobalRead r(txn.lockState());
ASSERT(txn.lockState()->isReadLocked());
} else if (i % 7 == 4 && tnumber == 1 /*only one upgrader legal*/) {
Lock::GlobalWrite w(txn.lockState());
ASSERT(txn.lockState()->isW());
if (i % 7 == 2) {
Lock::TempRelease t(txn.lockState());
}
} else if (i % 7 == 2) {
Lock::GlobalWrite w(txn.lockState());
ASSERT(txn.lockState()->isW());
if (sometimes) {
Lock::TempRelease t(txn.lockState());
}
} else if (i % 7 == 3) {
Lock::GlobalWrite w(txn.lockState());
{ Lock::TempRelease t(txn.lockState()); }
Lock::GlobalRead r(txn.lockState());
ASSERT(txn.lockState()->isW());
if (sometimes) {
Lock::TempRelease t(txn.lockState());
}
} else if (i % 7 == 5) {
{
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock r(txn.lockState(), "foo", MODE_S);
}
{
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock r(txn.lockState(), "bar", MODE_S);
}
} else if (i % 7 == 6) {
if (i > N / 2) {
int q = i % 11;
if (q == 0) {
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock r(txn.lockState(), "foo", MODE_S);
ASSERT(txn.lockState()->isDbLockedForMode("foo", MODE_S));
Lock::DBLock r2(txn.lockState(), "foo", MODE_S);
ASSERT(txn.lockState()->isDbLockedForMode("foo", MODE_S));
Lock::DBLock r3(txn.lockState(), "local", MODE_S);
ASSERT(txn.lockState()->isDbLockedForMode("foo", MODE_S));
ASSERT(txn.lockState()->isDbLockedForMode("local", MODE_S));
} else if (q == 1) {
// test locking local only -- with no preceding lock
{
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock x(txn.lockState(), "local", MODE_S);
}
{
ScopedTransaction scopedXact(&txn, MODE_IX);
Lock::DBLock x(txn.lockState(), "local", MODE_X);
// No actual writing here, so no WriteUnitOfWork
if (sometimes) {
Lock::TempRelease t(txn.lockState());
}
}
} else if (q == 1) {
{
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock x(txn.lockState(), "admin", MODE_S);
}
{
ScopedTransaction scopedXact(&txn, MODE_IX);
Lock::DBLock x(txn.lockState(), "admin", MODE_X);
}
} else if (q == 3) {
ScopedTransaction scopedXact(&txn, MODE_IX);
Lock::DBLock x(txn.lockState(), "foo", MODE_X);
Lock::DBLock y(txn.lockState(), "admin", MODE_S);
} else if (q == 4) {
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock x(txn.lockState(), "foo2", MODE_S);
Lock::DBLock y(txn.lockState(), "admin", MODE_S);
} else {
ScopedTransaction scopedXact(&txn, MODE_IX);
Lock::DBLock w(txn.lockState(), "foo", MODE_X);
{ Lock::TempRelease t(txn.lockState()); }
Lock::DBLock r2(txn.lockState(), "foo", MODE_S);
Lock::DBLock r3(txn.lockState(), "local", MODE_S);
}
} else {
ScopedTransaction scopedXact(&txn, MODE_IS);
Lock::DBLock r(txn.lockState(), "foo", MODE_S);
Lock::DBLock r2(txn.lockState(), "foo", MODE_S);
Lock::DBLock r3(txn.lockState(), "local", MODE_S);
}
}
pm.hit();
}
}
unsigned long long addExistingToIndex( OperationContext* txn,
Collection* collection,
const IndexDescriptor* descriptor,
IndexAccessMethod* accessMethod,
bool canBeKilled ) {
string ns = collection->ns().ns(); // our copy for sanity
bool dupsAllowed = !descriptor->unique();
bool dropDups = descriptor->dropDups();
string curopMessage;
{
stringstream ss;
ss << "Index Build";
if ( canBeKilled )
ss << "(background)";
curopMessage = ss.str();
}
ProgressMeter* progress = txn->setMessage(curopMessage.c_str(),
curopMessage,
collection->numRecords());
unsigned long long n = 0;
unsigned long long numDropped = 0;
auto_ptr<Runner> runner(InternalPlanner::collectionScan(ns,collection));
std::string idxName = descriptor->indexName();
// After this yields in the loop, idx may point at a different index (if indexes get
// flipped, see insert_makeIndex) or even an empty IndexDetails, so nothing below should
// depend on idx. idxNo should be recalculated after each yield.
BSONObj js;
DiskLoc loc;
while (Runner::RUNNER_ADVANCED == runner->getNext(&js, &loc)) {
try {
if ( !dupsAllowed && dropDups ) {
LastError::Disabled led( lastError.get() );
addKeysToIndex(txn, collection, descriptor, accessMethod, js, loc);
}
else {
addKeysToIndex(txn, collection, descriptor, accessMethod, js, loc);
}
}
catch( AssertionException& e ) {
if (ErrorCodes::isInterruption(DBException::convertExceptionCode(e.getCode()))) {
txn->checkForInterrupt();
}
// TODO: Does exception really imply dropDups exception?
if (dropDups) {
bool runnerEOF = runner->isEOF();
runner->saveState();
BSONObj toDelete;
collection->deleteDocument( txn, loc, false, true, &toDelete );
repl::logOp(txn, "d", ns.c_str(), toDelete);
if (!runner->restoreState(txn)) {
// Runner got killed somehow. This probably shouldn't happen.
if (runnerEOF) {
// Quote: "We were already at the end. Normal.
// TODO: Why is this normal?
}
else {
uasserted(ErrorCodes::CursorNotFound,
"cursor gone during bg index; dropDups");
}
break;
}
// We deleted a record, but we didn't actually yield the dblock.
// TODO: Why did the old code assume we yielded the lock?
numDropped++;
}
else {
log() << "background addExistingToIndex exception " << e.what() << endl;
throw;
}
}
n++;
progress->hit();
txn->recoveryUnit()->commitIfNeeded();
if (canBeKilled) {
// Checking for interrupt here is necessary because the bg index
// interruptors can only interrupt this index build while they hold
// a write lock, and yieldAndCheckIfOK only checks for
// interrupt prior to yielding our write lock. We need to check the kill flag
// here before another iteration of the loop.
txn->checkForInterrupt();
}
progress->setTotalWhileRunning( collection->numRecords() );
}
progress->finished();
if ( dropDups && numDropped )
log() << "\t index build dropped: " << numDropped << " dups";
return n;
}
optional<string> FileSharing::uploadRetired(const string& path, ProgressMeter& meter) {
progressFun = [&] (double p) { meter.setProgress(p);};
return curlUpload(path.c_str(), (uploadUrl + "/upload.php").c_str());
}
BOOL CALLBACK Proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg) {
case WM_INITDIALOG: {
Rect wr;
SystemParametersInfo(SPI_GETWORKAREA, 0, wr, 0);
Rect dr;
GetWindowRect(hwnd, dr);
Point p = wr.CenterPos(dr.Size());
SetWindowPos(hwnd, 0, p.x, p.y, dr.Width(), dr.Height(),
SWP_SHOWWINDOW|SWP_NOOWNERZORDER|SWP_NOZORDER);
SetWindowText(GetDlgItem(hwnd, 101), "C:\\upp");
SendDlgItemMessage(hwnd, 101, EM_SETSEL, (WPARAM) 0, (LPARAM) -1);
SetWindowText(hwnd, GetExeTitle());
break;
}
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDOK: {
char h[2048];
GetWindowText(GetDlgItem(hwnd, 101), h, 2048);
String exe = AppendFileName(h, "theide.exe");
if(FileExists(exe)) {
MessageBox(::GetActiveWindow(),
"Please uninstall previous version before installing the new one.",
"Ultimate++", MB_ICONSTOP | MB_OK | MB_APPLMODAL);
WinExec(exe + " -uninstall", SW_SHOWNORMAL);
break;
}
ProgressMeter pi;
pi.SetText("Installing files");
HRSRC hrsrc = FindResource(NULL, LPCTSTR(1112), RT_RCDATA);
if(!hrsrc) Error();
outdir = h;
LZMAExtract((const char *)LockResource(LoadResource(NULL, hrsrc)), SizeofResource(NULL, hrsrc),
h, pi);
if (BST_CHECKED == SendDlgItemMessage(hwnd, 10 /*IDC_ASSOC*/, BM_GETCHECK, 0, 0)) {
SetWinRegString(exe, "", "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\theide.exe\\");
SetWinRegString(h, "Path", "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\theide.exe\\");
SetWinRegString("TheIDE.upp", "", ".upp\\", HKEY_CLASSES_ROOT);
SetWinRegString("open", "", "TheIDE.upp\\shell\\", HKEY_CLASSES_ROOT);
SetWinRegString("\"" + exe + "\" \"%1\"", "", "TheIDE.upp\\shell\\open\\command\\", HKEY_CLASSES_ROOT);
}
pi.Destroy();
FileMove(AppendFileName(h, IsWow64() ? "theide64.exe" : "theide32.exe"), exe);
EndDialog(hwnd, 0);
WinExec(exe, SW_SHOWNORMAL);
break;
}
case 999: {
BOOL retVal;
char Folder[256] = "C:\\";
char FolderName[17] = "Select Directory";
if(BrowseFolder( 0, Folder, FolderName)) {
strcat(Folder, "\\upp");
SetWindowText(GetDlgItem(hwnd, 101), Folder);
}
break;
}
case IDCANCEL:
EndDialog(hwnd, 0);
break;
}
}
return 0;
}
