TEST_F(DocumentSourceFacetTest, ShouldRejectNonArrayFacets) { auto ctx = getExpCtx(); auto spec = BSON("$facet" << BSON("a" << 1)); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = BSON("$facet" << BSON("a" << BSON_ARRAY(BSON("$skip" << 4)) << "b" << 2)); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); }
TEST_F(DocumentSourceFacetTest, ShouldRejectFacetsWithStagesThatMustBeTheFirstStage) { auto ctx = getExpCtx(); auto spec = BSON("$facet" << BSON("a" << BSON_ARRAY(BSON("$indexStats" << BSONObj())))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = BSON("$facet" << BSON( "a" << BSON_ARRAY(BSON("$limit" << 1) << BSON("$indexStats" << BSONObj())))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); }
TEST_F(DocumentSourceFacetTest, ShouldRejectFacetsWithInvalidNames) { auto ctx = getExpCtx(); auto spec = BSON("$facet" << BSON("" << BSON_ARRAY(BSON("$skip" << 4)))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = BSON("$facet" << BSON("a.b" << BSON_ARRAY(BSON("$skip" << 4)))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = BSON("$facet" << BSON("$a" << BSON_ARRAY(BSON("$skip" << 4)))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); }
TEST_F(DocumentSourceFacetTest, ShouldRejectFacetsContainingAFacetStage) { auto ctx = getExpCtx(); auto spec = fromjson("{$facet: {a: [{$facet: {a: [{$skip: 2}]}}]}}"); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = fromjson("{$facet: {a: [{$skip: 2}, {$facet: {a: [{$skip: 2}]}}]}}"); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = fromjson("{$facet: {a: [{$skip: 2}], b: [{$facet: {a: [{$skip: 2}]}}]}}"); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); }
TEST_F(DocumentSourceFacetTest, ShouldAcceptLegalSpecification) { auto ctx = getExpCtx(); auto spec = BSON("$facet" << BSON("a" << BSON_ARRAY(BSON("$skip" << 4)) << "b" << BSON_ARRAY(BSON("$limit" << 3)))); auto facetStage = DocumentSourceFacet::createFromBson(spec.firstElement(), ctx); ASSERT_TRUE(facetStage.get()); }
TEST_F(DocumentSourceFacetTest, ShouldRejectFacetsContainingAnOutStage) { auto ctx = getExpCtx(); auto spec = BSON("$facet" << BSON("a" << BSON_ARRAY(BSON("$out" << "out_collection")))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = BSON("$facet" << BSON("a" << BSON_ARRAY(BSON("$skip" << 1) << BSON("$out" << "out_collection")))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); spec = BSON("$facet" << BSON("a" << BSON_ARRAY(BSON("$out" << "out_collection") << BSON("$skip" << 1)))); ASSERT_THROWS(DocumentSourceFacet::createFromBson(spec.firstElement(), ctx), UserException); }
List *mergesort(List *list) { if (length(list) == 1) { return list; } Position testOnConstr = NULL; bool test = 0; List *leftHalf = createList(testOnConstr); List *rightHalf = createList(testOnConstr); Position posLeft = head(leftHalf); Position posRight = head(rightHalf); for (Position temp = firstElement(list); temp != next(list, middle(list)); temp = next(list, temp)) { insert(leftHalf, returnByPos(list, temp), posLeft); posLeft = next(leftHalf, posLeft); } for (Position temp = next(list, middle(list)); temp != last(list); temp = next(list, temp)) { insert(rightHalf, returnByPos(list, temp), posRight); posRight = next(rightHalf, posRight); } leftHalf = mergesort(leftHalf); rightHalf = mergesort(rightHalf); List *result = createList(testOnConstr); Position posResult = head(result); posLeft = head(leftHalf); posRight = head(rightHalf); while (length(leftHalf) && length(rightHalf) != 0) { if (returnByPos(leftHalf, firstElement(leftHalf)) <= returnByPos(rightHalf, firstElement(rightHalf))) { insert(result, returnByPos(leftHalf, firstElement(leftHalf)), posResult); remove(leftHalf, posLeft); posResult = next(result, posResult); } else { insert(result, returnByPos(rightHalf, firstElement(rightHalf)), posResult); remove(rightHalf, posRight); posResult = next(result, posResult); } } while (length(leftHalf) != 0) { insert(result, returnByPos(leftHalf, firstElement(leftHalf)), posResult); remove(leftHalf, posLeft); posResult = next(result, posResult); } while (length(rightHalf) != 0) { insert(result, returnByPos(rightHalf, firstElement(rightHalf)), posResult); remove(rightHalf, posRight); posResult = next(result, posResult); } deleteList(leftHalf); deleteList(rightHalf); return result; }
void printList(ListPoint *list) { ElementOfList *temp = firstElement(list); while (temp != nullptr) { std::cout << temp->value << " "; temp = temp->next; } std::cout << std::endl; }
bool Stanza::isValid() const { if (element().isNull()) return false; if (type()=="error" && firstElement("error").isNull()) return false; return true; }
ElementOfList *middle(ListPoint *list) { int middleCount = length(list) / 2 - 1; ElementOfList *temp = firstElement(list); while(middleCount > 0) { middleCount--; temp = temp->next; } return temp; }
void BSONObj::_assertInvalid() const { StringBuilder ss; int os = objsize(); ss << "BSONObj size: " << os << " (0x" << integerToHex( os ) << ") is invalid. " << "Size must be between 0 and " << BSONObjMaxInternalSize << "(" << ( BSONObjMaxInternalSize/(1024*1024) ) << "MB)"; try { BSONElement e = firstElement(); ss << " First element: " << e.toString(); } catch ( ... ) { } massert( 10334 , ss.str() , 0 ); }
// calculation of every element for one tile int tile_fill(struct TileQueue *tiles) { INDEX i,j; COLOR *TileColor; INIT_MEM(TileColor, TILE_SIZE * TILE_SIZE, COLOR); struct timeval t1, t2; gettimeofday(&t1, NULL); while(!terminated){ pthread_mutex_lock(&mutex); if (!isEmpty(tiles)) { int current_tile = firstElement(tiles); pop(tiles); pthread_mutex_unlock(&mutex); if (fake) { // fake tasks usleep(-current_tile); } else { // regular tasks // assigning first and final index of tile int j_begin = rank_j(current_tile, Cj); int j_end = MIN(j_begin + TILE_SIZE, Img.Pixel.j); int i_begin = rank_i(current_tile, Ci); int i_end = MIN(i_begin + TILE_SIZE, Img.Pixel.i); for (j = j_begin; j < j_end ; j++) { for (i = i_begin ; i < i_end; i++) { TileColor [(j-j_begin) * TILE_SIZE + (i-i_begin)] = pixel_basic (i, j); } } // Sending current tile to proc 0 MPI_Send(TileColor, TILE_SIZE * TILE_SIZE, MPI_COLOR, 0, current_tile + TILE_TAG_INDEX, MPI_COMM_WORLD); } } else { pthread_mutex_unlock(&mutex); if (!vol){ terminated = 1; break; } // if vol de travail, ask for work and wait until we receive it sem_post(&ask_work); sem_wait(&wait_work); } } pthread_mutex_lock(&mutex_time); gettimeofday(&t2, NULL); local_time = MAX(local_time,(t2.tv_sec - t1.tv_sec)*1000000 + t2.tv_usec - t1.tv_usec); printf("time %ld\n",(t2.tv_sec - t1.tv_sec)*1000000 + t2.tv_usec - t1.tv_usec); pthread_mutex_unlock(&mutex_time); return 0; }
void QPubNub::onSubscribeReadyRead() { QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender()); QJsonArray response; if (handleResponse(reply, response)) { return; } QJsonValue firstElement(response.at(0)); if (!firstElement.isArray()) { emit error("First element of response is not an JSON array", 0); subscribe(); } QJsonValue timeTokenElement = response.at(1); if (!timeTokenElement.isString()) { emit error("Second element of response is not a string", 0); subscribe(); } m_timeToken = timeTokenElement.toString(); QJsonValue channelListString = response.at(2); QStringList channels; QJsonArray messages = firstElement.toArray(); if (channelListString.isString()) { channels = channelListString.toString().split(','); } else { int len = messages.isEmpty() ? 0 : messages.size(); for (int i = 0; i < len; i++) { channels << m_channelUrlPart; } } if (messages.isEmpty()) { emit connected(); } else { #ifdef Q_PUBNUB_CRYPT if (m_cipherKey.isEmpty()) { for (int i=0,len=messages.size();i<len;++i) { emit message(messages[i], m_timeToken, channels[i]); } } else { decrypt(messages, channels); } #else for (int i=0,len=messages.size();i<len;++i) { emit message(messages[i], m_timeToken, channels[i]); } #endif // Q_PUBNUB_CRYPT } subscribe(); }
int length(ListPoint *list) { if (head(list) == 0) { return 0; } int count = 0; ElementOfList *temp = firstElement(list); while(temp != nullptr) { count++; temp = temp->next; } return count; }
Status createCollectionForApplyOps(OperationContext* opCtx, const std::string& dbName, const BSONElement& ui, const BSONObj& cmdObj, const BSONObj& idIndex) { invariant(opCtx->lockState()->isDbLockedForMode(dbName, MODE_X)); auto db = dbHolder().get(opCtx, dbName); const NamespaceString newCollName(Command::parseNsCollectionRequired(dbName, cmdObj)); auto newCmd = cmdObj; // If a UUID is given, see if we need to rename a collection out of the way, and whether the // collection already exists under a different name. If so, rename it into place. As this is // done during replay of the oplog, the operations do not need to be atomic, just idempotent. // We need to do the renaming part in a separate transaction, as we cannot transactionally // create a database on MMAPv1, which could result in createCollection failing if the database // does not yet exist. if (ui.ok()) { // Return an optional, indicating whether we need to early return (if the collection already // exists, or in case of an error). using Result = boost::optional<Status>; auto result = writeConflictRetry(opCtx, "createCollectionForApplyOps", newCollName.ns(), [&] { WriteUnitOfWork wunit(opCtx); // Options need the field to be named "uuid", so parse/recreate. auto uuid = uassertStatusOK(UUID::parse(ui)); uassert(ErrorCodes::InvalidUUID, "Invalid UUID in applyOps create command: " + uuid.toString(), uuid.isRFC4122v4()); auto& catalog = UUIDCatalog::get(opCtx); auto currentName = catalog.lookupNSSByUUID(uuid); OpObserver* opObserver = getGlobalServiceContext()->getOpObserver(); if (currentName == newCollName) return Result(Status::OK()); // In the case of oplog replay, a future command may have created or renamed a // collection with that same name. In that case, renaming this future collection to // a random temporary name is correct: once all entries are replayed no temporary // names will remain. On MMAPv1 the rename can result in index names that are too // long. However this should only happen for initial sync and "resync collection" // for rollback, so we can let the error propagate resulting in an abort and restart // of the initial sync or result in rollback to fassert, requiring a resync of that // node. const bool stayTemp = true; if (auto futureColl = db ? db->getCollection(opCtx, newCollName) : nullptr) { auto tmpNameResult = db->makeUniqueCollectionNamespace(opCtx, "tmp%%%%%"); if (!tmpNameResult.isOK()) { return Result(Status(tmpNameResult.getStatus().code(), str::stream() << "Cannot generate temporary " "collection namespace for applyOps " "create command: collection: " << newCollName.ns() << ". error: " << tmpNameResult.getStatus().reason())); } const auto& tmpName = tmpNameResult.getValue(); Status status = db->renameCollection(opCtx, newCollName.ns(), tmpName.ns(), stayTemp); if (!status.isOK()) return Result(status); opObserver->onRenameCollection(opCtx, newCollName, tmpName, futureColl->uuid(), /*dropTarget*/ false, /*dropTargetUUID*/ {}, stayTemp); } // If the collection with the requested UUID already exists, but with a different // name, just rename it to 'newCollName'. if (catalog.lookupCollectionByUUID(uuid)) { Status status = db->renameCollection(opCtx, currentName.ns(), newCollName.ns(), stayTemp); if (!status.isOK()) return Result(status); opObserver->onRenameCollection(opCtx, currentName, newCollName, uuid, /*dropTarget*/ false, /*dropTargetUUID*/ {}, stayTemp); wunit.commit(); return Result(Status::OK()); } // A new collection with the specific UUID must be created, so add the UUID to the // creation options. Regular user collection creation commands cannot do this. auto uuidObj = uuid.toBSON(); newCmd = cmdObj.addField(uuidObj.firstElement()); wunit.commit(); return Result(boost::none); }); if (result) { return *result; } } return createCollection( opCtx, newCollName, newCmd, idIndex, CollectionOptions::parseForStorage); }
void img (const char *FileNameImg) { FILE *FileImg; COLOR *TabColor, *Color, *TileColor; STRING Name; INDEX i, j, rank; BYTE Byte; int N = 18988, err, provided; int next_proc; MPI_Request rs; MPI_Status status; MPI_Init_thread(NULL, NULL, MPI_THREAD_MULTIPLE, &provided); MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &P); next_proc = (rank + 1) % P; if (next_proc == 0) next_proc++; P--; MPI_Type_vector(1, 3, 0, MPI_FLOAT, &MPI_COLOR); MPI_Type_commit(&MPI_COLOR); if (rank == 0) { strcpy (Name, FileNameImg); strcat (Name, ".ppm"); INIT_FILE (FileImg, Name, "w"); fprintf (FileImg, "P6\n%d %d\n255\n", Img.Pixel.i, Img.Pixel.j); } // number of tiles Ci = Img.Pixel.i / TILE_SIZE + (Img.Pixel.i % TILE_SIZE?1:0); // number of tiles in dimension i Cj = Img.Pixel.j / TILE_SIZE + (Img.Pixel.i % TILE_SIZE?1:0); // number of tiles in dimension j int C = Ci * Cj; int q = (C+P-1)/P; int size = Img.Pixel.i * Img.Pixel.j ; N = C/2+1; // buffer for each tile INIT_MEM (TileColor, TILE_SIZE * TILE_SIZE, COLOR); if (rank != 0) { struct TileQueue tiles = {NULL, NULL}; // Init tasks init(&tiles,rank,q,N,C); // Init mutex, semaphores & threads pthread_mutex_init(&mutex,NULL); pthread_mutex_init(&mutex_time,NULL); sem_init(&wait_work, 0, 0); sem_init(&ask_work, 0, 0); pthread_t tid[NB_THREADS]; for (i = 0; i < NB_THREADS; i++){ err = pthread_create(&(tid[i]), NULL, (void*)tile_fill, (void*)&tiles); if (err != 0) printf("\ncan't create thread :[%s]", strerror(err)); } // vol de travail ? if (vol){ // Main thread: Communicator while (!terminated) { int flag = 0, msg; MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, &status); if (flag) { // We DID receive a communication so we CAN do a blocking receive MPI_Recv(&msg, 1, MPI_INT, status.MPI_SOURCE, status.MPI_TAG, MPI_COMM_WORLD, &status); // TAG contains the information about what the message is switch (status.MPI_TAG){ case TERMINATE: // No more jobs; threads can finish their jobs and return MPI_Isend(&msg, 1, MPI_INT, next_proc, TERMINATE, MPI_COMM_WORLD, &rs); terminated = 1; break; case WORK_ASK: // msg-th process is seeking for job pthread_mutex_lock(&mutex); if(!isEmpty(&tiles)){ int tile = firstElement(&tiles); pop(&tiles); pthread_mutex_unlock(&mutex); MPI_Isend(&tile, 1, MPI_INT, msg, WORK_SEND, MPI_COMM_WORLD, &rs); } else { pthread_mutex_unlock(&mutex); if (msg == rank){ MPI_Isend(&msg, 1, MPI_INT, next_proc, TERMINATE, MPI_COMM_WORLD, &rs); terminated = 1; } else { MPI_Isend(&msg, 1, MPI_INT, next_proc, WORK_ASK, MPI_COMM_WORLD, &rs); } } break; case WORK_SEND: // Received a job pthread_mutex_lock(&mutex); addTile(&tiles, msg); pthread_mutex_unlock(&mutex); sem_post(&wait_work); break; default: fprintf(stderr, "Err: Unknown message: %d, with tag %d\n", msg,status.MPI_TAG); break; } } if (sem_trywait(&ask_work) == 0){ MPI_Isend(&rank, 1, MPI_INT, next_proc, WORK_ASK, MPI_COMM_WORLD, &rs); } } for (i = 0; i < NB_THREADS; i++){ sem_post(&wait_work); } } for (i = 0; i < NB_THREADS; i++){ pthread_join(tid[i],NULL); } pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex_time); sem_destroy(&wait_work); sem_destroy(&ask_work); fprintf(stderr, "%d %ld\n", rank, local_time); } // process 0 gathers all the tiles if (rank == 0){ // If fake tasks: we don't receive anything and don't write the image FILE* fd = fopen("config","r"); if (fd != NULL){ int fake; fscanf(fd,"%d\n",&fake); if (fake){ EXIT_FILE(FileImg); EXIT_MEM(TileColor); MPI_Finalize(); return; } } // final image buffer that will receive the tiles INIT_MEM (TabColor, size, COLOR); // Receive tiles from other procs for (i = 0; i < C ; i++){ MPI_Recv(TileColor, TILE_SIZE * TILE_SIZE, MPI_COLOR, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status); int current_tile = status.MPI_TAG - TILE_TAG_INDEX; int j_begin = rank_j(current_tile,Cj); int index_begin = rank_i(current_tile,Ci) + j_begin * Img.Pixel.i; for (j = 0; j < TILE_SIZE && j_begin + j < Img.Pixel.j; j++) { memcpy(&TabColor[index_begin + j * Img.Pixel.i],&TileColor[j * TILE_SIZE],MIN(Img.Pixel.i - rank_i(current_tile,Ci),TILE_SIZE) * sizeof(COLOR)); } } // writing in file for (j = 0, Color = TabColor; j < size; j++, Color++) { Byte = Color->r < 1.0 ? 255.0*Color->r : 255.0; putc (Byte, FileImg); Byte = Color->g < 1.0 ? 255.0*Color->g : 255.0; putc (Byte, FileImg); Byte = Color->b < 1.0 ? 255.0*Color->b : 255.0; putc (Byte, FileImg); } EXIT_FILE (FileImg); printf("Copied in file\n"); EXIT_MEM (TabColor); } EXIT_MEM (TileColor); MPI_Finalize(); }
StatusWith<std::set<NamespaceString>> RollbackImpl::_namespacesForOp(const OplogEntry& oplogEntry) { NamespaceString opNss = oplogEntry.getNamespace(); OpTypeEnum opType = oplogEntry.getOpType(); std::set<NamespaceString> namespaces; // No namespaces for a no-op. if (opType == OpTypeEnum::kNoop) { return std::set<NamespaceString>(); } // CRUD ops have the proper namespace in the operation 'ns' field. if (opType == OpTypeEnum::kInsert || opType == OpTypeEnum::kUpdate || opType == OpTypeEnum::kDelete) { return std::set<NamespaceString>({opNss}); } // If the operation is a command, then we need to extract the appropriate namespaces from the // command object, as opposed to just using the 'ns' field of the oplog entry itself. if (opType == OpTypeEnum::kCommand) { auto obj = oplogEntry.getObject(); auto firstElem = obj.firstElement(); // Does not handle 'applyOps' entries. invariant(oplogEntry.getCommandType() != OplogEntry::CommandType::kApplyOps, "_namespacesForOp does not handle 'applyOps' oplog entries."); switch (oplogEntry.getCommandType()) { case OplogEntry::CommandType::kRenameCollection: { // Add both the 'from' and 'to' namespaces. namespaces.insert(NamespaceString(firstElem.valuestrsafe())); namespaces.insert(NamespaceString(obj.getStringField("to"))); break; } case OplogEntry::CommandType::kDropDatabase: { // There is no specific namespace to save for a drop database operation. break; } case OplogEntry::CommandType::kDbCheck: case OplogEntry::CommandType::kConvertToCapped: case OplogEntry::CommandType::kEmptyCapped: { // These commands do not need to be supported by rollback. 'convertToCapped' should // always be converted to lower level DDL operations, and 'emptycapped' is a // testing-only command. std::string message = str::stream() << "Encountered unsupported command type '" << firstElem.fieldName() << "' during rollback."; return Status(ErrorCodes::UnrecoverableRollbackError, message); } case OplogEntry::CommandType::kCreate: case OplogEntry::CommandType::kDrop: case OplogEntry::CommandType::kCreateIndexes: case OplogEntry::CommandType::kDropIndexes: case OplogEntry::CommandType::kCollMod: { // For all other command types, we should be able to parse the collection name from // the first command argument. try { auto cmdNss = CommandHelpers::parseNsCollectionRequired(opNss.db(), obj); namespaces.insert(cmdNss); } catch (const DBException& ex) { return ex.toStatus(); } break; } case OplogEntry::CommandType::kApplyOps: default: // Every possible command type should be handled above. MONGO_UNREACHABLE } }