/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.waveprotocol.box.server.persistence.mongodb;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.wave.api.Context;
import com.google.wave.api.ProtocolVersion;
import com.google.wave.api.event.EventType;
import com.google.wave.api.robot.Capability;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.MongoException;
import com.mongodb.gridfs.GridFS;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSInputFile;
import org.bson.types.BasicBSONList;
import org.waveprotocol.box.attachment.AttachmentMetadata;
import org.waveprotocol.box.server.account.AccountData;
import org.waveprotocol.box.server.account.HumanAccountData;
import org.waveprotocol.box.server.account.HumanAccountDataImpl;
import org.waveprotocol.box.server.account.RobotAccountData;
import org.waveprotocol.box.server.account.RobotAccountDataImpl;
import org.waveprotocol.box.server.authentication.PasswordDigest;
import org.waveprotocol.box.server.persistence.AccountStore;
import org.waveprotocol.box.server.persistence.AttachmentStore;
import org.waveprotocol.box.server.persistence.PersistenceException;
import org.waveprotocol.box.server.persistence.SignerInfoStore;
import org.waveprotocol.box.server.robots.RobotCapabilities;
import org.waveprotocol.wave.crypto.SignatureException;
import org.waveprotocol.wave.crypto.SignerInfo;
import org.waveprotocol.wave.federation.Proto.ProtocolSignerInfo;
import org.waveprotocol.wave.media.model.AttachmentId;
import org.waveprotocol.wave.model.util.CollectionUtils;
import org.waveprotocol.wave.model.wave.ParticipantId;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* <b>CertPathStore:</b><br/>
* <i>Collection(signerInfo):</i>
* <ul>
* <li>_id : signerId byte array.</li>
* <li>protoBuff : byte array representing the protobuff message of a
* {@link ProtocolSignerInfo}.</li>
* </ul>
* <p>
*
* @author ljvderijk@google.com (Lennard de Rijk)
* @author josephg@gmail.com (Joseph Gentle)
*
*/
public final class MongoDbStore implements SignerInfoStore, AttachmentStore, AccountStore {
private static final String ACCOUNT_COLLECTION = "account";
private static final String ACCOUNT_HUMAN_DATA_FIELD = "human";
private static final String ACCOUNT_ROBOT_DATA_FIELD = "robot";
private static final String HUMAN_PASSWORD_FIELD = "passwordDigest";
private static final String PASSWORD_DIGEST_FIELD = "digest";
private static final String PASSWORD_SALT_FIELD = "salt";
private static final String ROBOT_URL_FIELD = "url";
private static final String ROBOT_SECRET_FIELD = "secret";
private static final String ROBOT_CAPABILITIES_FIELD = "capabilities";
private static final String ROBOT_VERIFIED_FIELD = "verified";
private static final String CAPABILITIES_VERSION_FIELD = "version";
private static final String CAPABILITIES_HASH_FIELD = "capabilitiesHash";
private static final String CAPABILITIES_CAPABILITIES_FIELD = "capabilities";
private static final String CAPABILITY_CONTEXTS_FIELD = "contexts";
private static final String CAPABILITY_FILTER_FIELD = "filter";
private static final Logger LOG = Logger.getLogger(MongoDbStore.class.getName());
private final DB database;
MongoDbStore(DB database) {
this.database = database;
}
@Override
public void initializeSignerInfoStore() throws PersistenceException {
// Nothing to initialize
}
@Override
public SignerInfo getSignerInfo(byte[] signerId) {
DBObject query = getDBObjectForSignerId(signerId);
DBCollection signerInfoCollection = getSignerInfoCollection();
DBObject signerInfoDBObject = signerInfoCollection.findOne(query);
// Sub-class contract specifies return null when not found
SignerInfo signerInfo = null;
if (signerInfoDBObject != null) {
byte[] protobuff = (byte[]) signerInfoDBObject.get("protoBuff");
try {
signerInfo = new SignerInfo(ProtocolSignerInfo.parseFrom(protobuff));
} catch (InvalidProtocolBufferException e) {
LOG.log(Level.SEVERE, "Couldn't parse the protobuff stored in MongoDB: " + protobuff, e);
} catch (SignatureException e) {
LOG.log(Level.SEVERE, "Couldn't parse the certificate chain or domain properly", e);
}
}
return signerInfo;
}
@Override
public void putSignerInfo(ProtocolSignerInfo protocolSignerInfo) throws SignatureException {
SignerInfo signerInfo = new SignerInfo(protocolSignerInfo);
byte[] signerId = signerInfo.getSignerId();
// Not using a modifier here because rebuilding the object is not a lot of
// work. Doing implicit upsert by using save with a DBOBject that has an _id
// set.
DBObject signerInfoDBObject = getDBObjectForSignerId(signerId);
signerInfoDBObject.put("protoBuff", protocolSignerInfo.toByteArray());
getSignerInfoCollection().save(signerInfoDBObject);
}
/**
* Returns an instance of {@link DBCollection} for storing SignerInfo.
*/
private DBCollection getSignerInfoCollection() {
return database.getCollection("signerInfo");
}
/**
* Returns a {@link DBObject} which contains the key-value pair used to
* signify the signerId.
*
* @param signerId the signerId value to set.
* @return a new {@link DBObject} with the (_id,signerId) entry.
*/
private DBObject getDBObjectForSignerId(byte[] signerId) {
DBObject query = new BasicDBObject();
query.put("_id", signerId);
return query;
}
// *********** Attachments.
private GridFS attachmentGrid;
private GridFS getAttachmentGrid() {
if (attachmentGrid == null) {
attachmentGrid = new GridFS(database, "attachments");
}
return attachmentGrid;
}
@Override
public AttachmentData getAttachment(AttachmentId attachmentId) {
final GridFSDBFile attachment = getAttachmentGrid().findOne(attachmentId.serialise());
if (attachment == null) {
return null;
} else {
return new AttachmentData() {
@Override
public InputStream getInputStream() throws IOException {
return attachment.getInputStream();
}
@Override
public long getSize() {
return attachment.getLength();
}
};
}
}
@Override
public void storeAttachment(AttachmentId attachmentId, InputStream data)
throws IOException {
GridFSInputFile file = getAttachmentGrid().createFile(data, attachmentId.serialise());
try {
file.save();
} catch (MongoException e) {
// Unfortunately, file.save() wraps any IOException thrown in a
// 'MongoException'. Since the interface explicitly throws IOExceptions,
// we unwrap any IOExceptions thrown.
Throwable innerException = e.getCause();
if (innerException instanceof IOException) {
throw (IOException) innerException;
} else {
throw e;
}
}
}
@Override
public void deleteAttachment(AttachmentId attachmentId) {
getAttachmentGrid().remove(attachmentId.serialise());
}
@Override
public AttachmentMetadata getMetadata(AttachmentId attachmentId) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public AttachmentData getThumbnail(AttachmentId attachmentId) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void storeMetadata(AttachmentId attachmentId, AttachmentMetadata metaData) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public void storeThumbnail(AttachmentId attachmentId, InputStream dataData) throws IOException {
throw new UnsupportedOperationException("Not supported yet.");
}
// ******** AccountStore
@Override
public void initializeAccountStore() throws PersistenceException {
// TODO: Sanity checks not handled by MongoDBProvider???
}
@Override
public AccountData getAccount(ParticipantId id) {
DBObject query = getDBObjectForParticipant(id);
DBObject result = getAccountCollection().findOne(query);
if (result == null) {
return null;
}
DBObject human = (DBObject) result.get(ACCOUNT_HUMAN_DATA_FIELD);
if (human != null) {
return objectToHuman(id, human);
}
DBObject robot = (DBObject) result.get(ACCOUNT_ROBOT_DATA_FIELD);
if (robot != null) {
return objectToRobot(id, robot);
}
throw new IllegalStateException("DB object contains neither a human nor a robot");
}
@Override
public void putAccount(AccountData account) {
DBObject object = getDBObjectForParticipant(account.getId());
if (account.isHuman()) {
object.put(ACCOUNT_HUMAN_DATA_FIELD, humanToObject(account.asHuman()));
} else if (account.isRobot()) {
object.put(ACCOUNT_ROBOT_DATA_FIELD, robotToObject(account.asRobot()));
} else {
throw new IllegalStateException("Account is neither a human nor a robot");
}
getAccountCollection().save(object);
}
@Override
public void removeAccount(ParticipantId id) {
DBObject object = getDBObjectForParticipant(id);
getAccountCollection().remove(object);
}
private DBObject getDBObjectForParticipant(ParticipantId id) {
DBObject query = new BasicDBObject();
query.put("_id", id.getAddress());
return query;
}
private DBCollection getAccountCollection() {
return database.getCollection(ACCOUNT_COLLECTION);
}
// ****** HumanAccountData serialization
private DBObject humanToObject(HumanAccountData account) {
DBObject object = new BasicDBObject();
PasswordDigest digest = account.getPasswordDigest();
if (digest != null) {
DBObject digestObj = new BasicDBObject();
digestObj.put(PASSWORD_SALT_FIELD, digest.getSalt());
digestObj.put(PASSWORD_DIGEST_FIELD, digest.getDigest());
object.put(HUMAN_PASSWORD_FIELD, digestObj);
}
return object;
}
private HumanAccountData objectToHuman(ParticipantId id, DBObject object) {
PasswordDigest passwordDigest = null;
DBObject digestObj = (DBObject) object.get(HUMAN_PASSWORD_FIELD);
if (digestObj != null) {
byte[] salt = (byte[]) digestObj.get(PASSWORD_SALT_FIELD);
byte[] digest = (byte[]) digestObj.get(PASSWORD_DIGEST_FIELD);
passwordDigest = PasswordDigest.from(salt, digest);
}
return new HumanAccountDataImpl(id, passwordDigest);
}
// ****** RobotAccountData serialization
private DBObject robotToObject(RobotAccountData account) {
return new BasicDBObject()
.append(ROBOT_URL_FIELD, account.getUrl())
.append(ROBOT_SECRET_FIELD, account.getConsumerSecret())
.append(ROBOT_CAPABILITIES_FIELD, capabilitiesToObject(account.getCapabilities()))
.append(ROBOT_VERIFIED_FIELD, account.isVerified());
}
private DBObject capabilitiesToObject(RobotCapabilities capabilities) {
if (capabilities == null) {
return null;
}
BasicDBObject capabilitiesObj = new BasicDBObject();
for (Capability capability : capabilities.getCapabilitiesMap().values()) {
BasicBSONList contexts = new BasicBSONList();
for (Context c : capability.getContexts()) {
contexts.add(c.name());
}
capabilitiesObj.put(capability.getEventType().name(),
new BasicDBObject()
.append(CAPABILITY_CONTEXTS_FIELD, contexts)
.append(CAPABILITY_FILTER_FIELD, capability.getFilter()));
}
BasicDBObject object =
new BasicDBObject()
.append(CAPABILITIES_CAPABILITIES_FIELD, capabilitiesObj)
.append(CAPABILITIES_HASH_FIELD, capabilities.getCapabilitiesHash())
.append(CAPABILITIES_VERSION_FIELD, capabilities.getProtocolVersion().name());
return object;
}
private AccountData objectToRobot(ParticipantId id, DBObject robot) {
String url = (String) robot.get(ROBOT_URL_FIELD);
String secret = (String) robot.get(ROBOT_SECRET_FIELD);
RobotCapabilities capabilities =
objectToCapabilities((DBObject) robot.get(ROBOT_CAPABILITIES_FIELD));
boolean verified = (Boolean) robot.get(ROBOT_VERIFIED_FIELD);
return new RobotAccountDataImpl(id, url, secret, capabilities, verified);
}
@SuppressWarnings("unchecked")
private RobotCapabilities objectToCapabilities(DBObject object) {
if (object == null) {
return null;
}
Map<String, Object> capabilitiesObj =
(Map<String, Object>) object.get(CAPABILITIES_CAPABILITIES_FIELD);
Map<EventType, Capability> capabilities = CollectionUtils.newHashMap();
for (Entry<String, Object> capability : capabilitiesObj.entrySet()) {
EventType eventType = EventType.valueOf(capability.getKey());
List<Context> contexts = CollectionUtils.newArrayList();
DBObject capabilityObj = (DBObject) capability.getValue();
DBObject contextsObj = (DBObject) capabilityObj.get(CAPABILITY_CONTEXTS_FIELD);
for (String contextId : contextsObj.keySet()) {
contexts.add(Context.valueOf((String) contextsObj.get(contextId)));
}
String filter = (String) capabilityObj.get(CAPABILITY_FILTER_FIELD);
capabilities.put(eventType, new Capability(eventType, contexts, filter));
}
String capabilitiesHash = (String) object.get(CAPABILITIES_HASH_FIELD);
ProtocolVersion version =
ProtocolVersion.valueOf((String) object.get(CAPABILITIES_VERSION_FIELD));
return new RobotCapabilities(capabilities, capabilitiesHash, version);
}
}