public void ensureCaps() {
   for (MappedClass mc : mapr.getMappedClasses())
     if (mc.getEntityAnnotation() != null && mc.getEntityAnnotation().cap().value() > 0) {
       CappedAt cap = mc.getEntityAnnotation().cap();
       String collName = mapr.getCollectionName(mc.getClazz());
       BasicDBObjectBuilder dbCapOpts = BasicDBObjectBuilder.start("capped", true);
       if (cap.value() > 0) dbCapOpts.add("size", cap.value());
       if (cap.count() > 0) dbCapOpts.add("max", cap.count());
       DB db = getDB();
       if (db.getCollectionNames().contains(collName)) {
         DBObject dbResult = db.command(BasicDBObjectBuilder.start("collstats", collName).get());
         if (dbResult.containsField("capped")) {
           // TODO: check the cap options.
           log.warning("DBCollection already exists is cap'd already; doing nothing. " + dbResult);
         } else {
           log.warning(
               "DBCollection already exists with same name("
                   + collName
                   + ") and is not cap'd; not creating cap'd version!");
         }
       } else {
         getDB().createCollection(collName, dbCapOpts.get());
         log.debug("Created cap'd DBCollection (" + collName + ") with opts " + dbCapOpts);
       }
     }
 }
示例#2
0
  @Test
  public void testAnotherUpsert() {
    DBCollection collection = newCollection();
    BasicDBObjectBuilder queryBuilder =
        BasicDBObjectBuilder.start()
            .push("_id")
            .append("f", "ca")
            .push("1")
            .append("l", 2)
            .pop()
            .push("t")
            .append("t", 11)
            .pop()
            .pop();
    DBObject query = queryBuilder.get();

    DBObject update =
        BasicDBObjectBuilder.start()
            .push("$inc")
            .append("n.!", 1)
            .append("n.a.b:false", 1)
            .pop()
            .get();
    collection.update(query, update, true, false);

    DBObject expected =
        queryBuilder.push("n").append("!", 1).push("a").append("b:false", 1).pop().pop().get();
    assertEquals(expected, collection.findOne());
  }
  public static final DBObject createFilter(EventFilter filter) {

    BasicDBObjectBuilder builder = new BasicDBObjectBuilder();

    if (filter != null) {
      if (filter.getUser() != null) {
        builder.add("user_id", filter.getUser());
      } else if (filter.getProject() != null) {
        builder.add("project_id", filter.getProject());
      }
      if (filter.getMeter() != null) {
        builder.add("name", filter.getMeter());
      }
      if (filter.getStart() != null) {
        builder.add("start", new BasicDBObject("$gte", filter.getStart()));
      }
      if (filter.getEnd() != null) {
        builder.add("end", new BasicDBObject("$lt", filter.getEnd()));
      }
      if (filter.getResource() != null) {
        builder.add("resource_id", filter.getResource());
      }
      if (filter.getSource() != null) {
        builder.add("source", filter.getSource());
      }
    }

    return builder.get();
  }
  public void introduceType(SpaceTypeDescriptor typeDescriptor) {

    DBCollection m = getConnection().getCollection(METADATA_COLLECTION_NAME);

    BasicDBObjectBuilder builder =
        BasicDBObjectBuilder.start().add(Constants.ID_PROPERTY, typeDescriptor.getTypeName());
    try {
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      ObjectOutputStream out = new ObjectOutputStream(bos);
      IOUtils.writeObject(
          out, SpaceTypeDescriptorVersionedSerializationUtils.toSerializableForm(typeDescriptor));

      builder.add(TYPE_DESCRIPTOR_FIELD_NAME, bos.toByteArray());

      WriteResult wr = m.save(builder.get());

      if (logger.isTraceEnabled()) logger.trace(wr);

      indexBuilder.ensureIndexes(typeDescriptor);

    } catch (IOException e) {
      logger.error(e);

      throw new SpaceMongoException(
          "error occurs while serialize and save type descriptor: " + typeDescriptor, e);
    }
  }
示例#5
0
  @Override
  public DBObject toJSON() {
    BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();

    BasicDBList jsonList = new BasicDBList();

    Iterator<VoronoiSite> sitesIt = this.sites.iterator();
    while (sitesIt.hasNext()) {
      jsonList.add(sitesIt.next().toJSON());
    }
    builder.add("sites", jsonList);

    jsonList = new BasicDBList();
    Iterator<VoronoiCorner> cornersIt = this.corners.iterator();
    while (cornersIt.hasNext()) {
      jsonList.add(cornersIt.next().toJSON());
    }
    builder.add("corners", jsonList);

    jsonList = new BasicDBList();
    Iterator<VoronoiEdge> edgesIt = this.edges.iterator();
    while (edgesIt.hasNext()) {
      jsonList.add(edgesIt.next().toJSON());
    }
    builder.add("edges", jsonList);

    return builder.get();
  }
 /** Does a deep copy of an object to allow for subsequent modification */
 public static DBObject copyDBObject(DBObject dbObject) {
   DBObject orig = dbObject;
   BasicDBObjectBuilder dbObjectBuilder = BasicDBObjectBuilder.start();
   for (String field : orig.keySet()) {
     Object value = orig.get(field);
     dbObjectBuilder.add(field, value);
   }
   return dbObjectBuilder.get();
 }
 public void perform(BasicDBObjectBuilder builder) {
   BasicDBList list = new BasicDBList();
   for (Operator operator : operators) {
     BasicDBObjectBuilder operatorBuilder = new BasicDBObjectBuilder();
     operator.perform(operatorBuilder);
     list.add(operatorBuilder.get());
   }
   builder.append("$or", list);
 }
  public static DBObject toDBObject(Person p) {

    BasicDBObjectBuilder builder =
        BasicDBObjectBuilder.start()
            .append("name", p.getName())
            .append("surname", p.getSurname())
            .append("phone", p.getPhone());
    if (p.getId() != null) builder = builder.append("_id", new ObjectId(p.getId()));
    return builder.get();
  }
  /*
   * (non-Javadoc)
   * @see org.springframework.data.mongodb.core.query.CriteriaDefinition#getCriteriaObject()
   */
  @Override
  public DBObject getCriteriaObject() {

    BasicDBObjectBuilder builder = new BasicDBObjectBuilder();

    if (StringUtils.hasText(language)) {
      builder.add("$language", language);
    }

    if (!terms.isEmpty()) {
      builder.add("$search", join(terms));
    }

    return new BasicDBObject("$text", builder.get());
  }
    /**
     * Returns the current CommitEntry as a mongo DBObject.
     *
     * @return DBObject representing the CommitEntry
     */
    public DBObject asDBObject() {
      final BasicDBList events = new BasicDBList();
      BasicDBObjectBuilder commitBuilder =
          BasicDBObjectBuilder.start()
              .add(AGGREGATE_IDENTIFIER_PROPERTY, aggregateIdentifier)
              .add(SEQUENCE_NUMBER_PROPERTY, firstSequenceNumber)
              .add(LAST_SEQUENCE_NUMBER_PROPERTY, lastSequenceNumber)
              .add(FIRST_SEQUENCE_NUMBER_PROPERTY, firstSequenceNumber)
              .add(TIME_STAMP_PROPERTY, firstTimestamp)
              .add(FIRST_TIME_STAMP_PROPERTY, firstTimestamp)
              .add(LAST_TIME_STAMP_PROPERTY, lastTimestamp)
              .add(EVENTS_PROPERTY, events);

      for (EventEntry eventEntry : eventEntries) {
        events.add(eventEntry.asDBObject());
      }
      return commitBuilder.get();
    }
示例#11
0
  protected <T> void ensureIndex(
      Class<T> clazz,
      String name,
      BasicDBObject fields,
      boolean unique,
      boolean dropDupsOnCreate,
      boolean background,
      boolean sparse) {
    // validate field names and translate them to the stored values
    BasicDBObject keys = new BasicDBObject();
    for (Entry<String, Object> entry : fields.entrySet()) {
      StringBuffer sb = new StringBuffer(entry.getKey());
      Mapper.validate(clazz, mapr, sb, FilterOperator.IN, "", true, false);
      keys.put(sb.toString(), entry.getValue());
    }

    BasicDBObjectBuilder keyOpts = new BasicDBObjectBuilder();
    if (name != null && name.length() > 0) {
      keyOpts.add("name", name);
    }
    if (unique) {
      keyOpts.add("unique", true);
      if (dropDupsOnCreate) keyOpts.add("dropDups", true);
    }

    if (background) keyOpts.add("background", true);
    if (sparse) keyOpts.add("sparse", true);

    DBCollection dbColl = getCollection(clazz);

    BasicDBObject opts = (BasicDBObject) keyOpts.get();
    if (opts.isEmpty()) {
      log.debug("Ensuring index for " + dbColl.getName() + " with keys:" + keys);
      dbColl.ensureIndex(keys);
    } else {
      log.debug(
          "Ensuring index for " + dbColl.getName() + " with keys:" + keys + " and opts:" + opts);
      dbColl.ensureIndex(keys, opts);
    }

    // TODO: remove this once using 2.4 driver does this in ensureIndex
    CommandResult cr = dbColl.getDB().getLastError();
    cr.throwOnError();
  }
示例#12
0
  @SuppressWarnings({"rawtypes"})
  public void ensureIndex(
      Class clazz,
      String name,
      IndexFieldDef[] defs,
      boolean unique,
      boolean dropDupsOnCreate,
      boolean background) {
    BasicDBObjectBuilder keys = BasicDBObjectBuilder.start();

    for (IndexFieldDef def : defs) {
      String fieldName = def.getField();
      IndexDirection dir = def.getDirection();
      keys.add(fieldName, dir.toIndexValue());
    }

    ensureIndex(
        clazz, name, (BasicDBObject) keys.get(), unique, dropDupsOnCreate, background, false);
  }
  /**
   * Return an iterable of dictionaries containing resource information.
   *
   * @param user
   * @param project
   * @param source
   */
  public List<Resources.Resource> getResources(String source, String project, String user) {

    BasicDBObjectBuilder dboBuilder = new BasicDBObjectBuilder();

    if (source != null) {
      // dboBuilder.add("source", user);
    }

    if (project != null) {
      dboBuilder.add("project_id", user);
    }

    if (user != null) {
      dboBuilder.add("user_id", user);
    }

    DBCursor dbCursor = db.getCollection("resource").find(dboBuilder.get());
    List<Resources.Resource> resources = new ArrayList<Resources.Resource>();
    for (DBObject dbo : dbCursor) {
      Resources.Resource resource = new Resources.Resource();
      resource.setId((String) dbo.get("_id"));
      resource.setProjectId((String) dbo.get("project_id"));
      resource.setUserId((String) dbo.get("user_id"));
      resource.setTimestamp((Long) dbo.get("timestamp"));
      Object metadataDbo = dbo.get("metadata");
      // null System.out.println(metadataDbo.getClass().getCanonicalName());
      Metadata metadata = new Metadata();
      resource.setMetadata(metadata);
      List<Meter> meters = new ArrayList<Meter>();
      BasicDBList dbList = (BasicDBList) dbo.get("meter");
      for (Object o : dbList) {
        if (o != null && o instanceof DBObject) {
          DBObject meterDbo = (DBObject) o;
          Meter meter = new Meter();
          meter.setName((String) meterDbo.get("counter_name"));
          meter.setType((String) meterDbo.get("counter_type"));
        }
      }
      resource.setMeters(meters);
      resources.add(resource);
    }
    return resources;
  }
  private static DBObject normalize(DBObject obj) {
    BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();

    Iterator<String> iterator = obj.keySet().iterator();
    builder.push("$set");
    while (iterator.hasNext()) {

      String key = iterator.next();

      if (Constants.ID_PROPERTY.equals(key)) continue;

      Object value = obj.get(key);

      if (value == null) continue;

      builder.add(key, value);
    }

    return builder.get();
  }
示例#15
0
  @SuppressWarnings("rawtypes")
  public <T> MapreduceResults<T> mapReduce(
      MapreduceType type,
      Query query,
      String map,
      String reduce,
      String finalize,
      Map<String, Object> scopeFields,
      Class<T> outputType) {
    Assert.parametersNotNull("map", map);
    Assert.parameterNotEmpty(map, "map");
    Assert.parametersNotNull("reduce", reduce);
    Assert.parameterNotEmpty(reduce, "reduce");

    QueryImpl<T> qi = (QueryImpl<T>) query;

    DBCollection dbColl = qi.getCollection();
    // TODO remove this after testing.
    if (dbColl == null) dbColl = getCollection(qi.getEntityClass());

    if (log.isTraceEnabled())
      log.info(
          "Executing mapReduce("
              + dbColl.getName()
              + ") with query("
              + qi.toString()
              + ") map("
              + map
              + ") reduce("
              + reduce
              + ") finalize("
              + finalize
              + ") scope("
              + scopeFields
              + ")");

    // TODO replace this with the 2.4 driver impl.
    String outColl = mapr.getCollectionName(outputType);
    BasicDBObjectBuilder bldr =
        BasicDBObjectBuilder.start("mapreduce", mapr.getCollectionName(qi.getEntityClass()));

    switch (type) {
      case REDUCE:
        bldr.push("out").add("reduce", outColl).pop();
        break;
      case MERGE:
        bldr.push("out").add("merge", outColl).pop();
        break;
      case INLINE:
        bldr.push("out").add("inline", 1).pop();
        break;
      default:
        bldr.add("out", outColl);
        break;
    }

    if (qi.getOffset() != 0 || qi.getFieldsObject() != null)
      throw new QueryException(
          "mapReduce does not allow the offset/retrievedFields query options.");

    if (qi.getQueryObject() != null) bldr.add("query", qi.getQueryObject());
    if (qi.getLimit() > 0) bldr.add("limit", qi.getLimit());
    if (qi.getSortObject() != null) bldr.add("sort", qi.getSortObject());

    bldr.add("map", map);
    bldr.add("reduce", reduce);

    if (finalize != null && finalize.length() > 0) bldr.add("finalize", finalize);

    if (scopeFields != null && scopeFields.size() > 0)
      bldr.add("scope", mapr.toMongoObject(null, null, scopeFields));

    DBObject dbObj = bldr.get();
    CommandResult cr = dbColl.getDB().command(dbObj);
    cr.throwOnError();
    MapreduceResults mrRes =
        (MapreduceResults) mapr.fromDBObject(MapreduceResults.class, cr, createCache());

    QueryImpl baseQ = null;
    if (!MapreduceType.INLINE.equals(type))
      baseQ = new QueryImpl(outputType, db.getCollection(mrRes.getOutputCollectionName()), this);
    // TODO Handle inline case and create an iterator/able.

    mrRes.setBits(type, baseQ);
    return mrRes;
  }
  public DBObject buildDbObject(JSONObject jsonObject) {

    if (!check(jsonObject)) {
      return null;
    }

    BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();
    JSONObject mobile = jsonObject.getJSONObject(FieldName.Tanx.mobile);
    JSONObject device = mobile.getJSONObject(FieldName.Tanx.device);
    String deviceId = device.getString(FieldName.Tanx.device_id);

    // 过滤非法deviceId
    if (deviceId.contains("000000000000000") || deviceId.contains(":")) {
      logger.info("=== ignore deviceId:{}", deviceId);
      return null;
    }

    // 新增, 不更新的
    BasicDBObject setObj =
        new BasicDBObject(FieldName.field_deviceId, deviceId)
            .append(FieldName.field_deviceIdMd5, DigestUtils.md5Hex(deviceId))
            .append(FieldName.field_deviceIdSha1, DigestUtils.sha1Hex(deviceId));

    // brand
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.brand))) {
      setObj.append(FieldName.field_brand, device.getString(FieldName.Tanx.brand));
    }
    // model
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.model))) {
      setObj.append(FieldName.field_model, device.getString(FieldName.Tanx.model));
    }
    // platform
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.platform))) {
      setObj.append(FieldName.field_platform, device.getString(FieldName.Tanx.platform));
    }
    // os
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.os))) {
      setObj.append(FieldName.field_os, device.getString(FieldName.Tanx.os));
    }
    // os_version
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.os_version))) {
      setObj.append(FieldName.field_osVersion, device.getString(FieldName.Tanx.os_version));
    }
    // mac
    String mac = device.getString(FieldName.Tanx.mac);
    if (StringUtils.isNotBlank(mac) && mac.contains(":")) {
      setObj
          .append(FieldName.field_mac, mac)
          .append(FieldName.field_macMd5, DigestUtils.md5Hex(mac))
          .append(FieldName.field_macSha1, DigestUtils.sha1Hex(mac));
    }
    // device_size
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.device_size))) {
      setObj.append(FieldName.field_deviceSize, device.getString(FieldName.Tanx.device_size));
    }

    // builder.add(MongoSink.OP_SET_ON_INSERT, setObj);

    BasicDBObject addToSetObj = new BasicDBObject();

    // ip
    if (StringUtils.isNotBlank(jsonObject.getString(FieldName.Tanx.ip))) {
      addToSetObj.append(FieldName.field_ipList, jsonObject.getString(FieldName.Tanx.ip));
    }

    // 城市名称
    if (StringUtils.isNotBlank(jsonObject.getString(FieldName.Tanx.city))) {
      addToSetObj.append(FieldName.field_cityList, jsonObject.getString(FieldName.Tanx.city));
    }

    // 追加的数据,geo
    if (StringUtils.isNotBlank(device.getString(FieldName.Tanx.latitude))
        && StringUtils.isNotBlank(device.getString(FieldName.Tanx.longitude))) {
      addToSetObj.append(
          FieldName.field_geoList,
          new BasicDBObject(FieldName.field_latitude, device.getString(FieldName.Tanx.latitude))
              .append(FieldName.field_longitude, device.getString(FieldName.Tanx.longitude)));
    }

    builder.add(MongoSink.OP_ADD_TO_SET, addToSetObj);

    // app
    if (StringUtils.isNotBlank(mobile.getString(FieldName.Tanx.package_name))) {

      BasicDBObject appObj = new BasicDBObject();
      appObj.append(FieldName.field_packageName, mobile.getString(FieldName.Tanx.package_name));
      if (StringUtils.isNotBlank(mobile.getString(FieldName.Tanx.app_name))) {
        appObj.append(FieldName.field_appName, mobile.getString(FieldName.Tanx.app_name));
      }

      // app分类
      if (mobile.getJSONArray(FieldName.Tanx.app_categories) != null
          && !mobile.getJSONArray(FieldName.Tanx.app_categories).isEmpty()) {
        appObj.append(
            FieldName.field_appCategorys,
            mobile
                .getJSONArray(FieldName.Tanx.app_categories)
                .getJSONObject(0)
                .getString(FieldName.Tanx.id));
      }

      if (StringUtils.isNotBlank(jsonObject.getString(FieldName.bidRequestTime))) {
        appObj.append(FieldName.lastUseTime, jsonObject.getString(FieldName.bidRequestTime));
      }

      // mongo 不支持包含点. 的做key, 替换为_下划线
      setObj.append(
          FieldName.field_appList + mobile.getString(FieldName.Tanx.package_name).replace(".", "_"),
          appObj);
    }

    if (addToSetObj.isEmpty()) {
      return null;
    }

    // app需要记录最后使用日期, 每次都更新
    builder.add(MongoSink.OP_SET, setObj);

    return builder.get();
  }