Java Code Examples for com.mongodb.CommandResult#ok()

@Override
public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
    Object ret) throws Throwable {
    AbstractSpan activeSpan = ContextManager.activeSpan();
    CommandResult cresult = null;
    if (ret instanceof WriteResult) {
        WriteResult wresult = (WriteResult) ret;
        cresult = wresult.getCachedLastError();
    } else if (ret instanceof AggregationOutput) {
        AggregationOutput aresult = (AggregationOutput) ret;
        cresult = aresult.getCommandResult();
    }
    if (null != cresult && !cresult.ok()) {
        activeSpan.log(cresult.getException());
    }
    ContextManager.stopSpan();
    return ret;
}
 

/**
 * get list of  the shards
 * @param dbConn
 * @return
 */
private static List<String> getShards(DB dbConn) {
    List<String> shards = new ArrayList<String>();

    DBObject listShardsCmd = new BasicDBObject("listShards", 1);
    CommandResult res = dbConn.command(listShardsCmd);
    if (!res.ok()) {
        LOG.error("Error getting shards for {}: {}", dbConn, res.getErrorMessage());
    }

    BasicDBList listShards = (BasicDBList) res.get("shards");

    //Only get shards for sharding mongo
    if (listShards != null) {
        ListIterator<Object> iter = listShards.listIterator();

        while (iter.hasNext()) {
            BasicDBObject shard = (BasicDBObject) iter.next();
            shards.add(shard.getString(ID));
        }
    }
    return shards;
}
 

/**
 * set the state of balancer.
 *
 * @param dbConn
 * @param state
 * @return Error description, or null if no errors
 */
private static String setBalancerState(DB dbConn, boolean state) {
    DBObject balancer = new BasicDBObject(ID, "balancer");
    DBObject updateObj = new BasicDBObject();
    String stopped = state ? "false" : "true";
    updateObj.put("$set", new BasicDBObject("stopped", stopped));
    WriteResult wresult = dbConn.getSisterDB("config").getCollection("settings").update(balancer, updateObj, true, false);
    if (wresult != null) {
        CommandResult result = wresult.getLastError();
        if (!result.ok()) {
            LOG.error("Error setting balancer state to {}: {}", state, result.getErrorMessage());
            return result.getErrorMessage();
        }
    }
    return null;
}
 

public boolean ping() {
    MongoClient client = fastClient();
    DBObject command = new BasicDBObject("ping", "1");
    final DB db = client.getDB("admin");

    try {
        CommandResult status = db.command(command);
        return status.ok();
    } catch (MongoException e) {
        LOG.warn("Pinging server {} failed with {}", address.getHost(), e);
    } finally {
        client.close();
    }
    return false;
}
 

@Override
public <T> int update(Class<T> entityClass, String[] fields, Object[] fieldValues, Serializable id) {
	WriteResult result = operations.updateFirst(new Query(where("_id").is(id)), setFieldValue(fields, fieldValues), entityClass);
	CommandResult commandResult = result.getLastError();
	if(commandResult.ok()){
		return 1;
	}
	throw new DaoException(commandResult.getErrorMessage());
}
 

/**
 * Pre-split database
 * @param shardCollections: the set of collections to be split
 * @param dbName
 * @param mongoTemplate
 * @return Error description, or null if no errors
 */
public static String preSplit(Set<String> shardCollections, String dbName, MongoTemplate mongoTemplate) {
    DB dbConn = mongoTemplate.getDb().getSisterDB("admin");

    //Don't do anything if it is non-sharded
    List<String> shards = getShards(dbConn);
    if (shards.size() == 0) {
        return null;
    }

    //set balancer off
    String sresult = setBalancerState(dbConn, false);
    if (sresult != null) {
        return sresult;
    }

    // Enable sharding for this database
    DBObject enableShard = new BasicDBObject("enableSharding", dbName);
    CommandResult result = dbConn.command(enableShard);
    if (!result.ok()) {
        LOG.error("Error enabling sharding on {}: {}", dbConn, result.getErrorMessage());
        return result.getErrorMessage();
    }

    for (String coll : shardCollections) {
        String collection = dbName + "." + coll;

        // Enable sharding for this collection, sharding on _id
        DBObject shardColl = new BasicDBObject();
        shardColl.put("shardCollection", collection);
        shardColl.put("key", new BasicDBObject(ID, 1));
        result = dbConn.command(shardColl);
        if (!result.ok()) {
            LOG.error("Error enabling shard'ing on {}: {}", collection, result.getErrorMessage());
           return result.getErrorMessage();
        }

        sresult = moveChunks(collection, shards, dbConn);
        if (sresult != null) {
            return sresult;
        }
    }
    return preSplitBinCollections(dbName, mongoTemplate);
}
 

private static String preSplitBinCollections(String dbName,  MongoTemplate mongoTemplate) {
    DB dbConn = mongoTemplate.getDb().getSisterDB("admin");
    List<String> shards = getShards(dbConn);
    if (shards != null && shards.size() > 0) {
        int numShards = shards.size();
        List<String> collections = Arrays.asList("recordHash", "deltas");
        for (String collectionName: collections) {
            LOG.info("Shard count = {}. Setting up sharding config for {}!", numShards, collectionName);
            String collection = dbName + "." + collectionName;
            DBObject shardColl = new BasicDBObject();
            shardColl.put("shardCollection", collection);
            shardColl.put("key", new BasicDBObject(ID, 1));
            CommandResult result = dbConn.command(shardColl);
            if (!result.ok()) {
                LOG.error("Error enabling shard'ing on recordHash: {}", result.getErrorMessage());
                return result.getErrorMessage();
            }
            int charOffset = 256 / numShards;
            List<byte[]> shardPoints = new ArrayList<byte[]>();
            shardPoints.add(null);
            for (int shard = 1; shard < numShards; shard++) {
                String splitString = Integer.toHexString(charOffset * shard);
                if (splitString.length() < 2) {
                    splitString = "0" + splitString;
                }

                splitString = splitString + STR_0X38;
                byte[] splitPoint = RecordHash.hex2Binary(splitString);
                shardPoints.add(splitPoint);
                LOG.info("Adding recordHash splitPoint [" + RecordHash.binary2Hex(splitPoint) + "]");

                DBObject splitCmd = new BasicDBObject();
                splitCmd.put("split", collection);
                splitCmd.put("middle", new BasicDBObject(ID, splitPoint));
                result = dbConn.command(splitCmd);
                if (!result.ok()) {
                    LOG.error("Error splitting chunk in recordHash: {}", result.getErrorMessage());
                    return result.getErrorMessage();
                }
            }
            for (int index = 0; index < numShards; index++) {
                DBObject moveCommand = new BasicDBObject();
                moveCommand.put("moveChunk", collection);
                moveCommand.put("find", new BasicDBObject(ID, index == 0 ? "$minkey" : shardPoints.get(index)));
                moveCommand.put("to", shards.get(index));
                result = dbConn.command(moveCommand);
                if (!result.ok()) {
                    if (!result.getErrorMessage().equals("that chunk is already on that shard")) {
                        LOG.error("Error moving chunk in recordHash: {}", result.getErrorMessage());
                        return result.getErrorMessage();
                    }
                }
            }
        }
    } else {
        LOG.info("No shards or shard count < 0. Not setting sharding config for recordHash!");
    }
    return null;
}