${foo.title}
Showing: ${page.resultFrom} - ${page.resultTo} of total ${page.totalResults} <%-- handle navigation --%>
${foo.title}
Showing: ${page.resultFrom} - ${page.resultTo} of total ${page.totalResults} <%-- handle navigation --%>
Represents an in-line document attachment. *
On saving, the fields 'data' holds the base64 encoded data, * and 'contentType' holds the Content-Type of the attachment. * @author Ahmed Yehia */ public class Attachment { private String data; @SerializedName("content_type") private String contentType; private int revpos; private String digest; private long length; private boolean stub; public String getData() { return data; } public String getContentType() { return contentType; } public int getRevpos() { return revpos; } public String getDigest() { return digest; } public long getLength() { return length; } public boolean isStub() { return stub; } public void setData(String data) { this.data = data; } public void setContentType(String contentType) { this.contentType = contentType; } public void setRevpos(int revpos) { this.revpos = revpos; } public void setDigest(String digest) { this.digest = digest; } public void setLength(long length) { this.length = length; } public void setStub(boolean stub) { this.stub = stub; } } LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Changes.java 0000664 0000000 0000000 00000011127 12150357216 0025470 0 ustar 00root root 0000000 0000000 /* * Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com) * * Licensed 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.lightcouch; import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.URI; import org.apache.http.client.methods.HttpGet; import org.lightcouch.ChangesResult.Row; import com.google.gson.Gson; /** *
Contains the Change Notifications API, supports change feeds of types normal * and continuous. *
* // feed type normal
* ChangesResult result = dbClient.changes()
* .since("seq-value") // *
* .limit(10)
* .filter("example/filter")
* .getChanges();
*
* // feed type continuous
* Changes changes = dbClient.changes()
* .includeDocs(true)
* .heartBeat(30000)
* .continuousChanges();
*
* while (changes.hasNext()) {
* ChangesResult.Row feed = changes.next();
* // changes.stop(); // stop continuous feed
* }
*
* * Getting changes since latest update may be obtained by: *
* CouchDbInfo dbInfo = dbClient.context().info();
* String since = dbInfo.getUpdateSeq();
*
* @see ChangesResult
* @author Ahmed Yehia
*/
public class Changes {
private BufferedReader reader;
private HttpGet httpGet;
private Row nextRow;
private boolean stop;
private CouchDbClient dbc;
private Gson gson;
private URIBuilder uriBuilder;
Changes(CouchDbClient dbc) {
this.dbc = dbc;
this.gson = dbc.getGson();
this.uriBuilder = URIBuilder.builder(dbc.getDBUri()).path("_changes");
}
/**
* Requests Change notifications of feed type continuous.
*
Feed notifications are accessed in an iterator style.
*/
public Changes continuousChanges() {
URI uri = uriBuilder.query("feed", "continuous").build();
httpGet = new HttpGet(uri);
InputStream in = dbc.get(httpGet);
InputStreamReader is = new InputStreamReader(in);
setReader(new BufferedReader(is));
return this;
}
/**
* Checks whether a feed is available in the continuous stream, blocking
* until a feed is received.
*/
public boolean hasNext() {
return readNextRow();
}
/**
* @return The next feed in the stream.
*/
public Row next() {
return getNextRow();
}
/**
* Stops a running continuous feed.
*/
public void stop() {
stop = true;
}
/**
* Requests Change notifications of feed type normal.
*/
public ChangesResult getChanges() {
URI uri = uriBuilder.query("feed", "normal").build();
return dbc.get(uri, ChangesResult.class);
}
// -------------------------------- Query Params
public Changes since(String since) {
uriBuilder.query("since", since);
return this;
}
public Changes limit(int limit) {
uriBuilder.query("limit", limit);
return this;
}
public Changes heartBeat(long heartBeat) {
uriBuilder.query("heartbeat", heartBeat);
return this;
}
public Changes timeout(long timeout) {
uriBuilder.query("timeout", timeout);
return this;
}
public Changes filter(String filter) {
uriBuilder.query("filter", filter);
return this;
}
public Changes includeDocs(boolean includeDocs) {
uriBuilder.query("include_docs", includeDocs);
return this;
}
public Changes style(String style) {
uriBuilder.query("style", style);
return this;
}
//---------------------------------------- Private
/**
* Reads and sets the next feed in the stream.
*/
private boolean readNextRow() {
boolean hasNext = false;
try {
if(!stop) {
String row = getReader().readLine();
if(row != null && !row.startsWith("{\"last_seq\":")) {
setNextRow(gson.fromJson(row, Row.class));
hasNext = true;
}
}
} catch (Exception e) {
terminate();
throw new CouchDbException("Error reading continuous stream.", e);
}
if(!hasNext)
terminate();
return hasNext;
}
private BufferedReader getReader() {
return reader;
}
private void setReader(BufferedReader reader) {
this.reader = reader;
}
private Row getNextRow() {
return nextRow;
}
private void setNextRow(Row nextRow) {
this.nextRow = nextRow;
}
private void terminate() {
httpGet.abort();
CouchDbUtil.close(getReader());
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/ChangesResult.java 0000664 0000000 0000000 00000004452 12150357216 0026672 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import java.util.List;
import com.google.gson.JsonObject;
import com.google.gson.annotations.SerializedName;
/**
*
Represents a Change notifications feed result.
* @see Changes
* @author Ahmed Yehia
*
*/
public class ChangesResult {
private List results;
@SerializedName("last_seq")
private String lastSeq;
public List getResults() {
return results;
}
public void setResults(List results) {
this.results = results;
}
public String getLastSeq() {
return lastSeq;
}
public void setLastSeq(String lastSeq) {
this.lastSeq = lastSeq;
}
/**
* Represent a row in Changes result.
*/
public static class Row {
private String seq;
private String id;
private List changes;
private boolean deleted;
private JsonObject doc;
public String getSeq() {
return seq;
}
public void setSeq(String seq) {
this.seq = seq;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List getChanges() {
return changes;
}
public void setChanges(List changes) {
this.changes = changes;
}
public boolean isDeleted() {
return deleted;
}
public void setDeleted(boolean deleted) {
this.deleted = deleted;
}
public JsonObject getDoc() {
return doc;
}
public void setDoc(JsonObject doc) {
this.doc = doc;
}
/**
* Represent a Change rev.
*/
public static class Rev {
private String rev;
public String getRev() {
return rev;
}
public void setRev(String rev) {
this.rev = rev;
}
} // end class Rev
} // end class Row
} // end class ChangesResult
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbClient.java 0000664 0000000 0000000 00000036302 12150357216 0026570 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static org.lightcouch.CouchDbUtil.assertNotEmpty;
import static org.lightcouch.CouchDbUtil.close;
import static org.lightcouch.CouchDbUtil.generateUUID;
import static org.lightcouch.CouchDbUtil.getElement;
import static org.lightcouch.CouchDbUtil.streamToString;
import static org.lightcouch.URIBuilder.builder;
import java.io.InputStream;
import java.net.URI;
import java.util.List;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPut;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
/**
* Presents a client to a CouchDB database instance.
*
This is the main class to use to gain access to the various APIs defined by this client.
*
*
Usage Example:
* Instantiating an instance of this class requires configuration options to be supplied.
* Properties files may be used for this purpose. See overloaded constructors for available options.
*
A typical example for creating an instance is by preparing a properties file named
* couchdb.properties and placing it in your application classpath:
*
*
* couchdb.name=my-db
* couchdb.createdb.if-not-exist=true
* couchdb.protocol=http
* couchdb.host=127.0.0.1
* couchdb.port=5984
* couchdb.username=
* couchdb.password=
*
*
* Then construct a new instance using the default constructor:
*
* CouchDbClient dbClient = new CouchDbClient(); // looks for classpath:couchdb.properties
* // access the API here
*
* Multiple client instances could be created to handle multiple database instances simultaneously in a thread-safe manner,
* typically one client for each database.
*
*
A client instance provides access to various APIs, accessible under several locations or contexts.
*
Document APIs are available directly under this instance:
*
* Foo foo = dbClient.find(Foo.class, "some-id");
*
*
* Design documents API under the context design() {@link CouchDbDesign} contains usage example.
*
*
View APIs under the context view() {@link View} contains usage examples.
*
*
Change Notifications API under the context changes() see {@link Changes} for usage example.
*
*
Replication APIs under two contexts: replication() and replicator(),
* the latter supports the replicator database introduced with CouchDB v 1.1.0
* {@link Replication} and {@link Replicator} provide usage examples.
*
*
Database APIs under the context context()
*
*
After completing usage of this client, it might be useful to shutdown it's
* underlying connection manager to ensure proper release of resources:
* dbClient.shutdown()
*
* @author Ahmed Yehia
*
*/
public final class CouchDbClient extends CouchDbClientBase {
// -------------------------------------------------------------------------- Constructors
/**
* Constructs a new instance of this class, expects a configuration file named
* couchdb.properties to be available in your application classpath.
*/
public CouchDbClient() {
super();
}
/**
* Constructs a new instance of this class.
* @param configFileName The configuration file name.
*/
public CouchDbClient(String configFileName) {
super(new CouchDbConfig(configFileName));
}
/**
* Constructs a new instance of this class.
* @param dbName The database name.
* @param createDbIfNotExist To create a new database if it does not already exist.
* @param protocol The protocol to use (i.e http or https)
* @param host The database host address
* @param port The database listening port
* @param username The Username credential
* @param password The Password credential
*/
public CouchDbClient(String dbName, boolean createDbIfNotExist,
String protocol, String host, int port, String username, String password) {
super(new CouchDbConfig(new CouchDbProperties(dbName, createDbIfNotExist, protocol, host, port, username, password)));
}
/**
* Constructs a new instance of this class.
* @param properties An object containing configuration properties.
* @see {@link CouchDbProperties}
*/
public CouchDbClient(CouchDbProperties properties) {
super(new CouchDbConfig(properties));
}
private CouchDbContext context;
private CouchDbDesign design;
{
context = new CouchDbContext(this);
design = new CouchDbDesign(this);
}
/**
* {@inheritDoc}
*/
@Override
public void setGsonBuilder(GsonBuilder gsonBuilder) {
super.setGsonBuilder(gsonBuilder);
}
/**
* Provides access to the database APIs.
*/
public CouchDbContext context() {
return context;
}
/**
* Provides access to the database design documents API.
*/
public CouchDbDesign design() {
return design;
}
/**
* Provides access to the View APIs.
*/
public View view(String viewId) {
return new View(this, viewId);
}
/**
* Provides access to the replication APIs.
*/
public Replication replication() {
return new Replication(this);
}
/**
* Provides access to the replicator database APIs.
*/
public Replicator replicator() {
return new Replicator(this);
}
/**
* Provides access to the Change Notifications API.
*/
public Changes changes() {
return new Changes(this);
}
/**
* Synchronize all design documents on desk with the database.
*
Shorthand for {@link CouchDbDesign#synchronizeAllWithDb()}
*
This method might be used to sync design documents upon a client creation, eg. a Spring bean init-method.
*/
public void syncDesignDocsWithDb() {
design().synchronizeAllWithDb();
}
/**
* Finds an Object of the specified type.
* @param Object type.
* @param classType The class of type T.
* @param id The document id.
* @return An object of type T.
* @throws NoDocumentException If the document is not found in the database.
*/
public T find(Class classType, String id) {
assertNotEmpty(classType, "Class");
assertNotEmpty(id, "id");
return get(builder(getDBUri()).path(id).build(), classType);
}
/**
* Finds an Object of the specified type.
* @param Object type.
* @param classType The class of type T.
* @param id The document id.
* @param params Extra parameters to append.
* @return An object of type T.
* @throws NoDocumentException If the document is not found in the database.
*/
public T find(Class classType, String id, Params params) {
assertNotEmpty(classType, "Class");
assertNotEmpty(id, "id");
return get(builder(getDBUri()).path(id).query(params).build(), classType);
}
/**
* Finds an Object of the specified type.
* @param Object type.
* @param classType The class of type T.
* @param id The document id to get.
* @param rev The document revision.
* @return An object of type T.
* @throws NoDocumentException If the document is not found in the database.
*/
public T find(Class classType, String id, String rev) {
assertNotEmpty(classType, "Class");
assertNotEmpty(id, "id");
assertNotEmpty(id, "rev");
URI uri = builder(getDBUri()).path(id).query("rev", rev).build();
return get(uri, classType);
}
/**
* A General purpose find, that gives more control over the query.
* Unlike other finders, this method expects a fully formated and encoded URI to be supplied.
* @param classType The class of type T.
* @param uri The URI.
* @return An object of type T.
*/
public T findAny(Class classType, String uri) {
assertNotEmpty(classType, "Class");
assertNotEmpty(uri, "uri");
return get(URI.create(uri), classType);
}
/**
* Finds a document and returns the result as an {@link InputStream}.
* The stream should be properly closed after usage, as to avoid connection leaks.
* @param id The document id.
* @return The result of the request as an {@link InputStream}
* @throws NoDocumentException If the document is not found in the database.
* @see #find(String, String)
*/
public InputStream find(String id) {
assertNotEmpty(id, "id");
return get(builder(getDBUri()).path(id).build());
}
/**
* Finds a document given an id and revision, returns the result as {@link InputStream}.
* The stream should be properly closed after usage, as to avoid connection leaks.
* @param id The document id.
* @param rev The document revision.
* @return The result of the request as an {@link InputStream}
* @throws NoDocumentException If the document is not found in the database.
*/
public InputStream find(String id, String rev) {
assertNotEmpty(id, "id");
assertNotEmpty(rev, "rev");
return get(builder(getDBUri()).path(id).query("rev", rev).build());
}
/**
* Checks if the database contains a document given an id.
* @param id The document id.
* @return true If the document is found, false otherwise.
*/
public boolean contains(String id) {
assertNotEmpty(id, "id");
HttpResponse response = null;
try {
response = head(builder(getDBUri()).path(id).build());
} catch (NoDocumentException e) {
return false;
} finally {
close(response);
}
return true;
}
/**
* Saves an object in the database.
* @param object The object to save
* @throws DocumentConflictException If a conflict is detected during the save.
* @return {@link Response}
*/
public Response save(Object object) {
return put(getDBUri(), object, true);
}
/**
* Saves the given object in a batch request.
* @param object The object to save.
*/
public void batch(Object object) {
assertNotEmpty(object, "object");
HttpResponse response = null;
try {
URI uri = builder(getDBUri()).query("batch", "ok").build();
response = post(uri, getGson().toJson(object));
} finally {
close(response);
}
}
/**
* Performs a Bulk Documents request.
* @param objects The {@link List} of objects.
* @param allOrNothing Indicated whether the request has all-or-nothing semantics.
* @return {@code List} Containing the resulted entries.
*/
public List bulk(List objects, boolean allOrNothing) {
assertNotEmpty(objects, "objects");
HttpResponse response = null;
try {
String allOrNothingVal = allOrNothing ? "\"all_or_nothing\": true, " : "";
URI uri = builder(getDBUri()).path("_bulk_docs").build();
String json = String.format("{%s%s%s}", allOrNothingVal, "\"docs\": ", getGson().toJson(objects));
response = post(uri, json);
return getResponseList(response);
} finally {
close(response);
}
}
/**
* Saves an attachment under a new document with a generated UUID as the document id.
*
To retrieve an attachment, see {@link #find(String)}.
* @param instream The {@link InputStream} holding the binary data.
* @param name The attachment name.
* @param contentType The attachment "Content-Type".
* @return {@link Response}
*/
public Response saveAttachment(InputStream instream, String name, String contentType) {
assertNotEmpty(instream, "InputStream");
assertNotEmpty(name, "name");
assertNotEmpty(contentType, "ContentType");
URI uri = builder(getDBUri()).path(generateUUID()).path("/").path(name).build();
return put(uri, instream, contentType);
}
/**
*
Saves an attachment under an existing document given both a document id
* and revision, or under a new document given only the document id.
*
To retrieve an attachment, see {@link #find(String)}.
* @param instream The {@link InputStream} holding the binary data.
* @param name The attachment name.
* @param contentType The attachment "Content-Type".
* @param docId The document id to save the attachment under, or {@code null} to save under a new document.
* @param docRev The document revision to save the attachment under, or {@code null} when saving to a new document.
* @throws DocumentConflictException
* @return {@link Response}
*/
public Response saveAttachment(InputStream instream, String name, String contentType, String docId, String docRev) {
assertNotEmpty(instream, "InputStream");
assertNotEmpty(name, "name");
assertNotEmpty(contentType, "ContentType");
assertNotEmpty(docId, "DocId");
URI uri = builder(getDBUri()).path(docId).path("/").path(name).query("rev", docRev).build();
return put(uri, instream, contentType);
}
/**
* Updates an object in the database, the object must have the correct id and revision values.
* @param object The object to update
* @throws DocumentConflictException If a conflict is detected during the update.
* @return {@link Response}
*/
public Response update(Object object) {
return put(getDBUri(), object, false);
}
/**
* Removes an object from the database, the object must have the correct id and revision values.
* @param object The object to remove
* @throws NoDocumentException If the document could not be found in the database.
* @return {@link Response}
*/
public Response remove(Object object) {
assertNotEmpty(object, "object");
JsonObject jsonObject = getGson().toJsonTree(object).getAsJsonObject();
String id = getElement(jsonObject, "_id");
String rev = getElement(jsonObject, "_rev");
return remove(id, rev);
}
/**
* Removes a document from the database, given both an id and revision values.
* @param id The document id
* @param rev The document revision
* @throws NoDocumentException If the document could not be found in the database.
* @return {@link Response}
*/
public Response remove(String id, String rev) {
assertNotEmpty(id, "id");
assertNotEmpty(rev, "rev");
return delete(builder(getDBUri()).path(id).query("rev", rev).build());
}
/**
* Invokes an Update Handler.
* @param updateHandlerUri The Update Handler URI, in the format: designDocId/updateFunction
* @param docId The document id to update.
* @param query The query string parameters, e.g, field=field1&value=value1
* @return The output of the request.
*/
public String invokeUpdateHandler(String updateHandlerUri, String docId, String query) {
assertNotEmpty(updateHandlerUri, "updateHandlerUri");
assertNotEmpty(docId, "docId");
String[] v = updateHandlerUri.split("/");
String path = String.format("_design/%s/_update/%s/%s", v[0], v[1], docId);
URI uri = builder(getDBUri()).path(path).query(query).build();
HttpResponse response = executeRequest(new HttpPut(uri));
return streamToString(getStream(response));
}
/**
* {@inheritDoc}
*/
@Override
public URI getDBUri() {
return super.getDBUri();
}
/**
* {@inheritDoc}
*/
@Override
public URI getBaseUri() {
return super.getBaseUri();
}
/**
* {@inheritDoc}
*/
@Override
public Gson getGson() {
return super.getGson();
}
/**
* {@inheritDoc}
*/
@Override
public void shutdown() {
super.shutdown();
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbClientBase.java 0000664 0000000 0000000 00000035533 12150357216 0027370 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static java.lang.String.format;
import static org.lightcouch.CouchDbUtil.*;
import static org.lightcouch.URIBuilder.builder;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Type;
import java.net.URI;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.List;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocket;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpRequestInterceptor;
import org.apache.http.HttpResponse;
import org.apache.http.HttpResponseInterceptor;
import org.apache.http.HttpStatus;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpHead;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.ClientContext;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.scheme.SchemeSocketFactory;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.PoolingClientConnectionManager;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.CoreProtocolPNames;
import org.apache.http.protocol.BasicHttpContext;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.reflect.TypeToken;
/**
* Base client class to be extended by a concrete subclass, responsible for establishing
* a connection with the database and the definition of the basic HTTP request handling and validation.
* @see CouchDbClient
* @author Ahmed Yehia
*/
abstract class CouchDbClientBase {
static final Log log = LogFactory.getLog(CouchDbClientBase.class);
private HttpClient httpClient;
private URI baseURI;
private URI dbURI;
private Gson gson;
private CouchDbConfig config;
private HttpHost host;
private BasicHttpContext context;
protected CouchDbClientBase() {
this(new CouchDbConfig());
}
protected CouchDbClientBase(CouchDbConfig config) {
CouchDbProperties props = config.getProperties();
this.httpClient = createHttpClient(props);
this.gson = initGson(new GsonBuilder());
this.config = config;
baseURI = builder().scheme(props.getProtocol()).host(props.getHost()).port(props.getPort()).path("/").build();
dbURI = builder(baseURI).path(props.getDbName()).path("/").build();
}
// ---------------------------------------------- Getters
/**
* @return The database URI.
*/
protected URI getDBUri() {
return dbURI;
}
/**
* @return The base URI.
*/
protected URI getBaseUri() {
return baseURI;
}
/**
* @return The Gson instance.
*/
protected Gson getGson() {
return gson;
}
protected CouchDbConfig getConfig() {
return config;
}
// HTTP Requests
/**
* Performs a HTTP GET request.
* @return {@link InputStream}
*/
InputStream get(HttpGet httpGet) {
HttpResponse response = executeRequest(httpGet);
return getStream(response);
}
/**
* Performs a HTTP GET request.
* @return {@link InputStream}
*/
InputStream get(URI uri) {
HttpGet get = new HttpGet(uri);
get.addHeader("Accept", "application/json");
return get(get);
}
/**
* Performs a HTTP GET request.
* @return An object of type T
*/
T get(URI uri, Class classType) {
InputStream instream = null;
try {
instream = get(uri);
return deserialize(instream, classType);
} finally {
close(instream);
}
}
/**
* Performs a HTTP HEAD request.
* @return {@link HttpResponse}
*/
HttpResponse head(URI uri) {
return executeRequest(new HttpHead(uri));
}
/**
* Performs a HTTP PUT request, saves or updates a document.
* @return {@link Response}
*/
Response put(URI uri, Object object, boolean newEntity) {
assertNotEmpty(object, "object");
HttpResponse response = null;
try {
JsonObject json = getGson().toJsonTree(object).getAsJsonObject();
String id = getElement(json, "_id");
String rev = getElement(json, "_rev");
if(newEntity) { // save
assertNull(rev, "revision");
id = (id == null) ? generateUUID() : id;
} else { // update
assertNotEmpty(id, "id");
assertNotEmpty(rev, "revision");
}
HttpPut put = new HttpPut(builder(uri).path(id).build());
setEntity(put, json.toString());
response = executeRequest(put);
return getResponse(response);
} finally {
close(response);
}
}
/**
* Performs a HTTP PUT request, saves an attachment.
* @return {@link Response}
*/
Response put(URI uri, InputStream instream, String contentType) {
HttpResponse response = null;
try {
HttpPut httpPut = new HttpPut(uri);
InputStreamEntity entity = new InputStreamEntity(instream, -1);
entity.setContentType(contentType);
httpPut.setEntity(entity);
response = executeRequest(httpPut);
return getResponse(response);
} finally {
close(response);
}
}
/**
* Performs a HTTP POST request.
* @return {@link HttpResponse}
*/
HttpResponse post(URI uri, String json) {
HttpPost post = new HttpPost(uri);
setEntity(post, json);
return executeRequest(post);
}
/**
* Performs a HTTP DELETE request.
* @return {@link Response}
*/
Response delete(URI uri) {
HttpResponse response = null;
try {
HttpDelete delete = new HttpDelete(uri);
response = executeRequest(delete);
return getResponse(response);
} finally {
close(response);
}
}
/**
* Executes a HTTP request.
* @param request The HTTP request to execute.
* @return {@link HttpResponse}
*/
protected HttpResponse executeRequest(HttpRequestBase request) {
HttpResponse response = null;
try {
response = httpClient.execute(host, request, context);
} catch (IOException e) {
request.abort();
log.error("Error executing request. " + e.getMessage());
throw new CouchDbException(e);
}
return response;
}
// Helpers
/**
* @return {@link DefaultHttpClient} instance.
*/
private HttpClient createHttpClient(CouchDbProperties props) {
DefaultHttpClient httpclient = null;
try {
SchemeSocketFactory ssf = null;
if(props.getProtocol().equals("https")) {
TrustManager trustManager = new X509TrustManager() {
public void checkClientTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
public void checkServerTrusted(X509Certificate[] chain,
String authType) throws CertificateException {
}
public X509Certificate[] getAcceptedIssuers() {
return null;
}
};
SSLContext sslcontext = SSLContext.getInstance("TLS");
sslcontext.init(null, new TrustManager[] { trustManager }, null);
ssf = new SSLSocketFactory(sslcontext, SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
SSLSocket socket = (SSLSocket) ssf.createSocket(null);
socket.setEnabledCipherSuites(new String[] { "SSL_RSA_WITH_RC4_128_MD5" });
} else {
ssf = PlainSocketFactory.getSocketFactory();
}
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme(props.getProtocol(), props.getPort(), ssf));
PoolingClientConnectionManager ccm = new PoolingClientConnectionManager(schemeRegistry);
httpclient = new DefaultHttpClient(ccm);
host = new HttpHost(props.getHost(), props.getPort(), props.getProtocol());
context = new BasicHttpContext();
// Http params
httpclient.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET, "UTF-8");
httpclient.getParams().setParameter(CoreConnectionPNames.SO_TIMEOUT, props.getSocketTimeout());
httpclient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, props.getConnectionTimeout());
int maxConnections = props.getMaxConnections();
if(maxConnections != 0) {
ccm.setMaxTotal(maxConnections);
ccm.setDefaultMaxPerRoute(maxConnections);
}
if(props.getProxyHost() != null) {
HttpHost proxy = new HttpHost(props.getProxyHost(), props.getProxyPort());
httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
}
// basic authentication
if(props.getUsername() != null && props.getPassword() != null) {
httpclient.getCredentialsProvider().setCredentials(
new AuthScope(props.getHost(), props.getPort()),
new UsernamePasswordCredentials(props.getUsername(), props.getPassword()));
props.clearPassword();
AuthCache authCache = new BasicAuthCache();
BasicScheme basicAuth = new BasicScheme();
authCache.put(host, basicAuth);
context.setAttribute(ClientContext.AUTH_CACHE, authCache);
}
// request interceptor
httpclient.addRequestInterceptor(new HttpRequestInterceptor() {
public void process(
final HttpRequest request,
final HttpContext context) throws IOException {
if(log.isInfoEnabled())
log.info(">> " + request.getRequestLine());
}
});
// response interceptor
httpclient.addResponseInterceptor(new HttpResponseInterceptor() {
public void process(
final HttpResponse response,
final HttpContext context) throws IOException {
validate(response);
if(log.isInfoEnabled())
log.info("<< Status: " + response.getStatusLine().getStatusCode());
}
});
} catch (Exception e) {
log.error("Error Creating HTTP client. " + e.getMessage());
throw new IllegalStateException(e);
}
return httpclient;
}
/**
* Validates a HTTP response; on error cases logs status and throws relevant exceptions.
* @param response The HTTP response.
*/
private void validate(HttpResponse response) throws IOException {
int code = response.getStatusLine().getStatusCode();
if(code == 200 || code == 201 || code == 202) { // success (ok | created | accepted)
return;
}
String msg = format("<< Status: %s (%s) ", code, response.getStatusLine().getReasonPhrase());
switch (code) {
case HttpStatus.SC_NOT_FOUND: {
log.info(msg);
throw new NoDocumentException(msg);
}
case HttpStatus.SC_CONFLICT: {
log.warn(msg);
throw new DocumentConflictException(msg);
}
default: { // other errors: 400 | 401 | 500 etc.
log.error(msg += EntityUtils.toString(response.getEntity()));
throw new CouchDbException(msg);
}
}
}
/**
* @param response The {@link HttpResponse}
* @return {@link Response}
*/
Response getResponse(HttpResponse response) throws CouchDbException {
return deserialize(getStream(response), Response.class);
}
/**
* @param response The {@link HttpResponse}
* @return {@link Response}
*/
List getResponseList(HttpResponse response) throws CouchDbException {
InputStream instream = getStream(response);
Reader reader = new InputStreamReader(instream);
return getGson().fromJson(reader, new TypeToken>(){}.getType());
}
/**
* Sets a JSON String as a request entity.
* @param httpRequest The request to set entity.
* @param json The JSON String to set.
*/
protected void setEntity(HttpEntityEnclosingRequestBase httpRequest, String json) {
try {
StringEntity entity = new StringEntity(json, "UTF-8");
entity.setContentType("application/json");
httpRequest.setEntity(entity);
} catch (UnsupportedEncodingException e) {
log.error("Error setting request data. " + e.getMessage());
throw new IllegalArgumentException(e);
}
}
/**
* @return {@link InputStream} from a {@link HttpResponse}
*/
InputStream getStream(HttpResponse response) {
try {
return response.getEntity().getContent();
} catch (Exception e) {
log.error("Error reading response. " + e.getMessage());
throw new CouchDbException(e);
}
}
T deserialize(InputStream instream, Class classType) {
Reader reader = new InputStreamReader(instream);
return getGson().fromJson(reader, classType);
}
/**
* The supplied {@link GsonBuilder} is used to create a new {@link Gson} instance.
* Useful for registering custom serializers/deserializers, for example JodaTime DateTime class.
*/
protected void setGsonBuilder(GsonBuilder gsonBuilder) {
this.gson = initGson(gsonBuilder);
}
/**
* Builds {@link Gson} and registers any required serializer/deserializer.
* @return {@link Gson} instance
*/
private Gson initGson(GsonBuilder gsonBuilder) {
gsonBuilder.registerTypeAdapter(JsonObject.class, new JsonDeserializer() {
public JsonObject deserialize(JsonElement json,
Type typeOfT, JsonDeserializationContext context)
throws JsonParseException {
return json.getAsJsonObject();
}
});
gsonBuilder.registerTypeAdapter(JsonObject.class, new JsonSerializer() {
public JsonElement serialize(JsonObject src, Type typeOfSrc,
JsonSerializationContext context) {
return src.getAsJsonObject();
}
});
return gsonBuilder.create();
}
/**
* Shuts down the connection manager used by this client instance.
*/
protected void shutdown() {
this.httpClient.getConnectionManager().shutdown();
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbConfig.java 0000664 0000000 0000000 00000007446 12150357216 0026566 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static org.lightcouch.CouchDbUtil.*;
import java.io.InputStream;
import java.util.Properties;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Provides configuration to client instance.
* @author Ahmed Yehia
*/
class CouchDbConfig {
private static final Log log = LogFactory.getLog(CouchDbConfig.class);
private static final String DEFAULT_FILE = "couchdb.properties";
private Properties properties = new Properties();
private String configFile;
private CouchDbProperties dbProperties;
public CouchDbConfig() {
this(DEFAULT_FILE);
}
public CouchDbConfig(String configFile) {
this.configFile = configFile;
try {
InputStream instream = CouchDbConfig.class.getClassLoader().getResourceAsStream(configFile);
properties.load(instream);
} catch (Exception e) {
String msg = "Could not read configuration file from the classpath: " + configFile;
log.error(msg);
throw new IllegalStateException(msg, e);
}
readProperties();
}
public CouchDbConfig(CouchDbProperties dbProperties) {
assertNotEmpty(dbProperties, "Properties");
assertNotEmpty(dbProperties.getDbName(), "Database");
assertNotEmpty(dbProperties.getProtocol(), "Protocol");
assertNotEmpty(dbProperties.getHost(), "Host");
assertNotEmpty(dbProperties.getPort(), "Port");
this.dbProperties = dbProperties;
}
private void readProperties() {
try {
// required
dbProperties = new CouchDbProperties();
dbProperties.setDbName(getProperty("couchdb.name", true));
boolean create = Boolean.parseBoolean(getProperty("couchdb.createdb.if-not-exist", true));
dbProperties.setCreateDbIfNotExist(create);
dbProperties.setProtocol(getProperty("couchdb.protocol", true));
dbProperties.setHost(getProperty("couchdb.host", true));
int port = Integer.parseInt(getProperty("couchdb.port", true));
dbProperties.setPort(port);
dbProperties.setUsername(getProperty("couchdb.username", true));
dbProperties.setPassword(getProperty("couchdb.password", true));
// optional
dbProperties.setSocketTimeout(getPropertyAsInt("couchdb.http.socket.timeout", false));
dbProperties.setConnectionTimeout(getPropertyAsInt("couchdb.http.connection.timeout", false));
dbProperties.setMaxConnections(getPropertyAsInt("couchdb.max.connections", false));
dbProperties.setProxyHost(getProperty("couchdb.proxy.host", false));
dbProperties.setProxyPort(getPropertyAsInt("couchdb.proxy.port", false));
} catch (Exception e) {
throw new IllegalStateException(e);
}
properties = null;
}
public CouchDbProperties getProperties() {
return dbProperties;
}
private String getProperty(String key, boolean isRequired) {
String property = properties.getProperty(key);
if(property == null && isRequired) {
String msg = String.format("A required property is missing. Key: %s, File: %s", key, configFile);
log.error(msg);
throw new IllegalStateException(msg);
} else {
return (property != null && property.length() != 0) ? property.trim() : null;
}
}
private int getPropertyAsInt(String key, boolean isRequired) {
String prop = getProperty(key, isRequired);
return (prop != null) ? Integer.parseInt(prop) : 0;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbContext.java 0000664 0000000 0000000 00000010715 12150357216 0026776 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static org.lightcouch.CouchDbUtil.*;
import static org.lightcouch.URIBuilder.*;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.lang.reflect.Type;
import java.net.URI;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPut;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.reflect.TypeToken;
/**
* Provides access to database APIs.
* @author Ahmed Yehia
*/
public class CouchDbContext {
private static final Log log = LogFactory.getLog(CouchDbContext.class);
private CouchDbClient dbc;
CouchDbContext(CouchDbClient dbc) {
this.dbc = dbc;
CouchDbProperties props = dbc.getConfig().getProperties();
if (props.isCreateDbIfNotExist()) {
createDB(props.getDbName());
} else {
serverVersion(); // pre warm up client
}
}
/**
* Deletes a database.
* @param dbName The database name to delete
* @param confirm For double checking, the text "delete database" must be supplied.
*/
public void deleteDB(String dbName, String confirm) {
assertNotEmpty(dbName, "Database name");
if(!"delete database".equals(confirm))
throw new IllegalArgumentException("Cannot delete database without confirmation!");
dbc.delete(builder(dbc.getBaseUri()).path(dbName).build());
}
/**
* Creates a new Database, if it does not already exist.
* @param dbName The Database name
*/
public void createDB(String dbName) {
assertNotEmpty(dbName, "Database name");
HttpResponse headresp = null;
HttpResponse putresp = null;
URI uri = builder(dbc.getBaseUri()).path(dbName).build();
try {
headresp = dbc.head(uri);
} catch (NoDocumentException e) { // db doesn't exist
HttpPut put = new HttpPut(uri);
putresp = dbc.executeRequest(put);
log.info(String.format("Database: '%s' is created.", dbName));
} finally {
close(headresp);
close(putresp);
}
}
/**
* @return All server databases.
*/
public List getAllDbs() {
InputStream instream = null;
try {
Type typeOfList = new TypeToken>() {}.getType();
instream = dbc.get(builder(dbc.getBaseUri()).path("_all_dbs").build());
Reader reader = new InputStreamReader(instream);
return dbc.getGson().fromJson(reader, typeOfList);
} finally {
close(instream);
}
}
/**
* Gets the info of the associated database instance with this client.
* @return {@link CouchDbInfo}
*/
public CouchDbInfo info() {
return dbc.get(builder(dbc.getDBUri()).build(), CouchDbInfo.class);
}
/**
* @return CouchDB server version.
*/
public String serverVersion() {
InputStream instream = null;
try {
instream = dbc.get(builder(dbc.getBaseUri()).build());
Reader reader = new InputStreamReader(instream);
return getElement(new JsonParser().parse(reader).getAsJsonObject(), "version");
} finally {
close(instream);
}
}
/**
* Triggers a database compaction request.
*/
public void compact() {
HttpResponse response = null;
try {
response = dbc.post(builder(dbc.getDBUri()).path("_compact").build(), "");
} finally {
close(response);
}
}
/**
* Requests the database commits any recent changes to disk.
*/
public void ensureFullCommit() {
HttpResponse response = null;
try {
response = dbc.post(builder(dbc.getDBUri()).path("_ensure_full_commit").build(), "");
} finally {
close(response);
}
}
/**
* Request a database sends a list of UUIDs.
* @param count The count of UUIDs.
*/
public List uuids(long count) {
String uri = String.format("%s_uuids?count=%d", dbc.getBaseUri(), count);
JsonObject json = dbc.findAny(JsonObject.class, uri);
return dbc.getGson().fromJson(json.get("uuids").toString(), new TypeToken>(){}.getType());
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbDesign.java 0000664 0000000 0000000 00000015720 12150357216 0026564 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static org.lightcouch.CouchDbUtil.*;
import static java.lang.String.format;
import static org.lightcouch.URIBuilder.builder;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.lightcouch.DesignDocument.MapReduce;
/**
* Provides methods to create and save CouchDB design documents.
* Usage Example:
*
* DesignDocument exampleDoc = dbClient.design().getFromDesk("example");
* Response response = dbClient.design().synchronizeWithDb(exampleDoc);
* DesignDocument documentFromDb = dbClient.design().getFromDb("_design/example");
*
* @see DesignDocument
* @author Ahmed Yehia
*/
public class CouchDbDesign {
private static final String DESIGN_DOCS_DIR = "design-docs";
private static final String JAVASCRIPT = "javascript";
private static final String DESIGN_PREFIX = "_design/";
private static final String VALIDATE_DOC = "validate_doc_update";
private static final String VIEWS = "views";
private static final String FILTERS = "filters";
private static final String SHOWS = "shows";
private static final String LISTS = "lists";
private static final String UPDATES = "updates";
private static final String MAP_JS = "map.js";
private static final String REDUCE_JS = "reduce.js";
private CouchDbClient dbc;
CouchDbDesign(CouchDbClient dbc) {
this.dbc = dbc;
}
/**
* Synchronizes a design document to the Database.
* This method will first try to find a document in the database with the same id
* as the given document, if it is not found then the given document will be saved to the database.
*
If the document was found in the database, it will be compared with the given document using
* {@code equals()}. If both documents are not equal, then the given document will be saved to the
* database and updates the existing document.
* @param document The design document to synchronize
* @return {@link Response} as a result of a document save or update, or returns {@code null} if no
* action was taken and the document in the database is up-to-date with the given document.
*/
public Response synchronizeWithDb(DesignDocument document) {
assertNotEmpty(document, "Document");
DesignDocument documentFromDb = null;
try {
documentFromDb = getFromDb(document.getId());
} catch (NoDocumentException e) {
return dbc.save(document);
}
if(!document.equals(documentFromDb)) {
document.setRevision(documentFromDb.getRevision());
return dbc.update(document);
}
return null;
}
/**
* Synchronize all design documents on desk to the database.
* @see #synchronizeWithDb(DesignDocument)
* @see CouchDbClient#syncDesignDocsWithDb()
*/
public void synchronizeAllWithDb() {
List documents = getAllFromDesk();
for (DesignDocument dd : documents) {
synchronizeWithDb(dd);
}
}
/**
* Gets a design document from the database.
* @param id The document id
* @return {@link DesignDocument}
*/
public DesignDocument getFromDb(String id) {
assertNotEmpty(id, "id");
URI uri = builder(dbc.getDBUri()).path(id).build();
return dbc.get(uri, DesignDocument.class);
}
/**
* Gets a design document from the database.
* @param id The document id
* @param rev The document revision
* @return {@link DesignDocument}
*/
public DesignDocument getFromDb(String id, String rev) {
assertNotEmpty(id, "id");
assertNotEmpty(id, "rev");
URI uri = builder(dbc.getDBUri()).path(id).query("rev", rev).build();
return dbc.get(uri, DesignDocument.class);
}
/**
* Gets all design documents from desk.
* @see #getFromDesk(String)
*/
public List getAllFromDesk() {
List designDocsList = new ArrayList();
for (String docName : listResources(format("%s/", DESIGN_DOCS_DIR))) {
designDocsList.add(getFromDesk(docName));
}
return designDocsList;
}
/**
* Gets a design document from desk.
* @param id The document id to get.
* @return {@link DesignDocument}
*/
public DesignDocument getFromDesk(String id) {
assertNotEmpty(id, "id");
DesignDocument dd = new DesignDocument();
String rootPath = format("%s/%s/", DESIGN_DOCS_DIR, id);
List elements = listResources(rootPath);
if(elements == null) {
throw new IllegalArgumentException("Design docs directory cannot be empty.");
}
if(elements.contains(VALIDATE_DOC)) { // validate_doc_update
String validateDocPath = format("%s%s/", rootPath, VALIDATE_DOC);
List dirList = listResources(validateDocPath);
for (String file : dirList) {
String contents = readFile(format("/%s%s", validateDocPath, file));
dd.setValidateDocUpdate(contents);
break; // only one validate_doc_update file
}
} // /validate_doc_update
Map views = null;
if(elements.contains(VIEWS)) { // views
String viewsPath = format("%s%s/", rootPath, VIEWS);
views = new HashMap();
for (String viewDirName : listResources(viewsPath)) { // views sub-dirs
MapReduce mr = new MapReduce();
String viewPath = format("%s%s/", viewsPath, viewDirName);
List dirList = listResources(viewPath);
for (String fileName : dirList) { // view files
String def = readFile(format("/%s%s", viewPath, fileName));
if(MAP_JS.equals(fileName))
mr.setMap(def);
else if(REDUCE_JS.equals(fileName))
mr.setReduce(def);
} // /foreach view files
views.put(viewDirName, mr);
} // /foreach views sub-dirs
} // /views
dd.setId(DESIGN_PREFIX + id);
dd.setLanguage(JAVASCRIPT);
dd.setViews(views);
dd.setFilters(populateMap(rootPath, elements, FILTERS));
dd.setShows(populateMap(rootPath, elements, SHOWS));
dd.setLists(populateMap(rootPath, elements, LISTS));
dd.setUpdates(populateMap(rootPath, elements, UPDATES));
return dd;
}
private Map populateMap(String rootPath, List elements, String element) {
Map functionsMap = null;
if(elements.contains(element)) {
functionsMap = new HashMap();
String path = format("%s%s/", rootPath, element);
for (String fileName : listResources(path)) {
String contents = readFile(format("/%s%s", path, fileName));
functionsMap.put(removeExtension(fileName), contents);
}
}
return functionsMap;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbException.java 0000664 0000000 0000000 00000002130 12150357216 0027300 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
/**
* Base runtime exception class.
* @see {@link NoDocumentException}, {@link DocumentConflictException}
* @author Ahmed Yehia
*/
public class CouchDbException extends RuntimeException {
private static final long serialVersionUID = 1L;
public CouchDbException(String message) {
super(message);
}
public CouchDbException(Throwable cause) {
super(cause);
}
public CouchDbException(String message, Throwable cause) {
super(message, cause);
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbInfo.java 0000664 0000000 0000000 00000004322 12150357216 0026242 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import com.google.gson.annotations.SerializedName;
/**
* Holds information about a CouchDB database instance.
* @author Ahmed Yehia
*/
public class CouchDbInfo {
@SerializedName("db_name")
private String dbName;
@SerializedName("doc_count")
private long docCount;
@SerializedName("doc_del_count")
private String docDelCount;
@SerializedName("update_seq")
private String updateSeq;
@SerializedName("purge_seq")
private long purgeSeq;
@SerializedName("compact_running")
private boolean compactRunning;
@SerializedName("disk_size")
private long diskSize;
@SerializedName("instance_start_time")
private long instanceStartTime;
@SerializedName("disk_format_version")
private int diskFormatVersion;
public String getDbName() {
return dbName;
}
public long getDocCount() {
return docCount;
}
public String getDocDelCount() {
return docDelCount;
}
public String getUpdateSeq() {
return updateSeq;
}
public long getPurgeSeq() {
return purgeSeq;
}
public boolean isCompactRunning() {
return compactRunning;
}
public long getDiskSize() {
return diskSize;
}
public long getInstanceStartTime() {
return instanceStartTime;
}
public int getDiskFormatVersion() {
return diskFormatVersion;
}
@Override
public String toString() {
return String
.format("CouchDbInfo [dbName=%s, docCount=%s, docDelCount=%s, updateSeq=%s, purgeSeq=%s, compactRunning=%s, diskSize=%s, instanceStartTime=%s, diskFormatVersion=%s]",
dbName, docCount, docDelCount, updateSeq, purgeSeq,
compactRunning, diskSize, instanceStartTime,
diskFormatVersion);
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbProperties.java 0000664 0000000 0000000 00000007067 12150357216 0027514 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
/**
* Represents configuration properties for connecting to CouchDB.
*
* @author Ahmed Yehia
* @author Daan van Berkel
*/
public class CouchDbProperties {
// required
private String dbName;
private boolean createDbIfNotExist;
private String protocol;
private String host;
private int port;
private String username;
private String password;
// optional
private int socketTimeout;
private int connectionTimeout;
private int maxConnections;
private String proxyHost;
private int proxyPort;
public CouchDbProperties() {
// default constructor
}
public CouchDbProperties(String dbName, boolean createDbIfNotExist, String protocol,
String host, int port, String username, String password) {
this.dbName = dbName;
this.createDbIfNotExist = createDbIfNotExist;
this.protocol = protocol;
this.host = host;
this.port = port;
this.username = username;
this.password = password;
}
public String getDbName() {
return dbName;
}
public boolean isCreateDbIfNotExist() {
return createDbIfNotExist;
}
public String getProtocol() {
return protocol;
}
public String getHost() {
return host;
}
public int getPort() {
return port;
}
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
public int getSocketTimeout() {
return socketTimeout;
}
public int getConnectionTimeout() {
return connectionTimeout;
}
public int getMaxConnections() {
return maxConnections;
}
public String getProxyHost() {
return proxyHost;
}
public int getProxyPort() {
return proxyPort;
}
public CouchDbProperties setDbName(String dbName) {
this.dbName = dbName;
return this;
}
public CouchDbProperties setCreateDbIfNotExist(boolean createDbIfNotExist) {
this.createDbIfNotExist = createDbIfNotExist;
return this;
}
public CouchDbProperties setProtocol(String protocol) {
this.protocol = protocol;
return this;
}
public CouchDbProperties setHost(String host) {
this.host = host;
return this;
}
public CouchDbProperties setPort(int port) {
this.port = port;
return this;
}
public CouchDbProperties setUsername(String username) {
this.username = username;
return this;
}
public CouchDbProperties setPassword(String password) {
this.password = password;
return this;
}
public CouchDbProperties setSocketTimeout(int socketTimeout) {
this.socketTimeout = socketTimeout;
return this;
}
public CouchDbProperties setConnectionTimeout(int connectionTimeout) {
this.connectionTimeout = connectionTimeout;
return this;
}
public CouchDbProperties setMaxConnections(int maxConnections) {
this.maxConnections = maxConnections;
return this;
}
public CouchDbProperties setProxyHost(String proxyHost) {
this.proxyHost = proxyHost;
return this;
}
public CouchDbProperties setProxyPort(int proxyPort) {
this.proxyPort = proxyPort;
return this;
}
public void clearPassword() {
setPassword("");
setPassword(null);
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/CouchDbUtil.java 0000664 0000000 0000000 00000012506 12150357216 0026267 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static java.lang.String.format;
import java.io.Closeable;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
import java.util.UUID;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import org.apache.http.HttpResponse;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
/**
* Provides various utility methods, for internal use.
* @author Ahmed Yehia
*/
final class CouchDbUtil {
private CouchDbUtil() {
// Utility class
}
public static void assertNotEmpty(Object object, String prefix) throws IllegalArgumentException {
if(object == null) {
throw new IllegalArgumentException(format("%s may not be null.", prefix));
} else if(object instanceof String && ((String)object).length() == 0) {
throw new IllegalArgumentException(format("%s may not be empty.", prefix));
}
}
public static void assertNull(Object object, String prefix) throws IllegalArgumentException {
if(object != null) {
throw new IllegalArgumentException(format("%s should be null.", prefix));
}
}
public static String generateUUID() {
return UUID.randomUUID().toString().replace("-", "");
}
// JSON
public static T JsonToObject(Gson gson, JsonElement elem, String key, Class classType) {
return gson.fromJson(elem.getAsJsonObject().get(key), classType);
}
/**
* @return A JSON element as a String, or null if not found.
*/
public static String getElement(JsonObject j, String e) {
return (j.get(e) == null) ? null : j.get(e).getAsString();
}
public static long getElementAsLong(JsonObject j, String e) {
return (j.get(e) == null) ? 0L : j.get(e).getAsLong();
}
public static int getElementAsInt(JsonObject j, String e) {
return (j.get(e) == null) ? 0 : j.get(e).getAsInt();
}
// Files
private static final String LINE_SEP = System.getProperty("line.separator");
/**
* List directory contents for a resource folder. Not recursive.
* This is basically a brute-force implementation.
* Works for regular files and also JARs.
*
* @author Greg Briggs
* @param clazz Any java class that lives in the same place as the resources you want.
* @param path Should end with "/", but not start with one.
* @return Just the name of each member item, not the full paths.
*/
public static List listResources(String path) {
try {
Class clazz = CouchDbUtil.class;
URL dirURL = clazz.getClassLoader().getResource(path);
if (dirURL != null && dirURL.getProtocol().equals("file")) {
return Arrays.asList(new File(dirURL.toURI()).list());
}
if (dirURL != null && dirURL.getProtocol().equals("jar")) {
String jarPath = dirURL.getPath().substring(5, dirURL.getPath().indexOf("!"));
JarFile jar = new JarFile(URLDecoder.decode(jarPath, "UTF-8"));
Enumeration entries = jar.entries();
Set result = new HashSet();
while(entries.hasMoreElements()) {
String name = entries.nextElement().getName();
if (name.startsWith(path)) {
String entry = name.substring(path.length());
int checkSubdir = entry.indexOf("/");
if (checkSubdir >= 0) {
entry = entry.substring(0, checkSubdir);
}
if(entry.length() > 0) {
result.add(entry);
}
}
}
return new ArrayList(result);
}
return null;
} catch (Exception e) {
throw new CouchDbException(e);
}
}
public static String readFile(String path) {
InputStream instream = CouchDbUtil.class.getResourceAsStream(path);
StringBuilder content = new StringBuilder();
Scanner scanner = null;
try {
scanner = new Scanner(instream);
while(scanner.hasNextLine()) {
content.append(scanner.nextLine() + LINE_SEP);
}
} finally {
scanner.close();
}
return content.toString();
}
public static String removeExtension(String fileName) {
return fileName.substring(0, fileName.lastIndexOf('.'));
}
public static String streamToString(InputStream in) {
Scanner s = new Scanner(in).useDelimiter("\\A");
String str = s.hasNext() ? s.next() : null;
close(in);
return str;
}
/**
* Closes the response input stream.
*
* @param response The {@link HttpResponse}
*/
public static void close(HttpResponse response) {
try {
close(response.getEntity().getContent());
} catch (Exception e) {}
}
/**
* Closes a resource.
*
* @param c The {@link Closeable} resource.
*/
public static void close(Closeable c) {
try {
c.close();
} catch (Exception e) {}
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/DesignDocument.java 0000664 0000000 0000000 00000012234 12150357216 0027030 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import java.util.Map;
import com.google.gson.annotations.SerializedName;
/**
* Represents a design document.
* @see CouchDbDesign
* @author Ahmed Yehia
*/
public class DesignDocument extends Document {
private String language;
private Map views;
@SerializedName("validate_doc_update")
private String validateDocUpdate;
private Map filters;
private Map shows;
private Map lists;
private Map updates;
public String getLanguage() {
return language;
}
public Map getViews() {
return views;
}
public String getValidateDocUpdate() {
return validateDocUpdate;
}
public Map getFilters() {
return filters;
}
public Map getShows() {
return shows;
}
public Map getLists() {
return lists;
}
public Map getUpdates() {
return updates;
}
public void setLanguage(String language) {
this.language = language;
}
public void setViews(Map views) {
this.views = views;
}
public void setValidateDocUpdate(String validateDocUpdate) {
this.validateDocUpdate = validateDocUpdate;
}
public void setFilters(Map filters) {
this.filters = filters;
}
public void setShows(Map shows) {
this.shows = shows;
}
public void setLists(Map lists) {
this.lists = lists;
}
public void setUpdates(Map updates) {
this.updates = updates;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + ((filters == null) ? 0 : filters.hashCode());
result = prime * result + ((language == null) ? 0 : language.hashCode());
result = prime * result + ((lists == null) ? 0 : lists.hashCode());
result = prime * result + ((shows == null) ? 0 : shows.hashCode());
result = prime * result + ((updates == null) ? 0 : updates.hashCode());
result = prime * result
+ ((validateDocUpdate == null) ? 0 : validateDocUpdate.hashCode());
result = prime * result + ((views == null) ? 0 : views.hashCode());
return result;
}
/**
* Indicates whether some other design document is equals to this one.
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
DesignDocument other = (DesignDocument) obj;
if (filters == null) {
if (other.filters != null)
return false;
} else if (!filters.equals(other.filters))
return false;
if (language == null) {
if (other.language != null)
return false;
} else if (!language.equals(other.language))
return false;
if (lists == null) {
if (other.lists != null)
return false;
} else if (!lists.equals(other.lists))
return false;
if (shows == null) {
if (other.shows != null)
return false;
} else if (!shows.equals(other.shows))
return false;
if (updates == null) {
if (other.updates != null)
return false;
} else if (!updates.equals(other.updates))
return false;
if (validateDocUpdate == null) {
if (other.validateDocUpdate != null)
return false;
} else if (!validateDocUpdate.equals(other.validateDocUpdate))
return false;
if (views == null) {
if (other.views != null)
return false;
} else if (!views.equals(other.views))
return false;
return true;
}
/**
* Holds Map Reduce functions in a view.
* @author Ahmed Yehia
*/
public static class MapReduce {
private String map;
private String reduce;
public String getMap() {
return map;
}
public String getReduce() {
return reduce;
}
public void setMap(String map) {
this.map = map;
}
public void setReduce(String reduce) {
this.reduce = reduce;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((map == null) ? 0 : map.hashCode());
result = prime * result + ((reduce == null) ? 0 : reduce.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
MapReduce other = (MapReduce) obj;
if (map == null) {
if (other.map != null)
return false;
} else if (!map.equals(other.map))
return false;
if (reduce == null) {
if (other.reduce != null)
return false;
} else if (!reduce.equals(other.reduce))
return false;
return true;
}
} // /class MapReduce
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Document.java 0000664 0000000 0000000 00000004225 12150357216 0025677 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import java.util.HashMap;
import java.util.Map;
import com.google.gson.annotations.SerializedName;
/**
* Convenient base class for CouchDB documents, defines the basic
* id and revision properties and attachments.
* @author Ahmed Yehia
*
*/
public class Document {
@SerializedName("_id")
private String id;
@SerializedName("_rev")
private String revision;
@SerializedName("_attachments")
private Map attachments;
public String getId() {
return id;
}
public String getRevision() {
return revision;
}
public Map getAttachments() {
return attachments;
}
public void setId(String id) {
this.id = id;
}
public void setRevision(String revision) {
this.revision = revision;
}
public void setAttachments(Map attachments) {
this.attachments = attachments;
}
public void addAttachment(String name, Attachment attachment) {
if(attachments == null)
attachments = new HashMap();
attachments.put(name, attachment);
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Document other = (Document) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
return true;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/DocumentConflictException.java 0000664 0000000 0000000 00000002123 12150357216 0031233 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
/**
* Thrown when a conflict is detected during a save or update.
* @author Ahmed Yehia
*/
public class DocumentConflictException extends CouchDbException {
private static final long serialVersionUID = 1L;
public DocumentConflictException(String message) {
super(message);
}
public DocumentConflictException(Throwable cause) {
super(cause);
}
public DocumentConflictException(String message, Throwable cause) {
super(message, cause);
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/NoDocumentException.java 0000664 0000000 0000000 00000002057 12150357216 0030054 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
/**
* Thrown when a requested document is not found.
* @author Ahmed Yehia
*/
public class NoDocumentException extends CouchDbException {
private static final long serialVersionUID = 1L;
public NoDocumentException(String message) {
super(message);
}
public NoDocumentException(Throwable cause) {
super(cause);
}
public NoDocumentException(String message, Throwable cause) {
super(message, cause);
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Page.java 0000664 0000000 0000000 00000004526 12150357216 0025001 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import java.util.List;
/**
* Holds data of a page as result of a view pagination query.
* @see View#queryPage(int, String, Class)
* @param Object type T
*
* @author Ahmed Yehia
*/
public class Page {
private boolean isHasPrevious;
private boolean isHasNext;
private List resultList;
private long totalResults;
private int resultFrom;
private int resultTo;
private int pageNumber;
private String nextParam;
private String previousParam;
public boolean isHasPrevious() {
return isHasPrevious;
}
public boolean isHasNext() {
return isHasNext;
}
public List getResultList() {
return resultList;
}
public long getTotalResults() {
return totalResults;
}
public int getResultFrom() {
return resultFrom;
}
public int getResultTo() {
return resultTo;
}
public int getPageNumber() {
return pageNumber;
}
public String getNextParam() {
return nextParam;
}
public String getPreviousParam() {
return previousParam;
}
public void setHasPrevious(boolean isHasPrevious) {
this.isHasPrevious = isHasPrevious;
}
public void setHasNext(boolean isHasNext) {
this.isHasNext = isHasNext;
}
public void setResultList(List resultList) {
this.resultList = resultList;
}
public void setTotalResults(long totalResults) {
this.totalResults = totalResults;
}
public void setResultFrom(int resultFrom) {
this.resultFrom = resultFrom;
}
public void setResultTo(int resultTo) {
this.resultTo = resultTo;
}
public void setPageNumber(int pageNumber) {
this.pageNumber = pageNumber;
}
public void setNextParam(String nextParam) {
this.nextParam = nextParam;
}
public void setPreviousParam(String previousParam) {
this.previousParam = previousParam;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Params.java 0000664 0000000 0000000 00000003320 12150357216 0025337 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static java.lang.String.format;
import java.util.ArrayList;
import java.util.List;
/**
* Query parameters to append to find requests.
* Example:
*
* dbClient.find(Foo.class, "doc-id", new Params().revsInfo().attachments());
*
* @see CouchDbClient#find(Class, String, Params)
* @author Ahmed Yehia
*
*/
public class Params {
private List params = new ArrayList();
public Params revsInfo() {
params.add("revs_info=true");
return this;
}
public Params attachments() {
params.add("attachments=true");
return this;
}
public Params revisions() {
params.add("revs=true");
return this;
}
public Params rev(String rev) {
params.add(format("rev=%s", rev));
return this;
}
public Params conflicts() {
params.add("conflicts=true");
return this;
}
public Params localSeq() {
params.add("local_seq=true");
return this;
}
public Params addParam(String name, Object value) {
params.add(format("%s=%s", name, value));
return this;
}
public List getParams() {
return params.isEmpty() ? null : params;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Replication.java 0000664 0000000 0000000 00000012572 12150357216 0026376 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static org.lightcouch.CouchDbUtil.assertNotEmpty;
import static org.lightcouch.CouchDbUtil.close;
import static org.lightcouch.URIBuilder.builder;
import java.net.URI;
import java.util.Map;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpResponse;
import com.google.gson.JsonObject;
/**
* This class allows construction and sending of replication requests.
*
Replication is triggered by sending a POST request to _replicate.
*
*
Usage Example:
*
* ReplicationResult result = dbClient.replication()
* .source("source-db")
* .target("target-db")
* .createTarget(true)
* .trigger();
*
*
* @see Replicator
* @author Ahmed Yehia
*
*/
public class Replication {
static final Log log = LogFactory.getLog(Replication.class);
private String source;
private String target;
private Boolean cancel;
private Boolean continuous;
private String filter;
private JsonObject queryParams;
private String[] docIds;
private String proxy;
private Boolean createTarget;
private Integer sinceSeq;
// OAuth
private JsonObject targetOauth;
private String consumerSecret;
private String consumerKey;
private String tokenSecret;
private String token;
private CouchDbClient dbc;
public Replication(CouchDbClient dbc) {
this.dbc = dbc;
}
/**
* Triggers a replication request.
*/
public ReplicationResult trigger() {
assertNotEmpty(source, "Source");
assertNotEmpty(target, "Target");
HttpResponse response = null;
try {
JsonObject json = createJson();
if(log.isDebugEnabled()) {
log.debug(json);
}
URI uri = builder(dbc.getBaseUri()).path("_replicate").build();
response = dbc.post(uri, json.toString());
return dbc.deserialize(dbc.getStream(response), ReplicationResult.class);
} finally {
close(response);
}
}
// fields
public Replication source(String source) {
this.source = source;
return this;
}
public Replication target(String target) {
this.target = target;
return this;
}
public Replication continuous(Boolean continuous) {
this.continuous = continuous;
return this;
}
public Replication filter(String filter) {
this.filter = filter;
return this;
}
public Replication queryParams(String queryParams) {
this.queryParams = dbc.getGson().fromJson(queryParams, JsonObject.class);
return this;
}
public Replication queryParams(Map queryParams) {
this.queryParams = dbc.getGson().toJsonTree(queryParams).getAsJsonObject();
return this;
}
public Replication docIds(String... docIds) {
this.docIds = docIds;
return this;
}
public Replication proxy(String proxy) {
this.proxy = proxy;
return this;
}
public Replication cancel(Boolean cancel) {
this.cancel = cancel;
return this;
}
public Replication createTarget(Boolean createTarget) {
this.createTarget = createTarget;
return this;
}
/**
* Starts a replication since an update sequence.
*/
public Replication sinceSeq(Integer sinceSeq) {
this.sinceSeq = sinceSeq;
return this;
}
public Replication targetOauth(String consumerSecret, String consumerKey, String tokenSecret, String token) {
targetOauth = new JsonObject();
this.consumerSecret = consumerKey;
this.consumerKey = consumerKey;
this.tokenSecret = tokenSecret;
this.token = token;
return this;
}
// helper
private JsonObject createJson() {
JsonObject json = new JsonObject();
addProperty(json, "source", source);
addProperty(json, "cancel", cancel);
addProperty(json, "continuous", continuous);
addProperty(json, "filter", filter);
if(queryParams != null)
json.add("query_params", queryParams);
if(docIds != null)
json.add("doc_ids", dbc.getGson().toJsonTree(docIds, String[].class));
addProperty(json, "proxy", proxy);
addProperty(json, "since_seq", sinceSeq);
addProperty(json, "create_target", createTarget);
if(targetOauth != null) {
JsonObject auth = new JsonObject();
JsonObject oauth = new JsonObject();
addProperty(oauth, "consumer_secret", consumerSecret);
addProperty(oauth, "consumer_key", consumerKey);
addProperty(oauth, "token_secret", tokenSecret);
addProperty(oauth, "token", token);
addProperty(targetOauth, "url", target);
auth.add("oauth", oauth);
targetOauth.add("auth", auth);
json.add("target", targetOauth);
} else {
addProperty(json, "target", target);
}
return json;
}
private void addProperty(JsonObject json, String name, Object value) {
if(value != null) {
if(value instanceof Boolean)
json.addProperty(name, (Boolean)value);
else if (value instanceof String)
json.addProperty(name, (String)value);
else if (value instanceof Integer)
json.addProperty(name, (Integer)value);
}
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/ReplicationResult.java 0000664 0000000 0000000 00000005700 12150357216 0027570 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import com.google.gson.annotations.SerializedName;
import java.util.List;
/**
* Holds the result of a replication request, along with previous sessions history.
* @see Replication
* @author Ahmed Yehia
*/
public class ReplicationResult {
@SerializedName("ok")
private boolean ok;
@SerializedName("session_id")
private String sessionId;
@SerializedName("source_last_seq")
private String sourceLastSeq;
@SerializedName("_local_id")
private String localId;
@SerializedName("history")
private List histories;
public boolean isOk() {
return ok;
}
public String getSessionId() {
return sessionId;
}
public String getSourceLastSeq() {
return sourceLastSeq;
}
public String getLocalId() {
return localId;
}
public List getHistories() {
return histories;
}
/**
* Represents a replication session history.
* @author Ahmed Yehia
*/
public static class ReplicationHistory {
@SerializedName("session_id")
private String sessionId;
@SerializedName("start_time")
private String startTime;
@SerializedName("end_time")
private String endTime;
@SerializedName("start_last_seq")
private String startLastSeq;
@SerializedName("end_last_seq")
private String endLastSeq;
@SerializedName("recorded_seq")
private String recordedSeq;
@SerializedName("missing_checked")
private long missingChecked;
@SerializedName("missing_found")
private long missingFound;
@SerializedName("docs_read")
private long docsRead;
@SerializedName("docs_written")
private long docsWritten;
@SerializedName("doc_write_failures")
private long docWriteFailures;
public String getSessionId() {
return sessionId;
}
public String getStartTime() {
return startTime;
}
public String getEndTime() {
return endTime;
}
public String getStartLastSeq() {
return startLastSeq;
}
public String getEndLastSeq() {
return endLastSeq;
}
public String getRecordedSeq() {
return recordedSeq;
}
public long getMissingChecked() {
return missingChecked;
}
public long getMissingFound() {
return missingFound;
}
public long getDocsRead() {
return docsRead;
}
public long getDocsWritten() {
return docsWritten;
}
public long getDocWriteFailures() {
return docWriteFailures;
}
} // /class ReplicationHistory
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Replicator.java 0000664 0000000 0000000 00000016325 12150357216 0026231 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static org.lightcouch.CouchDbUtil.*;
import static org.lightcouch.URIBuilder.builder;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.lightcouch.ReplicatorDocument.UserCtx;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* This class allows construction and sending of replication requests targeting a replicator database.
*
The Replicator database, by default is called _replicator was introduced in CouchDB version 1.1.0
*
The API supports triggering replication requests by adding a document to the replicator database,
* and cancelling a replication by removing the document that triggered the replication.
*
*
Usage Example:
*
* Response response = dbClient.replicator()
* .source("source-db")
* .target("target-db")
* .continuous(true)
* .createTarget(true)
* .replicatorDB("replicator-db-name") // optionally specify database name, defaults to _replicator
* .replicatorDocId("doc-id") // optionally specify document id, defaults to a new UUID being assigned
* .save();
*
* ReplicatorDocument document = dbClient.replicator()
* .replicatorDocId("doc-id")
* .replicatorDocRev("doc-rev") // optional
* .find();
*
* {@code
* List docs = dbClient.replicator().findAll();
* }
*
* Response response = dbClient.replicator()
* .replicatorDocId("doc-id")
* .replicatorDocRev("doc-rev")
* .remove();
*
*
* @see Replication
* @author Ahmed Yehia
*
*/
public class Replicator {
private String replicatorDB;
private String userCtxName;
private String[] userCtxRoles;
private CouchDbClient dbc;
private ReplicatorDocument replicatorDoc;
private URI dbURI;
public Replicator(CouchDbClient dbc) {
this.dbc = dbc;
replicatorDoc = new ReplicatorDocument();
replicatorDB = "_replicator"; // default replicator db
userCtxRoles = new String[0]; // default roles
dbURI = builder(dbc.getBaseUri()).path(replicatorDB).path("/").build();
}
/**
* Adds a new document to the replicator database.
* @return {@link Response}
*/
public Response save() {
assertNotEmpty(replicatorDoc.getSource(), "Source");
assertNotEmpty(replicatorDoc.getTarget(), "Target");
if(userCtxName != null) {
UserCtx ctx = replicatorDoc.new UserCtx();
ctx.setName(userCtxName);
ctx.setRoles(userCtxRoles);
replicatorDoc.setUserCtx(ctx);
}
return dbc.put(dbURI, replicatorDoc, true);
}
/**
* Finds a document in the replicator database.
* @return {@link ReplicatorDocument}
*/
public ReplicatorDocument find() {
assertNotEmpty(replicatorDoc.getId(), "Doc id");
URI uri = builder(dbURI).path(replicatorDoc.getId()).query("rev", replicatorDoc.getRevision()).build();
return dbc.get(uri, ReplicatorDocument.class);
}
/**
* Finds all documents in the replicator database.
*/
public List findAll() {
InputStream instream = null;
try {
URI uri = builder(dbURI).path("_all_docs").query("include_docs", "true").build();
Reader reader = new InputStreamReader(instream = dbc.get(uri));
JsonArray jsonArray = new JsonParser().parse(reader)
.getAsJsonObject().getAsJsonArray("rows");
List list = new ArrayList();
for (JsonElement jsonElem : jsonArray) {
JsonElement elem = jsonElem.getAsJsonObject().get("doc");
if(!getElement(elem.getAsJsonObject(), "_id").startsWith("_design")) { // skip design docs
ReplicatorDocument rd = dbc.getGson().fromJson(elem, ReplicatorDocument.class);
list.add(rd);
}
}
return list;
} finally {
close(instream);
}
}
/**
* Removes a document from the replicator database.
* @return {@link Response}
*/
public Response remove() {
assertNotEmpty(replicatorDoc.getId(), "Doc id");
assertNotEmpty(replicatorDoc.getRevision(), "Doc rev");
URI uri = builder(dbURI).path(replicatorDoc.getId()).query("rev", replicatorDoc.getRevision()).build();
return dbc.delete(uri);
}
// fields
public Replicator source(String source) {
replicatorDoc.setSource(source);
return this;
}
public Replicator target(String target) {
replicatorDoc.setTarget(target);
return this;
}
public Replicator continuous(boolean continuous) {
replicatorDoc.setContinuous(continuous);
return this;
}
public Replicator filter(String filter) {
replicatorDoc.setFilter(filter);
return this;
}
public Replicator queryParams(String queryParams) {
replicatorDoc.setQueryParams(dbc.getGson().fromJson(queryParams, JsonObject.class));
return this;
}
public Replicator queryParams(Map queryParams) {
replicatorDoc.setQueryParams(dbc.getGson().toJsonTree(queryParams).getAsJsonObject());
return this;
}
public Replicator docIds(String... docIds) {
replicatorDoc.setDocIds(docIds);
return this;
}
public Replicator proxy(String proxy) {
replicatorDoc.setProxy(proxy);
return this;
}
public Replicator createTarget(Boolean createTarget) {
replicatorDoc.setCreateTarget(createTarget);
return this;
}
public Replicator replicatorDB(String replicatorDB) {
this.replicatorDB = replicatorDB;
dbURI = builder(dbc.getBaseUri()).path(replicatorDB).path("/").build();
return this;
}
public Replicator replicatorDocId(String replicatorDocId) {
replicatorDoc.setId(replicatorDocId);
return this;
}
public Replicator replicatorDocRev(String replicatorDocRev) {
replicatorDoc.setRevision(replicatorDocRev);
return this;
}
public Replicator workerProcesses(int workerProcesses) {
replicatorDoc.setWorkerProcesses(workerProcesses);
return this;
}
public Replicator workerBatchSize(int workerBatchSize) {
replicatorDoc.setWorkerBatchSize(workerBatchSize);
return this;
}
public Replicator httpConnections(int httpConnections) {
replicatorDoc.setHttpConnections(httpConnections);
return this;
}
public Replicator connectionTimeout(long connectionTimeout) {
replicatorDoc.setConnectionTimeout(connectionTimeout);
return this;
}
public Replicator retriesPerRequest(int retriesPerRequest) {
replicatorDoc.setRetriesPerRequest(retriesPerRequest);
return this;
}
public Replicator userCtxName(String userCtxName) {
this.userCtxName = userCtxName;
return this;
}
public Replicator userCtxRoles(String... userCtxRoles) {
this.userCtxRoles = userCtxRoles;
return this;
}
public Replicator sinceSeq(Integer sinceSeq) {
replicatorDoc.setSinceSeq(sinceSeq);
return this;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/ReplicatorDocument.java 0000664 0000000 0000000 00000011764 12150357216 0027732 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import com.google.gson.JsonObject;
import com.google.gson.annotations.SerializedName;
/**
* Represents a replication document in a replicator database.
* @see Replicator
* @author Ahmed Yehia
*
*/
public class ReplicatorDocument extends Document {
@SerializedName("source")
private String source;
@SerializedName("target")
private String target;
@SerializedName("continuous")
private Boolean continuous;
@SerializedName("filter")
private String filter;
@SerializedName("query_params")
private JsonObject queryParams;
@SerializedName("doc_ids")
private String[] docIds;
@SerializedName("proxy")
private String proxy;
@SerializedName("create_target")
private Boolean createTarget;
@SerializedName("_replication_id")
private String replicationId;
@SerializedName("_replication_state")
private String replicationState;
@SerializedName("_replication_state_time")
private String replicationStateTime;
@SerializedName("worker_processes")
private Integer workerProcesses;
@SerializedName("worker_batch_size")
private Integer workerBatchSize;
@SerializedName("http_connections")
private Integer httpConnections;
@SerializedName("connection_timeout ")
private Long connectionTimeout;
@SerializedName("retries_per_request")
private Integer retriesPerRequest;
@SerializedName("user_ctx")
private UserCtx userCtx;
@SerializedName("since_seq")
private Integer sinceSeq;
public String getSource() {
return source;
}
public String getTarget() {
return target;
}
public Boolean getContinuous() {
return continuous;
}
public String getFilter() {
return filter;
}
public JsonObject getQueryParams() {
return queryParams;
}
public String[] getDocIds() {
return docIds;
}
public String getProxy() {
return proxy;
}
public Boolean getCreateTarget() {
return createTarget;
}
public String getReplicationId() {
return replicationId;
}
public String getReplicationState() {
return replicationState;
}
public String getReplicationStateTime() {
return replicationStateTime;
}
public UserCtx getUserCtx() {
return userCtx;
}
public Integer getWorkerProcesses() {
return workerProcesses;
}
public Integer getWorkerBatchSize() {
return workerBatchSize;
}
public Integer getHttpConnections() {
return httpConnections;
}
public Long getConnectionTimeout() {
return connectionTimeout;
}
public Integer getRetriesPerRequest() {
return retriesPerRequest;
}
public void setSource(String source) {
this.source = source;
}
public void setTarget(String target) {
this.target = target;
}
public void setContinuous(Boolean continuous) {
this.continuous = continuous;
}
public void setFilter(String filter) {
this.filter = filter;
}
public void setQueryParams(JsonObject queryParams) {
this.queryParams = queryParams;
}
public void setDocIds(String[] docIds) {
this.docIds = docIds;
}
public void setProxy(String proxy) {
this.proxy = proxy;
}
public void setCreateTarget(Boolean createTarget) {
this.createTarget = createTarget;
}
public void setReplicationId(String replicationId) {
this.replicationId = replicationId;
}
public void setReplicationState(String replicationState) {
this.replicationState = replicationState;
}
public void setReplicationStateTime(String replicationStateTime) {
this.replicationStateTime = replicationStateTime;
}
public void setUserCtx(UserCtx userCtx) {
this.userCtx = userCtx;
}
public void setWorkerProcesses(Integer workerProcesses) {
this.workerProcesses = workerProcesses;
}
public void setWorkerBatchSize(Integer workerBatchSize) {
this.workerBatchSize = workerBatchSize;
}
public void setHttpConnections(Integer httpConnections) {
this.httpConnections = httpConnections;
}
public void setConnectionTimeout(Long connectionTimeout) {
this.connectionTimeout = connectionTimeout;
}
public void setRetriesPerRequest(Integer retriesPerRequest) {
this.retriesPerRequest = retriesPerRequest;
}
public Integer getSinceSeq() {
return sinceSeq;
}
public void setSinceSeq(Integer sinceSeq) {
this.sinceSeq = sinceSeq;
}
public class UserCtx {
private String name;
private String[] roles;
public String getName() {
return name;
}
public String[] getRoles() {
return roles;
}
public void setName(String name) {
this.name = name;
}
public void setRoles(String[] roles) {
this.roles = roles;
}
} // /class UserCtx
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/Response.java 0000664 0000000 0000000 00000002221 12150357216 0025711 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
/**
* Represents CouchDB response as a result of a request.
* @author Ahmed Yehia
*
*/
public class Response {
private String id;
private String rev;
// related to bulk response only
private String error;
private String reason;
public String getId() {
return id;
}
public String getRev() {
return rev;
}
public String getError() {
return error;
}
public String getReason() {
return reason;
}
@Override
public String toString() {
return "Response [id=" + id + ", rev=" + rev + "]";
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/URIBuilder.java 0000664 0000000 0000000 00000004674 12150357216 0026077 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
/**
* Helper class for construction of HTTP request URIs.
*
* @author Ahmed Yehia
*
*/
class URIBuilder {
private String scheme;
private String host;
private int port;
private String path = "";
/* The final query */
private final StringBuilder query = new StringBuilder();
private final List queries = new ArrayList();
public static URIBuilder builder() {
return new URIBuilder();
}
public static URIBuilder builder(URI uri) {
URIBuilder builder = URIBuilder.builder().scheme(uri.getScheme())
.host(uri.getHost()).port(uri.getPort()).path(uri.getPath());
return builder;
}
public URI build() {
try {
for (int i = 0; i < queries.size(); i++) {
query.append(queries.get(i));
if (i != queries.size() - 1)
query.append("&");
}
String q = (query.length() == 0) ? null : query.toString();
return new URI(scheme, null, host, port, path, q, null);
} catch (URISyntaxException e) {
throw new IllegalArgumentException(e);
}
}
public URIBuilder scheme(String scheme) {
this.scheme = scheme;
return this;
}
public URIBuilder host(String host) {
this.host = host;
return this;
}
public URIBuilder port(int port) {
this.port = port;
return this;
}
public URIBuilder path(String path) {
this.path += path;
return this;
}
public URIBuilder query(String name, Object value) {
if (name != null && value != null)
this.queries.add(String.format("%s=%s", name, value));
return this;
}
public URIBuilder query(String query) {
if (query != null)
this.query.append(query);
return this;
}
public URIBuilder query(Params params) {
if (params.getParams() != null)
this.queries.addAll(params.getParams());
return this;
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/View.java 0000664 0000000 0000000 00000044330 12150357216 0025034 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import static java.lang.String.format;
import static org.lightcouch.CouchDbUtil.*;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.lightcouch.DesignDocument.MapReduce;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
/**
* This class allows construction and sending of View query requests.
* The API supports view queries for various data type results, and for pagination.
*
*
Usage Example:
*
* {@code
* List list = dbClient.view("example/foo")
* .includeDocs(true).startKey("start-key").endKey("end-key").limit(10).query(Foo.class);
*
* int count = dbClient.view("example/by_tag").key("couchdb").queryForInt(); // query for scalar values
*
* // query for view entries
* View view = dbClient.view("example/by_date")
* .key(2011, 10, 15) // complex key example
* .reduce(false)
* .includeDocs(true);
* ViewResult result =
* view.queryView(int[].class, String.class, Foo.class);
*
* // pagination
* Page page = dbClient.view("example/foo").queryPage(15, param, Foo.class);
* // page.get*Param() contains the param to query subsequent pages, {@code null} param queries the first page
* }
*
*
* @author Ahmed Yehia
*/
public class View {
private static final Log log = LogFactory.getLog(View.class);
// paging param fields
private static final String START_KEY = "s_k";
private static final String START_KEY_DOC_ID = "s_k_d_i";
private static final String CURRENT_START_KEY = "c_k";
private static final String CURRENT_START_KEY_DOC_ID = "c_k_d_i";
private static final String CURRENT_KEYS = "c";
private static final String ACTION = "a";
private static final String NEXT = "n";
private static final String PREVIOUS = "p";
// temp views
private static final String TEMP_VIEWS_DIR = "temp-views";
private static final String MAP_JS = "map.js";
private static final String REDUCE_JS = "reduce.js";
// view fields
private String key;
private String startKey;
private String startKeyDocId;
private String endKey;
private String endKeyDocId;
private Integer limit;
private String stale;
private Boolean descending;
private Integer skip;
private Boolean group;
private Integer groupLevel;
private Boolean reduce;
private Boolean includeDocs;
private Boolean inclusiveEnd;
private Boolean updateSeq;
private CouchDbClient dbc;
private Gson gson;
private URIBuilder uriBuilder;
private String allDocsKeys; // bulk docs
private MapReduce tempView; // temp view
View(CouchDbClient dbc, String viewId) {
assertNotEmpty(viewId, "View id");
this.dbc = dbc;
this.gson = dbc.getGson();
String view = viewId;
if(viewId.contains("/")) {
String[] v = viewId.split("/");
view = String.format("_design/%s/_view/%s", v[0], v[1]);
}
this.uriBuilder = URIBuilder.builder(dbc.getDBUri()).path(view);
}
// Query options
/**
* Queries a view as an {@link InputStream}
* The stream should be properly closed after usage, as to avoid connection leaks.
* @return The result as an {@link InputStream}.
*/
public InputStream queryForStream() {
URI uri = uriBuilder.build();
if(allDocsKeys != null) { // bulk docs
return dbc.getStream(dbc.post(uri, allDocsKeys));
}
if(tempView != null) { // temp view
return dbc.getStream(dbc.post(uri, gson.toJson(tempView)));
}
return dbc.get(uri);
}
/**
* Queries a view.
* @param Object type T
* @param classOfT The class of type T
* @return The result of the view query as a {@code List }
*/
public List query(Class classOfT) {
InputStream instream = null;
try {
Reader reader = new InputStreamReader(instream = queryForStream());
JsonArray jsonArray = new JsonParser().parse(reader)
.getAsJsonObject().getAsJsonArray("rows");
List list = new ArrayList();
for (JsonElement jsonElem : jsonArray) {
JsonElement elem = jsonElem.getAsJsonObject();
if(Boolean.TRUE.equals(this.includeDocs)) {
elem = jsonElem.getAsJsonObject().get("doc");
}
T t = this.gson.fromJson(elem, classOfT);
list.add(t);
}
return list;
} finally {
close(instream);
}
}
/**
* Queries a view.
* @param Object type K (key)
* @param Object type V (value)
* @param classOfK The class of type K.
* @param classOfV The class of type V.
* @param classOfT The class of type T.
* @return The View result entries.
*/
public ViewResult queryView(Class classOfK, Class classOfV, Class classOfT) {
InputStream instream = null;
try {
Reader reader = new InputStreamReader(instream = queryForStream());
JsonObject json = new JsonParser().parse(reader).getAsJsonObject();
ViewResult vr = new ViewResult();
vr.setTotalRows(getElementAsLong(json, "total_rows"));
vr.setOffset(getElementAsInt(json, "offset"));
vr.setUpdateSeq(getElementAsLong(json, "update_seq"));
JsonArray jsonArray = json.getAsJsonArray("rows");
if(jsonArray.size() == 0) { // validate available rows
throw new NoDocumentException("No result was returned by this view query.");
}
for (JsonElement e : jsonArray) {
ViewResult.Rows row = vr.new Rows();
row.setId(JsonToObject(gson, e, "id", String.class));
row.setKey(JsonToObject(gson, e, "key", classOfK));
row.setValue(JsonToObject(gson, e, "value", classOfV));
if(Boolean.TRUE.equals(this.includeDocs)) {
row.setDoc(JsonToObject(gson, e, "doc", classOfT));
}
vr.getRows().add(row);
}
return vr;
} finally {
close(instream);
}
}
/**
* @return The result of the view as String.
*/
public String queryForString() {
return queryValue(String.class);
}
/**
* @return The result of the view as int.
*/
public int queryForInt() {
return queryValue(int.class);
}
/**
* @return The result of the view as long.
*/
public long queryForLong() {
return queryValue(long.class);
}
/**
* @return The result of the view as boolean.
*/
public boolean queryForBoolean() {
return queryValue(boolean.class);
}
/**
* Queries for scalar values. Internal use.
*/
private V queryValue(Class classOfV) {
InputStream instream = null;
try {
Reader reader = new InputStreamReader(instream = queryForStream());
JsonArray array = new JsonParser().parse(reader).
getAsJsonObject().get("rows").getAsJsonArray();
if(array.size() != 1) { // expect exactly 1 row
throw new NoDocumentException("Expecting exactly a single result of this view query, but was: " + array.size());
}
return JsonToObject(gson, array.get(0), "value", classOfV);
} finally {
close(instream);
}
}
/**
* Queries a view for pagination, returns a next or a previous page, this method
* figures out which page to return based on the given param that is generated by an
* earlier call to this method, quering the first page is done by passing a {@code null} param.
* @param Object type T
* @param rowsPerPage The number of rows per page.
* @param param The request parameter to use to query a page, or {@code null} to return the first page.
* @param classOfT The class of type T.
* @return {@link Page}
*/
public Page queryPage(int rowsPerPage, String param, Class classOfT) {
if(param == null) { // assume first page
return queryNextPage(rowsPerPage, null, null, null, null, classOfT);
}
String currentStartKey;
String currentStartKeyDocId;
String startKey;
String startKeyDocId;
String action;
try {
// extract fields from the returned HEXed JSON object
JsonObject json = new JsonParser().parse(new String(Base64.decodeBase64(param.getBytes()))).getAsJsonObject();
if(log.isDebugEnabled()) {
log.debug("Paging Param Decoded = " + json);
}
JsonObject jsonCurrent = json.getAsJsonObject(CURRENT_KEYS);
currentStartKey = jsonCurrent.get(CURRENT_START_KEY).getAsString();
currentStartKeyDocId = jsonCurrent.get(CURRENT_START_KEY_DOC_ID).getAsString();
startKey = json.get(START_KEY).getAsString();
startKeyDocId = json.get(START_KEY_DOC_ID).getAsString();
action = json.get(ACTION).getAsString();
} catch (Exception e) {
throw new CouchDbException("could not parse the given param!", e);
}
if(PREVIOUS.equals(action)) { // previous
return queryPreviousPage(rowsPerPage, currentStartKey, currentStartKeyDocId, startKey, startKeyDocId, classOfT);
} else { // next
return queryNextPage(rowsPerPage, currentStartKey, currentStartKeyDocId, startKey, startKeyDocId, classOfT);
}
}
/**
* @return The next page.
*/
private Page queryNextPage(int rowsPerPage, String currentStartKey,
String currentStartKeyDocId, String startKey, String startKeyDocId, Class classOfT) {
// set view query params
limit(rowsPerPage + 1);
includeDocs(true);
if(startKey != null) {
startKey(startKey);
startKeyDocId(startKeyDocId);
}
// init page, query view
Page page = new Page();
List pageList = new ArrayList();
ViewResult vr = queryView(String.class, String.class, classOfT);
List.Rows> rows = vr.getRows();
int resultRows = rows.size();
int offset = vr.getOffset();
long totalRows = vr.getTotalRows();
// holds page params
JsonObject currentKeys = new JsonObject();
JsonObject jsonNext = new JsonObject();
JsonObject jsonPrev = new JsonObject();
currentKeys.addProperty(CURRENT_START_KEY, rows.get(0).getKey());
currentKeys.addProperty(CURRENT_START_KEY_DOC_ID, rows.get(0).getId());
for (int i = 0; i < resultRows; i++) {
// set keys for the next page
if (i == resultRows - 1) { // last element (i.e rowsPerPage + 1)
if(resultRows > rowsPerPage) { // if not last page
page.setHasNext(true);
jsonNext.addProperty(START_KEY, rows.get(i).getKey());
jsonNext.addProperty(START_KEY_DOC_ID, rows.get(i).getId());
jsonNext.add(CURRENT_KEYS, currentKeys);
jsonNext.addProperty(ACTION, NEXT);
page.setNextParam(Base64.encodeBase64URLSafeString(jsonNext.toString().getBytes()));
continue; // exclude
}
}
pageList.add(rows.get(i).getDoc());
}
// set keys for the previous page
if(offset != 0) { // if not first page
page.setHasPrevious(true);
jsonPrev.addProperty(START_KEY, currentStartKey);
jsonPrev.addProperty(START_KEY_DOC_ID, currentStartKeyDocId);
jsonPrev.add(CURRENT_KEYS, currentKeys);
jsonPrev.addProperty(ACTION, PREVIOUS);
page.setPreviousParam(Base64.encodeBase64URLSafeString(jsonPrev.toString().getBytes()));
}
// calculate paging display info
page.setResultList(pageList);
page.setTotalResults(totalRows);
page.setResultFrom(offset + 1);
int resultTo = rowsPerPage > resultRows ? resultRows : rowsPerPage; // fix when rowsPerPage exceeds returned rows
page.setResultTo(offset + resultTo);
page.setPageNumber((int) Math.ceil(page.getResultFrom() / Double.valueOf(rowsPerPage)));
return page;
}
/**
* @return The previous page.
*/
private Page queryPreviousPage(int rowsPerPage, String currentStartKey,
String currentStartKeyDocId, String startKey, String startKeyDocId, Class classOfT) {
// set view query params
limit(rowsPerPage + 1);
includeDocs(true);
descending(true); // read backward
startKey(currentStartKey);
startKeyDocId(currentStartKeyDocId);
// init page, query view
Page page = new Page();
List pageList = new ArrayList();
ViewResult vr = queryView(String.class, String.class, classOfT);
List.Rows> rows = vr.getRows();
int resultRows = rows.size();
int offset = vr.getOffset();
long totalRows = vr.getTotalRows();
Collections.reverse(rows); // fix order
// holds page params
JsonObject currentKeys = new JsonObject();
JsonObject jsonNext = new JsonObject();
JsonObject jsonPrev = new JsonObject();
currentKeys.addProperty(CURRENT_START_KEY, rows.get(0).getKey());
currentKeys.addProperty(CURRENT_START_KEY_DOC_ID, rows.get(0).getId());
for (int i = 0; i < resultRows; i++) {
// set keys for the next page
if (i == resultRows - 1) { // last element (i.e rowsPerPage + 1)
if(resultRows >= rowsPerPage) { // if not last page
page.setHasNext(true);
jsonNext.addProperty(START_KEY, rows.get(i).getKey());
jsonNext.addProperty(START_KEY_DOC_ID, rows.get(i).getId());
jsonNext.add(CURRENT_KEYS, currentKeys);
jsonNext.addProperty(ACTION, NEXT);
page.setNextParam(Base64.encodeBase64URLSafeString(jsonNext.toString().getBytes()));
continue;
}
}
pageList.add(rows.get(i).getDoc());
}
// set keys for the previous page
if(offset != (totalRows - rowsPerPage - 1)) { // if not first page
page.setHasPrevious(true);
jsonPrev.addProperty(START_KEY, currentStartKey);
jsonPrev.addProperty(START_KEY_DOC_ID, currentStartKeyDocId);
jsonPrev.add(CURRENT_KEYS, currentKeys);
jsonPrev.addProperty(ACTION, PREVIOUS);
page.setPreviousParam(Base64.encodeBase64URLSafeString(jsonPrev.toString().getBytes()));
}
// calculate paging display info
page.setResultList(pageList);
page.setTotalResults(totalRows);
page.setResultFrom((int) totalRows - (offset + rowsPerPage));
int resultTo = (int) totalRows - offset - 1;
page.setResultTo(resultTo);
page.setPageNumber(resultTo / rowsPerPage);
return page;
}
// fields
/**
* @param key The key value, accepts a single value or multiple values for complex keys.
*/
public View key(Object... key) {
this.key = getKeyAsJson(key);
uriBuilder.query("key", this.key);
return this;
}
/**
* @param startKey The start key value, accepts a single value or multiple values for complex keys.
*/
public View startKey(Object... startKey) {
this.startKey = getKeyAsJson(startKey);
uriBuilder.query("startkey", this.startKey);
return this;
}
public View startKeyDocId(String startKeyDocId) {
this.startKeyDocId = startKeyDocId;
uriBuilder.query("startkey_docid", this.startKeyDocId);
return this;
}
/**
* @param endKey The end key value, accepts a single value or multiple values for complex keys.
*/
public View endKey(Object... endKey) {
this.endKey = getKeyAsJson(endKey);
uriBuilder.query("endkey", this.endKey);
return this;
}
public View endKeyDocId(String endKeyDocId) {
this.endKeyDocId = endKeyDocId;
uriBuilder.query("endkey_docid", this.endKeyDocId);
return this;
}
public View limit(Integer limit) {
this.limit = limit;
uriBuilder.query("limit", this.limit);
return this;
}
/**
* @param stale Accept values: ok | update_after (update_after as of CouchDB 1.1.0)
*/
public View stale(String stale) {
this.stale = stale;
uriBuilder.query("stale", this.stale);
return this;
}
/**
* Reverses the reading direction, not the sort order.
*/
public View descending(Boolean descending) {
this.descending = Boolean.valueOf(gson.toJson(descending));
uriBuilder.query("descending", this.descending);
return this;
}
/**
* @param skip Skips n number of documents.
*/
public View skip(Integer skip) {
this.skip = skip;
uriBuilder.query("skip", this.skip);
return this;
}
/**
* @param group Specifies whether the reduce function reduces the result to a set of keys,
* or to a single result. Defaults to false (single result).
*/
public View group(Boolean group) {
this.group = group;
uriBuilder.query("group", this.group);
return this;
}
public View groupLevel(Integer groupLevel) {
this.groupLevel = groupLevel;
uriBuilder.query("group_level", this.groupLevel);
return this;
}
/**
* @param reduce Indicates whether to use the reduce function of the view,
* defaults to true if the reduce function is defined.
*/
public View reduce(Boolean reduce) {
this.reduce = reduce;
uriBuilder.query("reduce", this.reduce);
return this;
}
public View includeDocs(Boolean includeDocs) {
this.includeDocs = includeDocs;
uriBuilder.query("include_docs", this.includeDocs);
return this;
}
/**
* @param inclusiveEnd Indicates whether the endkey is included in the result,
* defaults to true.
*/
public View inclusiveEnd(Boolean inclusiveEnd) {
this.inclusiveEnd = inclusiveEnd;
uriBuilder.query("inclusive_end", this.inclusiveEnd);
return this;
}
public View updateSeq(Boolean updateSeq) {
this.updateSeq = updateSeq;
uriBuilder.query("update_seq", this.updateSeq);
return this;
}
public View keys(List keys) {
this.allDocsKeys = String.format("{%s:%s}", gson.toJson("keys"), gson.toJson(keys));
return this;
}
// temp views
public View tempView(String id) {
assertNotEmpty(id, "id");
String viewPath = format("%s/%s/", TEMP_VIEWS_DIR, id);
List dirList = listResources(viewPath);
assertNotEmpty(dirList, "Temp view directory");
tempView = new MapReduce();
for (String mapRed : dirList) {
String def = readFile(format("/%s%s", viewPath, mapRed));
if(MAP_JS.equals(mapRed))
tempView.setMap(def);
else if(REDUCE_JS.equals(mapRed))
tempView.setReduce(def);
}
return this;
}
public View tempView(MapReduce mapReduce) {
assertNotEmpty(mapReduce, "mapReduce");
tempView = mapReduce;
return this;
}
private String getKeyAsJson(Object... key) {
return (key.length == 1) ? gson.toJson(key[0]) : gson.toJson(key); // single or complex key
}
}
LightCouch-lightcouch-0.0.6/src/main/java/org/lightcouch/ViewResult.java 0000664 0000000 0000000 00000004441 12150357216 0026232 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch;
import java.util.ArrayList;
import java.util.List;
import com.google.gson.annotations.SerializedName;
/**
* Holds a view result entries.
* @see View
* @author Ahmed Yehia
*/
public class ViewResult {
@SerializedName("total_rows")
private long totalRows;
@SerializedName("update_seq")
private long updateSeq;
private int offset;
private List rows = new ArrayList();
public long getTotalRows() {
return totalRows;
}
public long getUpdateSeq() {
return updateSeq;
}
public int getOffset() {
return offset;
}
public List getRows() {
return rows;
}
public void setTotalRows(long totalRows) {
this.totalRows = totalRows;
}
public void setUpdateSeq(long updateSeq) {
this.updateSeq = updateSeq;
}
public void setOffset(int offset) {
this.offset = offset;
}
public void setRows(List rows) {
this.rows = rows;
}
@Override
public String toString() {
return "ViewResult [totalRows=" + totalRows + ", updateSeq=" + updateSeq
+ ", offset=" + offset + ", rows=" + rows + "]";
}
/**
* Inner class holding the view rows.
*/
public class Rows {
private String id;
private K key;
private V value;
private T doc;
public String getId() {
return id;
}
public K getKey() {
return key;
}
public V getValue() {
return value;
}
public T getDoc() {
return doc;
}
public void setId(String id) {
this.id = id;
}
public void setKey(K key) {
this.key = key;
}
public void setValue(V value) {
this.value = value;
}
public void setDoc(T doc) {
this.doc = doc;
}
@Override
public String toString() {
return "Rows [id=" + id + "]";
}
}
}
LightCouch-lightcouch-0.0.6/src/test/ 0000775 0000000 0000000 00000000000 12150357216 0017445 5 ustar 00root root 0000000 0000000 LightCouch-lightcouch-0.0.6/src/test/java/ 0000775 0000000 0000000 00000000000 12150357216 0020366 5 ustar 00root root 0000000 0000000 LightCouch-lightcouch-0.0.6/src/test/java/org/ 0000775 0000000 0000000 00000000000 12150357216 0021155 5 ustar 00root root 0000000 0000000 LightCouch-lightcouch-0.0.6/src/test/java/org/lightcouch/ 0000775 0000000 0000000 00000000000 12150357216 0023306 5 ustar 00root root 0000000 0000000 LightCouch-lightcouch-0.0.6/src/test/java/org/lightcouch/tests/ 0000775 0000000 0000000 00000000000 12150357216 0024450 5 ustar 00root root 0000000 0000000 LightCouch-lightcouch-0.0.6/src/test/java/org/lightcouch/tests/Bar.java 0000664 0000000 0000000 00000000454 12150357216 0026022 0 ustar 00root root 0000000 0000000 package org.lightcouch.tests;
import org.lightcouch.Document;
public class Bar extends Document {
private String bar;
public String getBar() {
return bar;
}
public void setBar(String bar) {
this.bar = bar;
}
@Override
public String toString() {
return "Bar [bar=" + bar + "]";
}
}
LightCouch-lightcouch-0.0.6/src/test/java/org/lightcouch/tests/CouchDbClientLoadTest.java 0000664 0000000 0000000 00000005033 12150357216 0031422 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch.tests;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.lightcouch.CouchDbClient;
/**
* {@link CouchDbClient} load test.
*
* Run test:
*
$ mvn test -Dtest=org.lightcouch.tests.CouchDbClientLoadTest
*
* @author Ahmed Yehia
*
*/
public class CouchDbClientLoadTest {
private static CouchDbClient dbClient;
private static final int NUM_THREADS = 1;
private static final int NUM_DOCS = 1;
@BeforeClass
public static void setUpClass() {
dbClient = new CouchDbClient();
}
@AfterClass
public static void tearDownClass() {
dbClient.shutdown();
}
@Test
public void clientsLoadTest() {
// init
ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
// start
System.out.println("--------------- Load Test Running ...");
StopWatch.start();
for (int i = 0; i < NUM_THREADS; i++) {
executor.execute(new MyRunnable());
}
executor.shutdown();
do { /* waiting */ }
while (!executor.isTerminated());
// result
long elapsed = StopWatch.stop();
long seconds = elapsed / 1000;
int totalDocs = NUM_THREADS * NUM_DOCS;
StringBuilder sb = new StringBuilder();
sb.append("--------------- Load Test Ended:");
sb.append("\n* Thread count: " + NUM_THREADS);
sb.append(", Docs per thread: " + NUM_DOCS);
sb.append("\n* Saved total new documents: " + totalDocs);
sb.append(String.format("\n* Elapsed time: %s seconds, %s ms.", seconds, elapsed - (seconds * 1000)));
sb.append("\n* Average persisting time: " + (elapsed / totalDocs) + " ms per Document.");
System.out.println(sb);
}
private class MyRunnable implements Runnable {
public void run() {
for (int i = 0; i < NUM_DOCS; i++) {
dbClient.save(new Foo());
}
}
}
}
LightCouch-lightcouch-0.0.6/src/test/java/org/lightcouch/tests/CouchDbClientTest.java 0000664 0000000 0000000 00000045406 12150357216 0030632 0 ustar 00root root 0000000 0000000 /*
* Copyright (C) 2011 Ahmed Yehia (ahmed.yehia.m@gmail.com)
*
* Licensed 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.lightcouch.tests;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.commons.codec.binary.Base64;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.lightcouch.Attachment;
import org.lightcouch.Changes;
import org.lightcouch.ChangesResult;
import org.lightcouch.ChangesResult.Row;
import org.lightcouch.CouchDbClient;
import org.lightcouch.CouchDbInfo;
import org.lightcouch.DesignDocument;
import org.lightcouch.DocumentConflictException;
import org.lightcouch.NoDocumentException;
import org.lightcouch.Page;
import org.lightcouch.Params;
import org.lightcouch.ReplicationResult;
import org.lightcouch.ReplicationResult.ReplicationHistory;
import org.lightcouch.ReplicatorDocument;
import org.lightcouch.Response;
import org.lightcouch.ViewResult;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
/**
* API Integration testing with live databases.
*
* @author Ahmed Yehia
*/
public class CouchDbClientTest {
private static CouchDbClient dbClient;
private static CouchDbClient dbClient2;
@BeforeClass
public static void setUpClass() {
dbClient = new CouchDbClient();
dbClient2 = new CouchDbClient("couchdb-2.properties");
// dbClient = new CouchDbClient("db-name", true, "http", "127.0.0.1", 5984, "username", "secret");
/*CouchDbProperties properties = new CouchDbProperties()
.setDbName("db-name")
.setCreateDbIfNotExist(true)
.setProtocol("https")
.setHost("example.com")
.setPort(443)
.setUsername("username")
.setPassword("secret")
.setMaxConnections(100);*/
//dbClient = new CouchDbClient(properties);
}
@AfterClass
public static void tearDownClass() {
dbClient.shutdown();
dbClient2.shutdown();
}
// Find
@Test
public void findById() {
Response response = dbClient.save(new Foo());
Foo foo = dbClient.find(Foo.class, response.getId());
assertNotNull(foo);
}
@Test
public void findByIdAndRev() {
Response response = dbClient.save(new Foo());
Foo foo = dbClient.find(Foo.class, response.getId(), response.getRev());
assertNotNull(foo);
}
@Test
public void findPOJO() {
Response response = dbClient.save(new Foo());
Foo foo = dbClient.find(Foo.class, response.getId());
assertNotNull(foo);
}
@Test
public void findJsonObject() {
Response response = dbClient.save(new Foo());
JsonObject jsonObject = dbClient.find(JsonObject.class, response.getId());
assertNotNull(jsonObject);
}
@Test
public void findAny() {
JsonObject jsonObject = dbClient.findAny(JsonObject.class, dbClient.getDBUri().toString());
assertNotNull(jsonObject);
}
@Test
public void findInputstream() throws IOException {
Response response = dbClient.save(new Foo());
InputStream inputStream = dbClient.find(response.getId());
assertTrue(inputStream.read() != -1);
inputStream.close();
}
@Test
public void findWithParams() {
Response response = dbClient.save(new Foo());
Foo foo = dbClient.find(Foo.class, response.getId(), new Params().revsInfo().attachments());
assertNotNull(foo);
}
@Test(expected = IllegalArgumentException.class)
public void findWithInvalidId_throwsIllegalArgumentException() {
dbClient.find(Foo.class, "");
}
@Test(expected = NoDocumentException.class)
public void findWithUnknownId_throwsNoDocumentException() {
dbClient.find(Foo.class, generateUUID());
}
@Test
public void contains() {
boolean found = dbClient.contains(generateUUID());
assertFalse(found);
Response response = dbClient.save(new Foo());
found = dbClient.contains(response.getId());
assertTrue(found);
}
// Save
@Test
public void savePOJO() {
dbClient.save(new Foo());
}
@Test
public void saveMap() {
Map map = new HashMap();
map.put("_id", generateUUID());
map.put("field1", "value1");
dbClient.save(map);
}
@Test
public void saveJsonObject() {
JsonObject json = new JsonObject();
json.addProperty("_id", generateUUID());
json.add("an-array", new JsonArray());
dbClient.save(json);
}
@Test(expected = IllegalArgumentException.class)
public void saveInvalidObject_throwsIllegalArgumentException() {
dbClient.save(null);
}
@Test(expected = IllegalArgumentException.class)
public void saveWithRevision_throwsIllegalArgumentException() {
Bar bar = new Bar();
bar.setRevision("rev-val");
dbClient.save(bar);
}
@Test(expected = DocumentConflictException.class)
public void saveWitDuplicateId_throwsDocumentConflictException() {
Foo foo = new Foo(generateUUID());
dbClient.save(foo);
dbClient.save(foo);
}
@Test
public void batch() {
dbClient.batch(new Foo());
}
// Update
@Test
public void update() {
Response response = dbClient.save(new Foo());
Foo foo = dbClient.find(Foo.class, response.getId());
dbClient.update(foo);
}
@Test(expected = IllegalArgumentException.class)
public void updateWithoutIdAndRev_throwsIllegalArgumentException() {
dbClient.update(new Foo());
}
@Test(expected = DocumentConflictException.class)
public void updateWithOutdatedRev_throwsDocumentConflictException() {
Response response = dbClient.save(new Foo());
Foo foo = dbClient.find(Foo.class, response.getId());
dbClient.update(foo);
dbClient.update(foo);
}
// Bulk
@Test
public void bulkModifyDoc() {
List