Esempio n. 1
0
    void Applier::_callback(const ReplicationExecutor::CallbackData& cbd) {
        if (!cbd.status.isOK()) {
            _finishCallback(cbd.status, _operations);
            return;
        }

        invariant(cbd.txn);

        // Refer to multiSyncApply() and multiInitialSyncApply() in sync_tail.cpp.
        cbd.txn->setReplicatedWrites(false);

        // allow us to get through the magic barrier
        cbd.txn->lockState()->setIsBatchWriter(true);

        Status applyStatus(ErrorCodes::InternalError, "not mutated");

        invariant(!_operations.empty());
        for (auto i = _operations.cbegin(); i != _operations.cend(); ++i) {
            try {
                applyStatus = _applyOperation(cbd.txn, *i);
            }
            catch (...) {
                applyStatus = exceptionToStatus();
            }
            if (!applyStatus.isOK()) {
                // 'i' points to last operation that was not applied.
                _finishCallback(applyStatus, Operations(i, _operations.cend()));
                return;
            }
        }
        _finishCallback(_operations.back().getField("ts").timestamp(), Operations());
    }
Esempio n. 2
0
// TODO change the passed in function to be multiapply instead of apply inlock
void MultiApplier::_callback(const ReplicationExecutor::CallbackArgs& cbd) {
    if (!cbd.status.isOK()) {
        _finishCallback(cbd.status, _operations);
        return;
    }

    invariant(cbd.txn);

    // Refer to multiSyncApply() and multiInitialSyncApply() in sync_tail.cpp.
    cbd.txn->setReplicatedWrites(false);

    // allow us to get through the magic barrier
    cbd.txn->lockState()->setIsBatchWriter(true);

    StatusWith<OpTime> applyStatus(ErrorCodes::InternalError, "not mutated");

    invariant(!_operations.empty());
    try {
        applyStatus = _multiApply(cbd.txn, _operations, _applyOperation);
    } catch (...) {
        applyStatus = exceptionToStatus();
    }
    if (!applyStatus.isOK()) {
        _finishCallback(applyStatus.getStatus(), _operations);
        return;
    }
    _finishCallback(applyStatus.getValue().getTimestamp(), Operations());
}
Esempio n. 3
0
bool BufferStream::CanRead() const
{
	if (MEDUSA_FLAG_HAS(Operations(), StreamDataOperation::Read))
	{
		return !IsEnd();
	}
	return false;
}
Esempio n. 4
0
bool HashStream::CanWrite() const
{
	if (MEDUSA_FLAG_HAS(Operations(), StreamDataOperation::Write))
	{
		return mSourceStream->CanWrite();
	}
	return false;
}
Esempio n. 5
0
int main(int argc, char *argv[]){
	list fileList, dirList;
	int i=0;
	char** fileArrayp = malloc(1024*sizeof(char*));
	char** dirArrayp = malloc(1024*sizeof(char*));
	while (i != 1024){
		fileArrayp[i]=malloc(NAME_MAX*sizeof(char));
		fileArrayp[i]="";
		dirArrayp[i]=malloc(NAME_MAX*sizeof(char));
		dirArrayp[i]="";
		i++;
	}
	int ell = 5; 
	scanDir(fileArrayp, dirArrayp, argv, argc);
    while (1) {
        Operations(fileArrayp, dirArrayp, &ell);
    }
}
Esempio n. 6
0
bool BufferStream::IsReadWrite() const
{
	return MEDUSA_FLAG_HAS(Operations(), StreamDataOperation::ReadWrite);

}
Esempio n. 7
0
bool BufferStream::CanWrite() const
{
	return MEDUSA_HAS_FLAG(Operations(), StreamDataOperation::Write);
}