下面列出了com.mongodb.ServerAddress#org.bson.Document 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
protected Supplier<Stream<DependencyTreeMatcher>> createPatternsSupplier()
throws DependencyParseException {
return new Supplier<Stream<DependencyTreeMatcher>>() {
MongoDatabase db = mongoResource.getDB();
final MongoCollection<Document> coll = db.getCollection(patternsCollection);
@Override
public Stream<DependencyTreeMatcher> get() {
return StreamSupport.stream(coll.find().spliterator(), false)
.map(
document -> {
try {
return DependencyTreeMatcher.create(document.getString(patternField));
} catch (DependencyParseException e) {
return null;
}
})
.filter(Predicates.notNull());
}
};
}
protected Document execute(String deviceId, HashMap<String, String> mos) throws HitDMException {
String to = "/hit/openapi/dm/write";
Document content = new Document();
content.put("d", deviceId);
List<Document> list = new ArrayList<Document>();
Set<String> set = mos.keySet();
Iterator<String> it = set.iterator();
while (it.hasNext()) {
Document e = new Document();
String key = it.next();
String val = mos.get(key);
e.put("n", key);
e.put("sv", val);
list.add(e);
}
content.put("e", list);
return callApi(to, content);
}
@Ignore
@Test
public void testInsert() {
MongoClientURI connectionString = new MongoClientURI("mongodb://127.0.0.1");
MongoClient mongoClient = new MongoClient(connectionString);
MongoDatabase database = mongoClient.getDatabase("lztb_att");
MongoCollection<Document> collection = database.getCollection("test");
Document doc = new Document("name", "MongoDB")
.append("type", "database")
.append("count", 1)
.append("info", new Document("x", 203).append("y", 102));
new Document().append("1", 1);
collection.insertOne(doc);
mongoClient.close();
}
@Override
public <T> T merge(final T entity, final InsertOneOptions options) {
final Object id = mapper.getId(entity);
if (id == null) {
throw new MappingException("Could not get id for " + entity.getClass().getName());
}
final Document document = mapper.toDocument(entity);
document.remove("_id");
final Query<T> query = (Query<T>) find(entity.getClass()).filter(eq("_id", id));
if (!tryVersionedUpdate(entity, mapper.getCollection(entity.getClass()), options)) {
UpdateResult execute = query.update(UpdateOperators.set(entity))
.execute(new UpdateOptions()
.clientSession(findSession(options))
.writeConcern(options.writeConcern()));
if (execute.getModifiedCount() != 1) {
throw new UpdateException("Nothing updated");
}
}
return query.first();
}
public ProfilingWriter(BlockingQueue<ProfilingEntry> jobQueue) {
this.jobQueue = jobQueue;
serverDto = ConfigReader.getCollectorServer();
runningSince = new Date();
final MongoDbAccessor mongo = getMongoDbAccessor();
try {
final MongoCollection<Document> profileCollection = getProfileCollection(mongo);
IndexOptions indexOptions = new IndexOptions();
indexOptions.background(true);
LOG.info("Create index {ts:-1, lbl:1} in the background if it does not yet exists");
profileCollection.createIndex(new BasicDBObject("ts",-1).append("lbl", 1), indexOptions);
LOG.info("Create index {adr:1, db:1, ts:-1} in the background if it does not yet exists");
profileCollection.createIndex(new BasicDBObject("adr",1).append("db",1).append("ts", -1), indexOptions);
LOG.info("ProfilingWriter is ready at {}", serverDto.getHosts());
} catch (MongoException e) {
LOG.error("Exception while connecting to: {}", serverDto.getHosts(), e);
}
}
@Test
public void shouldRunChangesetWithNullEnvironment() throws Exception {
// given
runner.setSpringEnvironment(null);
runner.setChangeLogsScanPackage(EnvironmentDependentTestResource.class.getPackage().getName());
when(dao.isNewChange(any(ChangeEntry.class))).thenReturn(true);
// when
runner.execute();
// then
long change1 = fakeMongoDatabase.getCollection(CHANGELOG_COLLECTION_NAME)
.count(new Document()
.append(ChangeEntry.KEY_CHANGEID, "Envtest1")
.append(ChangeEntry.KEY_AUTHOR, "testuser"));
assertEquals(1, change1);
}
@Override
public void copyPermissions(String fromResourceId, String toResourceId) throws IResourceStore.ResourceStoreException, IResourceStore.ResourceNotFoundException {
Document permissionsDocument = collection.find(new Document("_id", new ObjectId(fromResourceId))).first();
try {
if (permissionsDocument == null) {
String message = "Resource 'Permissions' not found. (id=%s)";
message = String.format(message, fromResourceId);
throw new IResourceStore.ResourceNotFoundException(message);
}
permissionsDocument.remove("_id");
Permissions permissions = documentBuilder.build(permissionsDocument, Permissions.class);
createPermissions(toResourceId, permissions);
} catch (IOException e) {
log.debug(e.getLocalizedMessage(), e);
throw new IResourceStore.ResourceStoreException("Cannot parse json structure into Permissions entity.", e);
}
}
/**
* Verifies that 'update' does not insert if 'upsert' if false.
* @see #testUpsert()
*/
@Test
public void testUpdateDoesNotInsert() throws Exception {
Document doc = DOCUMENTS.get(0);
byte[] bytes = documentToByteArray(doc);
runner.setProperty(PutMongo.MODE, "update");
runner.enqueue(bytes);
runner.run();
runner.assertAllFlowFilesTransferred(PutMongo.REL_SUCCESS, 1);
MockFlowFile out = runner.getFlowFilesForRelationship(PutMongo.REL_SUCCESS).get(0);
out.assertContentEquals(bytes);
// nothing was in collection, so nothing to update since upsert defaults to false
assertEquals(0, collection.count());
}
private void storeIndexSettings() {
indexLock.writeLock().lock();
try {
MongoDatabase db = mongo.getDatabase(mongoConfig.getDatabaseName());
MongoCollection<Document> dbCollection = db.getCollection(indexConfig.getIndexName() + CONFIG_SUFFIX);
Document settings = IndexConfigUtil.toDocument(indexConfig);
settings.put(MongoConstants.StandardFields._ID, SETTINGS_ID);
Document query = new Document();
query.put(MongoConstants.StandardFields._ID, SETTINGS_ID);
dbCollection.replaceOne(query, settings, new UpdateOptions().upsert(true));
}
finally {
indexLock.writeLock().unlock();
}
}
/**
* Saves the specified tile spec to the database.
*
* @param stackId stack identifier.
* @param tileSpec specification to be saved.
*
* @throws IllegalArgumentException
* if any required parameters or transform spec references are missing.
*/
void saveTileSpec(final StackId stackId,
final TileSpec tileSpec)
throws IllegalArgumentException {
MongoUtil.validateRequiredParameter("stackId", stackId);
MongoUtil.validateRequiredParameter("tileSpec", tileSpec);
MongoUtil.validateRequiredParameter("tileSpec.tileId", tileSpec.getTileId());
final MongoCollection<Document> tileCollection = getTileCollection(stackId);
final String context = "tile spec with id '" + tileSpec.getTileId();
validateTransformReferences(context, stackId, tileSpec.getTransforms());
final Document query = new Document();
query.put("tileId", tileSpec.getTileId());
final Document tileSpecObject = Document.parse(tileSpec.toJson());
final UpdateResult result = tileCollection.replaceOne(query, tileSpecObject, MongoUtil.UPSERT_OPTION);
LOG.debug("saveTileSpec: {}.{},({}), upsertedId is {}",
MongoUtil.fullName(tileCollection),
MongoUtil.action(result),
query.toJson(),
result.getUpsertedId());
}
public boolean checkIfRegistered(String cseId, CSE_TYPE cseType) {
List<KeyValue> kv = new ArrayList<KeyValue>();
kv.add(new KeyValue(CSEID_KEY, cseId));
kv.add(new KeyValue(RESTYPE_KEY, RESOURCE_TYPE.REMOTE_CSE.Value()));
if (cseType != null) {
kv.add(new KeyValue(CSETYPE_KEY, cseType.Value()));
}
List<Document> doc = getDocuments(kv, RESOURCE_TYPE.REMOTE_CSE, null, true, 1);
return doc != null && doc.size() > 0;
}
/**
* Serializes a document visibility expression byte array to a MongoDB
* {@link Document}.
* @param expression the document visibility expression byte array to be
* serialized.
* @return The MongoDB {@link Document}.
*/
public static Document toDocument(final byte[] expression) {
DocumentVisibility dv;
if (expression == null) {
dv = MongoDbRdfConstants.EMPTY_DV;
} else {
dv = new DocumentVisibility(expression);
}
return toDocument(dv);
}
/**
* Store a document in MongoDB. If the document has an ID, it will replace existing
* documents with that ID. If it does not, it will be inserted and MongoDB will assign it with
* a unique ID.
*
* @param topic Kafka topic that the document belongs to
* @param doc MongoDB document
* @throws MongoException if the document could not be stored.
*/
public void store(String topic, Document doc) throws MongoException {
MongoCollection<Document> collection = getCollection(topic);
Object mongoId = doc.get(MONGO_ID_KEY);
if (mongoId != null) {
collection.replaceOne(eq(MONGO_ID_KEY, mongoId), doc, UPDATE_UPSERT);
} else {
collection.insertOne(doc);
}
}
private void find(String dbName, String collName, int limit){
final MongoIterable<Document> res = getMongoDatabase(dbName).getCollection(collName)
.find()
.limit(limit);
if(res != null){
for(Document doc : res){
LOG.info("doc: {}", JSON.serialize(doc));
}
}
}
/***
* 插入单条记录
* @param table 表连接
* @param obj 单条数据
* obj double 处理不规范
* @return
*/
public String insertOne(MongoCollection table, Object obj) {
if (obj == null) {return null;}
Document docine =Document.parse(diyObjectIdToJson(obj));
docine.remove("_id");
docine.put("_id", new ObjectId().toString());
table.insertOne(docine);
return docine.get("_id").toString();
}
/**
* Reading directly {@link Document}
*/
@Test
public void document() throws IOException {
final CodecRegistry registry = JacksonCodecs.registryFromMapper(mapper);
Document expected = new Document("a", 1);
Document actual= registry.get(Document.class).decode(new BsonDocumentReader(expected.toBsonDocument(BsonDocument.class, registry)), DecoderContext.builder().build());
check(actual).is(expected);
}
private void testUpdateFullDocument(TestRunner runner) {
Document document = new Document()
.append("name", "John Smith")
.append("department", "Engineering");
collection.insertOne(document);
String updateBody = "{\n" +
"\t\"name\": \"John Smith\",\n" +
"\t\"department\": \"Engineering\",\n" +
"\t\"contacts\": {\n" +
"\t\t\"phone\": \"555-555-5555\",\n" +
"\t\t\"email\": \"[email protected]\",\n" +
"\t\t\"twitter\": \"@JohnSmith\"\n" +
"\t}\n" +
"}";
runner.setProperty(PutMongo.UPDATE_MODE, PutMongo.UPDATE_WITH_DOC);
runner.setProperty(PutMongo.MODE, PutMongo.MODE_UPDATE);
runner.setValidateExpressionUsage(true);
runner.enqueue(updateBody);
runner.run();
runner.assertTransferCount(PutMongo.REL_FAILURE, 0);
runner.assertTransferCount(PutMongo.REL_SUCCESS, 1);
MongoCursor<Document> cursor = collection.find(document).iterator();
Document found = cursor.next();
Assert.assertEquals(found.get("name"), document.get("name"));
Assert.assertEquals(found.get("department"), document.get("department"));
Document contacts = (Document)found.get("contacts");
Assert.assertNotNull(contacts);
Assert.assertEquals(contacts.get("twitter"), "@JohnSmith");
Assert.assertEquals(contacts.get("email"), "[email protected]");
Assert.assertEquals(contacts.get("phone"), "555-555-5555");
Assert.assertEquals(collection.count(document), 1);
}
@SuppressWarnings("unchecked")
private Optional<String> getLabel(Document document) {
String label = null;
try {
label = ((List<String>) document.get(labelField)).get(0);
} catch (NullPointerException | ClassCastException e) {
label = document.getString(labelField);
}
return Optional.ofNullable(label);
}
@Test
public void shouldReturnErrorStatusOnAnyException() {
//given
when(mongoDatabase.runCommand(new Document().append("ping", 1))).thenThrow(new MongoException("SomeException"));
//when
final StatusDetail statusDetail = testee.statusDetails().get(0);
//then
assertThat(statusDetail.getStatus(), is(ERROR));
assertThat(statusDetail.getMessage(), containsString("Exception during database check"));
}
public static <T> T toInfo(Document document, String _id, Class<T> clazz) {
if (null == document) {
return null;
}
try {
T instance = clazz.getDeclaredConstructor().newInstance();
Field[] fields = clazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
if ("isNew".equals(field.getName())) {
continue;
}
if (_id.equals(field.getName())) {
field.set(instance, document.get("_id"));
} else if (!document.containsKey(field.getName())) {
continue;
} else if (field.getType().getName().equals("java.math.BigInteger")) {
field.set(instance, new BigInteger(document.get(field.getName()).toString()));
} else {
field.set(instance, document.get(field.getName()));
}
}
return instance;
} catch (Exception e) {
LoggerUtil.commonLog.error(e);
throw new NulsRuntimeException(ApiErrorCode.DATA_PARSE_ERROR, "Document to Model fail");
}
}
public T execute(final CoreStitchServiceClient service) {
final Document args = new Document();
args.put("database", namespace.getDatabaseName());
args.put("collection", namespace.getCollectionName());
args.put("filter", filter);
// Send project and sort if they are not null
if (project != null) {
args.put("projection", project);
}
if (sort != null) {
args.put("sort", sort);
}
// findOneAndDelete() does not take these arguments
if (!methodName.equals("findOneAndDelete")) {
args.put("update", update);
if (upsert) {
args.put("upsert", true);
}
if (returnNewDocument) {
args.put("returnNewDocument", true);
}
}
return service.callFunction(methodName, Collections.singletonList(args), decoder);
}
@VisibleForTesting
static Document buildQuery(TupleDomain<ColumnHandle> tupleDomain)
{
Document query = new Document();
if (tupleDomain.getDomains().isPresent()) {
for (Map.Entry<ColumnHandle, Domain> entry : tupleDomain.getDomains().get().entrySet()) {
MongoColumnHandle column = (MongoColumnHandle) entry.getKey();
Optional<Document> predicate = buildPredicate(column, entry.getValue());
predicate.ifPresent(query::putAll);
}
}
return query;
}
public boolean reExitTransactionInMongoDB(TransactionXid transactionXid, String identifier) {
byte[] global = transactionXid.getGlobalTransactionId();
String instanceId = ByteUtils.byteArrayToString(global);
try {
String application = CommonUtils.getApplication(this.endpoint);
String databaseName = application.replaceAll("\\W", "_");
MongoDatabase mdb = this.mongoClient.getDatabase(databaseName);
MongoCollection<Document> collection = mdb.getCollection(CONSTANTS_TB_LOCKS);
Bson condition = Filters.eq(CONSTANTS_FD_GLOBAL, instanceId);
Document increases = new Document();
increases.append("times", -1);
Document document = new Document();
document.append("$inc", increases);
Document target = collection.findOneAndUpdate(condition, document, new FindOneAndUpdateOptions().upsert(true));
Integer times = target == null ? null : target.getInteger("times");
return times == null ? true : times <= 0;
} catch (com.mongodb.MongoWriteException error) {
logger.error("Error occurred while locking transaction(gxid= {}).", instanceId, error);
return true;
} catch (RuntimeException rex) {
logger.error("Error occurred while locking transaction(gxid= {}).", instanceId, rex);
return true;
}
}
@Override
public DeviceInfo getStatus(DeviceInfo devInfo) throws OneM2MException {
OneM2MDmAdapter adaptor = new OneM2MDmAdapter(CfgManager.getInstance().getOneM2mAgentAddress());
String deviceId = devInfo.getObjectIDs().get(0);
Document nodeDoc = context.getDatabaseManager().getCollection(CfgManager.getInstance().getResourceDatabaseName())
.find(new BasicDBObject(Naming.NODEID_SN, deviceId)).first();
String agentAddress = "";
agentAddress = nodeDoc.getString(Naming.MGMTCLIENTADDRESS);
if(agentAddress != null && !agentAddress.equals("")) {
adaptor = new OneM2MDmAdapter(agentAddress);
}
try {
Document doc = adaptor.readDeviceStatus(deviceId, "deviceinfo");
devInfo.setFwVersion(doc.getString("fw_version"));
devInfo.setSwVersion(doc.getString("os_version"));
devInfo.setDeviceLabel(doc.getString("serial"));
devInfo.setManufacturer(doc.getString("manufacturer"));
devInfo.setModel(doc.getString("model"));
} catch (HitDMException e) {
throw convertHitDMExToOneM2MEx(e);
} catch(IOException ex) {
ex.printStackTrace();
return null;
}
return devInfo;
}
@Override
public Source<List<Throwable>, NotUsed> purge(final CharSequence namespace) {
final Bson filter = thingNamespaceFilter(namespace);
final Bson update = new BsonDocument().append(AbstractWriteModel.SET,
new BsonDocument().append(FIELD_DELETE_AT, new BsonDateTime(0L)));
final UpdateOptions updateOptions = new UpdateOptions().bypassDocumentValidation(true);
final WriteModel<Document> writeModel = new UpdateManyModel<>(filter, update, updateOptions);
return Source.fromPublisher(collection.bulkWrite(Collections.singletonList(writeModel)))
.map(bulkWriteResult -> Collections.<Throwable>emptyList())
.recoverWithRetries(1, new PFBuilder<Throwable, Source<List<Throwable>, NotUsed>>()
.matchAny(throwable -> Source.single(Collections.singletonList(throwable)))
.build());
}
public static void drop(final MongoNamespace namespace) throws Throwable {
try {
ObservableSubscriber<Document> subscriber = new ObservableSubscriber<Document>();
getMongoClient().getDatabase(namespace.getDatabaseName())
.runCommand(new Document("drop", namespace.getCollectionName()))
.subscribe(subscriber);
subscriber.await(20, SECONDS);
} catch (MongoCommandException e) {
if (!e.getErrorMessage().contains("ns not found")) {
throw e;
}
}
}
@Test
public void mongoSaveNewTest() {
// When
// Given
String saveArguments = "{\"id\":11,\"someText\":\"new\"}";
UpdateResult result = template.requestBody("direct:start", saveArguments, UpdateResult.class);
// Then
Assertions.assertThat(result.getUpsertedId().asNumber().longValue()).isEqualTo(11L);
List<Document> docsFound = collection.find(Filters.eq("_id", 11)).into(new ArrayList<>());
Assertions.assertThat(docsFound).hasSize(1);
Assertions.assertThat(docsFound.get(0).getString("test")).isEqualTo("new");
}
protected Document firmwareUpdate(String deviceId, String url, String version, String packageName) throws HitDMException, IOException {
String to = "/firmware";
Document content = new Document();
content.put("d", deviceId);
content.put("url", url);
content.put("version", version);
content.put("pkgName", packageName);
return callPostApi(to, content);
}
@Test(expected = IllegalStateException.class)
public void testUsedRowsOnlyCleanupOnClosedConnection() throws Exception {
// GIVEN
final CleanupStrategyExecutor<MongoDatabase, Document> strategyExecutor = provider.usedRowsOnlyStrategy();
assertThat(strategyExecutor, notNullValue());
mongoClient.close();
// WHEN
strategyExecutor.execute(connection, Arrays.asList(initialDataSet));
}
public DescriptorStore(MongoDatabase database, IPermissionStore permissionStore, IUserStore userStore,
IGroupStore groupStore, IDocumentBuilder documentBuilder, Class<T> documentType) {
RuntimeUtilities.checkNotNull(database, "database");
RuntimeUtilities.checkNotNull(permissionStore, "permissionStore");
MongoCollection<Document> descriptorCollection = database.getCollection(COLLECTION_DESCRIPTORS);
MongoResourceStorage<T> resourceStorage =
new MongoResourceStorage<>(database, collectionName, documentBuilder, documentType);
this.descriptorResourceStore = new ModifiableHistorizedResourceStore<>(resourceStorage);
this.resourceFilter = new ResourceFilter<>(descriptorCollection, descriptorResourceStore,
permissionStore, userStore, groupStore, documentBuilder, documentType);
descriptorCollection.createIndex(Indexes.ascending(FIELD_RESOURCE), new IndexOptions().unique(true));
}