Support for Riak 2.0. Ability to use special indices $bucket, $key. Ability to provide max_results and continuation in db.query and get continuation back.

.jshintrc

@@ -0,0 +1,3 @@
+{
+  "es5": true
+}

.travis.yml

@@ -1,11 +1,13 @@
 language: node_js
+env:
+  - RIAK_VERSION=default
+  - RIAK_VERSION=2.0.0pre5 RIAK_RELEASE=2.0
+before_install:
+  - ./install_riak.sh
 node_js:
-  - "0.8"
   - "0.10"
 services:
   - riak
 script:
   - make test
-branches:
-  only:
-    - master
+

Makefile

@@ -1,13 +1,20 @@
-MOCHA_OPTS=-t 20000 test/*-test.js
+MOCHA_OPTS = -t 20000
 REPORTER = spec
 
+ifeq ($(RIAK_VERSION),default)
+TESTS = test/*-test.js test/1.4-specific/*-test.js
+else
+TESTS = test/*-test.js test/2.0-specific/*-test.js
+endif
+
 check: test
 
 test: test-unit
 
 test-unit:
 	@NODE_ENV=test ./node_modules/.bin/mocha \
 	    --reporter $(REPORTER) \
-		$(MOCHA_OPTS)
+		$(MOCHA_OPTS) \
+		$(TESTS)
 
-.PHONY: test
+.PHONY: test

install_riak.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+
+if [ $RIAK_VERSION != "default" ]
+then
+  echo "Stopping Riak service"
+  sudo service riak stop
+  sudo apt-get purge riak
+  riak_file="riak_$RIAK_VERSION-1_amd64.deb"
+  cd /tmp
+  echo "Downloading Riak $RIAK_VERSION"
+  wget http://s3.amazonaws.com/downloads.basho.com/riak/$RIAK_RELEASE/$RIAK_VERSION/ubuntu/precise/$riak_file
+  echo "Installing Riak $RIAK_VERSION"
+  sudo dpkg -i $riak_file
+  echo "Enabling Yokozuna"
+  sudo sed -i 's/yokozuna = off/yokozuna = on/' /etc/riak/riak.conf
+  echo "Use leveldb as the backend"
+  sudo sed -i 's/storage_backend = bitcask/storage_backend = leveldb/' /etc/riak/riak.conf
+  echo "Set ulimit"
+  sudo sh -c 'echo "ulimit -n 65536" > /etc/default/riak'
+  echo "Starting Riak..."
+  sudo service riak start
+fi

lib/http-client.js

@@ -10,6 +10,7 @@ var http = require('http'),
   HttpMeta = require('./http-meta'),
   HttpRequest = require('./http-request'),
   HttpSearchClient = require('./http-search-client'),
+  HttpYokozunaClient = require('./http-yokozuna-client'),
   Mapper = require('./mapper'),
   HttpMapReduceClient = require('./http-mapreduce-client'),
   Pool = require('poolee');
@@ -29,6 +30,7 @@ var HttpClient = function HttpClient(options) {
     this._execute(meta)
   }.bind(this);
   this.search = new HttpSearchClient(this._defaults, execute);
+  this.yokozuna = new HttpYokozunaClient(this._defaults, execute);
   this.mapreduce = new HttpMapReduceClient(this._defaults, execute);
   var pool = this._defaults.pool;
   if (pool) {
@@ -357,14 +359,18 @@ HttpClient.prototype.query = function(bucket, query, options, callback) {
     end = value[1];
     value = value[0];
   }
-
-  var type = typeof value == 'number' ? 'int' : 'bin',
-    key = "index/" + field + "_" + type + "/" + encodeURIComponent(value);
+
+
+  var typedIndex = field !=  "$bucket" && field != "$key";
+  var key = "index/" + field + ( typedIndex? ( "_" + (typeof value == 'number' ? 'int' : 'bin') ): "" ) + "/" + encodeURIComponent(value);
 
   if (end) key += "/" + encodeURIComponent(end);
 
   this.get(bucket, key, meta, function(err, data, _meta) {
+    var continuation = data && data.continuation;
     data = data ? data.keys : undefined;
+    if ( continuation && data  )
+        data.continuation = continuation;
     meta.callback(err, data, _meta);
   });
 

lib/http-meta.js

@@ -38,9 +38,15 @@ HttpMeta.prototype.loadResponse = function(response) {
     this.links = linkUtils.stringToLinks(response.client._httpMessage._headers.link);
   }
 
+  // 2ii
+  var indices = indexUtils.extract(headers);
+  if (indices) {
+    this.index = indices;
+  }
+
   // etag -- replace any quotes in the string
   if (headers.etag) this.etag = headers.etag.replace(/"/g, '');
-    
+
   // location
   if (headers.location) {
     var match = headers.location.match(/^\/([^\/]+)(?:\/([^\/]+))?\/([^\/]+)$/);
@@ -222,7 +228,10 @@ HttpMeta.queryProperties = [
   'vtag',
   'returnbody',
   'chunked',
-  'buckets'
+  'buckets',
+  'max_results',
+  'return_terms',
+  'continuation',
 ]
 
 module.exports = HttpMeta;
@@ -247,6 +256,49 @@ var _encodeUri = function(component, encodeUri) {
   return encodeURIComponent(component.replace(/\+/g, "%20"));
 }
 
+var indexUtils = {
+  Matcher: /x-riak-index-(.*)_(.*)/,
+
+  /**
+  * Parses indices from a response
+  * @param {Object} headers
+  * @return {Object} with indices in `Meta` representation.
+  * @api private
+  */
+  extract: function(headers) {
+    var rawIndices;
+    if (rawIndices = indexUtils.propsAndMatchesByRegex(indexUtils.Matcher, headers)) {
+      var indices = {};
+      rawIndices.forEach(function(index) {
+        var name = index.match[1];
+        var type = index.match[2];
+        var value = index.value;
+        if (type == "int") value = parseInt(value);
+        indices[name] = value;
+      })
+      return indices;
+    } else {
+      return false;
+    }
+  },
+
+  propsAndMatchesByRegex: function(r, obj) {
+    var m;
+    var key;
+    var res = [];
+    for (key in obj) {
+      if (m = r.exec(key)) {
+        res.push({ match: m, value: obj[key] });
+      }
+    }
+    if (res.length > 0) {
+      return res;
+    } else {
+      return false;
+    }
+  }
+}
+
 var linkUtils = {
 
   /**

lib/http-request.js

@@ -60,6 +60,8 @@ HttpRequest.prototype.execute = function() {
 
   this.client.emit('riak.request.start', this.event)
 
+
+
   var request = httpClient.request(meta, function(err, response) {
     var normalstatus = [200,201,204,300,304];
     if(self.event.method == 'delete') normalstatus.push(404);
@@ -236,7 +238,13 @@ HttpRequest.prototype.handleRequestEnd = function(buffer) {
   // deal with errors
   if (this.meta.statusCode >= 400) {
     var err = new Error();
-    err.message = buffer && buffer.toString().trim();
+    if ( buffer ){
+        if ( Array.isArray( buffer ) || buffer.length && Object.prototype.toString.call(buffer[0]) == '[object Number]' )
+            for ( var i = 0; i< buffer.length; i++ )
+                err.message += String.fromCharCode(buffer[i])
+        else
+            err.message = ( typeof buffer == "string" ? buffer : JSON.stringify( buffer ) ).trim();
+        }
     err.statusCode = this.meta.statusCode;
     buffer = err;
   }

lib/http-search-client.js

@@ -12,7 +12,7 @@ var XML = require('xml'),
  */
 var HttpSearchClient = function HttpSearchClient(options, callback) {
   this._execute = callback;
-  this._defaults = {resource: 'solr', method: 'get'};
+  this._defaults = {resource: 'search/query', method: 'get'};
 
   // need to add the options to the defaults object so as to not overwrite them
   // for the calling http-client
@@ -78,7 +78,7 @@ HttpSearchClient.prototype.remove = function(index, documents, callback) {
  * @param {Function} callback(err, data, meta
  */
 HttpSearchClient.prototype.find = function(index, query, options, callback) {
-  var meta = new HttpSearchMeta(this._defaults, options, {callback: callback, index: index, operation: 'select', q: query, wt: 'json', });
+  var meta = new HttpSearchMeta(this._defaults, options, {callback: callback, index: index, operation: '', q: query, wt: 'json' });
   this._run(meta);
 }
 

lib/http-search-meta.js

@@ -53,10 +53,16 @@ Object.defineProperty(HttpSearchMeta.prototype, 'path', {
     }.bind(this));
 
     var queryString = querystring.stringify(queryParameters),
-      operation = "/" + this.operation,
       index = "/" + this.index,
+      operation,
       qs = queryString ? "?" + queryString : '';
 
+    if(this.operation) {
+      operation = "/" + this.operation;
+    } else {
+      operation = "";
+    }
+
     return "/" + this.resource + index + operation + qs;
   },
   enumerable: true
@@ -84,13 +90,26 @@ var responseMappings = {
 
 HttpSearchMeta.queryProperties = [
   'q',
+  'fq',
   'start',
   'rows',
   'wt',
   'sort',
   'presort',
   'filter',
-  'fl'
+  'fl',
+  'df',
+  'facet',            //TODO: SOLR have huge ammount of options. nightmare to specify it all
+  'facet.field',
+  'facet.query',
+  'stats',
+  'stats.field',
+  'group',
+  'group.field',
+  'group.main',
+  'group.sort',
+  'group.limit'
+
 ];
 
 module.exports = HttpSearchMeta;

lib/http-yokozuna-client.js

@@ -0,0 +1,109 @@
+var HttpSearchMeta = require('./http-search-meta');
+
+/**
+ * Initialize a Riak Yokozuna Search client.
+ * Expects only a callback that's call to execute a search query, e.g.
+ * in the HttpClient, therefore doesn't have any coupling to the
+ * underlying transport.
+ *
+ * @param {Object} options
+ * @param {Function} callback(meta)
+ */
+var HttpYokozunaClient = function HttpYokozunaClient(options, callback) {
+  this._execute = callback;
+  this._defaults = {resource: 'search/query', method: 'get'};
+
+  // need to add the options to the defaults object so as to not overwrite them
+  // for the calling http-client
+
+  if (options.host) {
+    this._defaults.host = options.host;
+  }
+
+  if (options.port) {
+    this._defaults.port = options.port;
+  }
+
+  if (options.client) {
+    this._defaults.client = options.client;
+  }
+};
+
+/**
+ * Add a search index to yokozuna
+ *
+ * @param {String} index
+ * @param {String} schema
+ * @param {Function} callback(err)
+ *
+ * @api public
+ */
+HttpYokozunaClient.prototype.createIndex = function(index, schema, callback) {
+  if (typeof schema === 'function') {
+    callback = schema;
+    schema = null;
+    schema = null;
+  }
+
+  var meta = new HttpSearchMeta(this._defaults, {resource: 'yz'}, {method: 'put', callback: callback, index: 'index', operation: index});
+
+  this._execute(meta);
+};
+
+/**
+ * Remove a search index from yokozuna
+ *
+ * @param {String} index
+ * @param {String} schema
+ * @param {Function} callback(err)
+ *
+ * @api public
+ */
+HttpYokozunaClient.prototype.getIndex = function(index, callback) {
+  var meta = new HttpSearchMeta(this._defaults, {resource: 'yz'}, {callback: callback, index: 'index', operation: index});
+
+  this._execute(meta);
+};
+
+/**
+ * Find a set of documents in Riak Yokozuna in the specified index.
+ * The query must be a valid query string as described in the Riak Yokozuna
+ * documentation.
+ *
+ * The options can include all query options supported by Riak Yokozuna.
+ *
+ * @param {String} index
+ * @param {String} query
+ * @param {Object} options
+ * @param {Function} callback(err, data, meta
+ */
+HttpYokozunaClient.prototype.find = function(index, query, options, callback) {
+  var meta = new HttpSearchMeta(this._defaults, options, {callback: callback, index: index, q: query, wt: 'json' });
+  this._run(meta);
+};
+
+
+HttpYokozunaClient.prototype._run = function(meta) {
+  var callback = meta.callback;
+  meta.callback = function(err, data, meta) {
+    if (err) {
+      return callback(err, data, meta);
+    }
+
+    try {
+      data = JSON.parse(data.toString());
+    } catch (e) {
+      return callback(e, e, meta);
+    }
+     if ( !data.response) data.response = {};
+
+     data.response.facet_counts = data.facet_counts;
+     data.response.stats = data.stats;
+     data.response.grouped = data.grouped;
+
+    callback(err, data.response,  meta);
+  };
+  this._execute(meta);
+};
+
+module.exports = HttpYokozunaClient;