VALUE
cb_bucket_observe(int argc, VALUE *argv, VALUE self)
{
struct cb_bucket_st *bucket = DATA_PTR(self);
struct cb_context_st *ctx;
VALUE rv, proc, exc;
lcb_error_t err;
struct cb_params_st params;
if (!cb_bucket_connected_bang(bucket, cb_sym_observe)) {
return Qnil;
}
memset(¶ms, 0, sizeof(struct cb_params_st));
rb_scan_args(argc, argv, "0*&", ¶ms.args, &proc);
if (!bucket->async && proc != Qnil) {
rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
}
params.type = cb_cmd_observe;
params.bucket = bucket;
cb_params_build(¶ms);
ctx = cb_context_alloc_common(bucket, proc, params.cmd.observe.num);
err = lcb_observe(bucket->handle, (const void *)ctx,
params.cmd.observe.num, params.cmd.observe.ptr);
cb_params_destroy(¶ms);
exc = cb_check_error(err, "failed to schedule observe request", Qnil);
if (exc != Qnil) {
cb_context_free(ctx);
rb_exc_raise(exc);
}
bucket->nbytes += params.npayload;
if (bucket->async) {
cb_maybe_do_loop(bucket);
return Qnil;
} else {
if (ctx->nqueries > 0) {
/* we have some operations pending */
lcb_wait(bucket->handle);
}
exc = ctx->exception;
rv = ctx->rv;
cb_context_free(ctx);
if (exc != Qnil) {
rb_exc_raise(exc);
}
exc = bucket->exception;
if (exc != Qnil) {
bucket->exception = Qnil;
rb_exc_raise(exc);
}
if (params.cmd.observe.num > 1 || params.cmd.observe.array) {
return rv; /* return as a hash {key => {}, ...} */
} else {
VALUE vv = Qnil;
rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
return vv; /* return first value */
}
}
}
/*
* Returns versions of the server for each node in the cluster
*
* @since 1.1.0
*
* @overload version
* @yieldparam [Result] ret the object with +error+, +node+, +operation+
* and +value+ attributes.
*
* @return [Hash] node-version pairs
*
* @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
* @raise [ArgumentError] when passing the block in synchronous mode
*
* @example Synchronous version request
* c.version #=> will render version
*
* @example Asynchronous version request
* c.run do
* c.version do |ret|
* ret.operation #=> :version
* ret.success? #=> true
* ret.node #=> "localhost:11211"
* ret.value #=> will render version
* end
* end
*/
VALUE
cb_bucket_version(int argc, VALUE *argv, VALUE self)
{
struct cb_bucket_st *bucket = DATA_PTR(self);
struct cb_context_st *ctx;
VALUE rv, exc, proc;
lcb_error_t err;
struct cb_params_st params;
if (!cb_bucket_connected_bang(bucket, cb_sym_version)) {
return Qnil;
}
memset(¶ms, 0, sizeof(struct cb_params_st));
rb_scan_args(argc, argv, "0*&", ¶ms.args, &proc);
if (!bucket->async && proc != Qnil) {
rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
}
params.type = cb_cmd_version;
params.bucket = bucket;
cb_params_build(¶ms);
ctx = cb_context_alloc_common(bucket, proc, params.cmd.version.num);
err = lcb_server_versions(bucket->handle, (const void *)ctx,
params.cmd.version.num, params.cmd.version.ptr);
exc = cb_check_error(err, "failed to schedule version request", Qnil);
cb_params_destroy(¶ms);
if (exc != Qnil) {
cb_context_free(ctx);
rb_exc_raise(exc);
}
bucket->nbytes += params.npayload;
if (bucket->async) {
cb_maybe_do_loop(bucket);
return Qnil;
} else {
if (ctx->nqueries > 0) {
/* we have some operations pending */
lcb_wait(bucket->handle);
}
exc = ctx->exception;
rv = ctx->rv;
cb_context_free(ctx);
if (exc != Qnil) {
rb_exc_raise(exc);
}
exc = bucket->exception;
if (exc != Qnil) {
bucket->exception = Qnil;
rb_exc_raise(exc);
}
return rv;
}
}
/*
* Obtain an object stored in Couchbase by given key.
*
* @since 1.0.0
*
* @see http://couchbase.com/docs/couchbase-manual-2.0/couchbase-architecture-apis-memcached-protocol-additions.html#couchbase-architecture-apis-memcached-protocol-additions-getl
*
* @overload get(*keys, options = {})
* @param keys [String, Symbol, Array] One or several keys to fetch
* @param options [Hash] Options for operation.
* @option options [true, false] :extended (false) If set to +true+, the
* operation will return a tuple +[value, flags, cas]+, otherwise (by
* default) it returns just the value.
* @option options [Fixnum] :ttl (self.default_ttl) Expiry time for key.
* Values larger than 30*24*60*60 seconds (30 days) are interpreted as
* absolute times (from the epoch).
* @option options [true, false] :quiet (self.quiet) If set to +true+, the
* operation won't raise error for missing key, it will return +nil+.
* Otherwise it will raise error in synchronous mode. In asynchronous
* mode this option ignored.
* @option options [Symbol] :format (nil) Explicitly choose the decoder
* for this key (+:plain+, +:document+, +:marshal+). See
* {Bucket#default_format}.
* @option options [Fixnum, Boolean] :lock Lock the keys for time span.
* If this parameter is +true+ the key(s) will be locked for default
* timeout. Also you can use number to setup your own timeout in
* seconds. If it will be lower that zero or exceed the maximum, the
* server will use default value. You can determine actual default and
* maximum values calling {Bucket#stats} without arguments and
* inspecting keys "ep_getl_default_timeout" and "ep_getl_max_timeout"
* correspondingly. See overloaded hash syntax to specify custom timeout
* per each key.
* @option options [true, false] :assemble_hash (false) Assemble Hash for
* results. Hash assembled automatically if +:extended+ option is true
* or in case of "get and touch" multimple keys.
* @option options [true, false, :all, :first, Fixnum] :replica
* (false) Read key from replica node. Options +:ttl+ and +:lock+
* are not compatible with +:replica+. Value +true+ is a synonym to
* +:first+, which means sequentially iterate over all replicas
* and return first successful response, skipping all failures.
* It is also possible to query all replicas in parallel using
* the +:all+ option, or pass a replica index, starting from zero.
*
* @yieldparam ret [Result] the result of operation in asynchronous mode
* (valid attributes: +error+, +operation+, +key+, +value+, +flags+,
* +cas+).
*
* @return [Object, Array, Hash] the value(s) (or tuples in extended mode)
* associated with the key.
*
* @raise [Couchbase::Error::NotFound] if the key is missing in the
* bucket.
*
* @raise [Couchbase::Error::Connect] if connection closed (see {Bucket#reconnect})
*
* @raise [ArgumentError] when passing the block in synchronous mode
*
* @example Get single value in quiet mode (the default)
* c.get("foo") #=> the associated value or nil
*
* @example Use alternative hash-like syntax
* c["foo"] #=> the associated value or nil
*
* @example Get single value in verbose mode
* c.get("missing-foo", :quiet => false) #=> raises Couchbase::NotFound
* c.get("missing-foo", :quiet => true) #=> returns nil
*
* @example Get and touch single value. The key won't be accessible after 10 seconds
* c.get("foo", :ttl => 10)
*
* @example Extended get
* val, flags, cas = c.get("foo", :extended => true)
*
* @example Get multiple keys
* c.get("foo", "bar", "baz") #=> [val1, val2, val3]
*
* @example Get multiple keys with assembing result into the Hash
* c.get("foo", "bar", "baz", :assemble_hash => true)
* #=> {"foo" => val1, "bar" => val2, "baz" => val3}
*
* @example Extended get multiple keys
* c.get("foo", "bar", :extended => true)
* #=> {"foo" => [val1, flags1, cas1], "bar" => [val2, flags2, cas2]}
*
* @example Asynchronous get
* c.run do
* c.get("foo", "bar", "baz") do |res|
* ret.operation #=> :get
* ret.success? #=> true
* ret.key #=> "foo", "bar" or "baz" in separate calls
* ret.value
* ret.flags
* ret.cas
* end
* end
*
* @example Get and lock key using default timeout
* c.get("foo", :lock => true)
*
* @example Determine lock timeout parameters
* c.stats.values_at("ep_getl_default_timeout", "ep_getl_max_timeout")
* #=> [{"127.0.0.1:11210"=>"15"}, {"127.0.0.1:11210"=>"30"}]
*
* @example Get and lock key using custom timeout
* c.get("foo", :lock => 3)
*
* @example Get and lock multiple keys using custom timeout
* c.get("foo", "bar", :lock => 3)
*
* @overload get(keys, options = {})
* When the method receive hash map, it will behave like it receive list
* of keys (+keys.keys+), but also touch each key setting expiry time to
* the corresponding value. But unlike usual get this command always
* return hash map +{key => value}+ or +{key => [value, flags, cas]}+.
*
* @param keys [Hash] Map key-ttl
* @param options [Hash] Options for operation. (see options definition
* above)
*
* @return [Hash] the values (or tuples in extended mode) associated with
* the keys.
*
* @example Get and touch multiple keys
* c.get("foo" => 10, "bar" => 20) #=> {"foo" => val1, "bar" => val2}
*
* @example Extended get and touch multiple keys
* c.get({"foo" => 10, "bar" => 20}, :extended => true)
* #=> {"foo" => [val1, flags1, cas1], "bar" => [val2, flags2, cas2]}
*
* @example Get and lock multiple keys for chosen period in seconds
* c.get("foo" => 10, "bar" => 20, :lock => true)
* #=> {"foo" => val1, "bar" => val2}
*/
VALUE
cb_bucket_get(int argc, VALUE *argv, VALUE self)
{
struct cb_bucket_st *bucket = DATA_PTR(self);
struct cb_context_st *ctx;
VALUE rv, proc, exc;
size_t ii;
lcb_error_t err = LCB_SUCCESS;
struct cb_params_st params;
if (!cb_bucket_connected_bang(bucket, cb_sym_get)) {
return Qnil;
}
memset(¶ms, 0, sizeof(struct cb_params_st));
rb_scan_args(argc, argv, "0*&", ¶ms.args, &proc);
if (!bucket->async && proc != Qnil) {
rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
}
params.type = cb_cmd_get;
params.bucket = bucket;
params.cmd.get.keys_ary = rb_ary_new();
cb_params_build(¶ms);
ctx = cb_context_alloc_common(bucket, proc, params.cmd.get.num);
ctx->extended = params.cmd.get.extended;
ctx->quiet = params.cmd.get.quiet;
ctx->transcoder = params.cmd.get.transcoder;
ctx->transcoder_opts = params.cmd.get.transcoder_opts;
if (RTEST(params.cmd.get.replica)) {
if (params.cmd.get.replica == cb_sym_all) {
ctx->nqueries = lcb_get_num_replicas(bucket->handle);
ctx->all_replicas = 1;
}
err = lcb_get_replica(bucket->handle, (const void *)ctx,
params.cmd.get.num, params.cmd.get.ptr_gr);
} else {
err = lcb_get(bucket->handle, (const void *)ctx,
params.cmd.get.num, params.cmd.get.ptr);
}
cb_params_destroy(¶ms);
exc = cb_check_error(err, "failed to schedule get request", Qnil);
if (exc != Qnil) {
cb_context_free(ctx);
rb_exc_raise(exc);
}
bucket->nbytes += params.npayload;
if (bucket->async) {
cb_maybe_do_loop(bucket);
return Qnil;
} else {
if (ctx->nqueries > 0) {
/* we have some operations pending */
lcb_wait(bucket->handle);
}
exc = ctx->exception;
rv = ctx->rv;
cb_context_free(ctx);
if (exc != Qnil) {
rb_exc_raise(exc);
}
exc = bucket->exception;
if (exc != Qnil) {
bucket->exception = Qnil;
rb_exc_raise(exc);
}
if (params.cmd.get.gat || params.cmd.get.assemble_hash ||
(params.cmd.get.extended && (params.cmd.get.num > 1 || params.cmd.get.array))) {
return rv; /* return as a hash {key => [value, flags, cas], ...} */
}
if (params.cmd.get.num > 1 || params.cmd.get.array) {
VALUE keys, ret;
ret = rb_ary_new();
/* make sure ret is guarded so not invisible in a register
* when stack scanning */
RB_GC_GUARD(ret);
keys = params.cmd.get.keys_ary;
for (ii = 0; ii < params.cmd.get.num; ++ii) {
rb_ary_push(ret, rb_hash_aref(rv, rb_ary_entry(keys, ii)));
}
return ret; /* return as an array [value1, value2, ...] */
} else {
VALUE vv = Qnil;
rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
return vv;
}
}
}
static inline VALUE
cb_bucket_store(lcb_storage_t cmd, int argc, VALUE *argv, VALUE self)
{
struct cb_bucket_st *bucket = DATA_PTR(self);
struct cb_context_st *ctx;
VALUE rv, proc, exc, obs = Qnil;
lcb_error_t err;
struct cb_params_st params;
if (!cb_bucket_connected_bang(bucket, storage_opcode_to_sym(cmd))) {
return Qnil;
}
memset(¶ms, 0, sizeof(struct cb_params_st));
rb_scan_args(argc, argv, "0*&", ¶ms.args, &proc);
if (!bucket->async && proc != Qnil) {
rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
}
params.type = cb_cmd_store;
params.bucket = bucket;
params.cmd.store.operation = cmd;
cb_params_build(¶ms);
obs = params.cmd.store.observe;
ctx = cb_context_alloc(bucket);
if (!bucket->async) {
ctx->rv = rb_hash_new();
ctx->observe_options = obs;
}
ctx->proc = proc;
ctx->nqueries = params.cmd.store.num;
err = lcb_store(bucket->handle, (const void *)ctx,
params.cmd.store.num, params.cmd.store.ptr);
cb_params_destroy(¶ms);
exc = cb_check_error(err, "failed to schedule set request", Qnil);
if (exc != Qnil) {
cb_context_free(ctx);
rb_exc_raise(exc);
}
bucket->nbytes += params.npayload;
if (bucket->async) {
cb_maybe_do_loop(bucket);
return Qnil;
} else {
if (ctx->nqueries > 0) {
/* we have some operations pending */
lcb_wait(bucket->handle);
}
exc = ctx->exception;
rv = ctx->rv;
cb_context_free(ctx);
if (exc != Qnil) {
rb_exc_raise(exc);
}
exc = bucket->exception;
if (exc != Qnil) {
bucket->exception = Qnil;
rb_exc_raise(exc);
}
if (RTEST(obs)) {
rv = rb_funcall(bucket->self, cb_id_observe_and_wait, 2, rv, obs);
}
if (params.cmd.store.num > 1) {
return rv; /* return as a hash {key => cas, ...} */
} else {
VALUE vv = Qnil;
rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
return vv;
}
}
}
static inline VALUE
cb_bucket_arithmetic(int sign, int argc, VALUE *argv, VALUE self)
{
struct bucket_st *bucket = DATA_PTR(self);
struct context_st *ctx;
VALUE args, rv, proc, exc;
lcb_error_t err;
struct params_st params;
if (bucket->handle == NULL) {
rb_raise(eConnectError, "closed connection");
}
rb_scan_args(argc, argv, "0*&", &args, &proc);
if (!bucket->async && proc != Qnil) {
rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
}
memset(¶ms, 0, sizeof(struct params_st));
params.type = cmd_arith;
params.bucket = bucket;
params.cmd.arith.sign = sign;
cb_params_build(¶ms, RARRAY_LEN(args), args);
ctx = xcalloc(1, sizeof(struct context_st));
if (ctx == NULL) {
rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
}
rv = rb_hash_new();
ctx->rv = &rv;
ctx->bucket = bucket;
ctx->proc = cb_gc_protect(bucket, proc);
ctx->exception = Qnil;
ctx->nqueries = params.cmd.arith.num;
err = lcb_arithmetic(bucket->handle, (const void *)ctx,
params.cmd.arith.num, params.cmd.arith.ptr);
cb_params_destroy(¶ms);
exc = cb_check_error(err, "failed to schedule arithmetic request", Qnil);
if (exc != Qnil) {
xfree(ctx);
rb_exc_raise(exc);
}
bucket->nbytes += params.npayload;
if (bucket->async) {
maybe_do_loop(bucket);
return Qnil;
} else {
if (ctx->nqueries > 0) {
/* we have some operations pending */
lcb_wait(bucket->handle);
}
exc = ctx->exception;
xfree(ctx);
if (exc != Qnil) {
cb_gc_unprotect(bucket, exc);
rb_exc_raise(exc);
}
if (params.cmd.store.num > 1) {
return rv; /* return as a hash {key => cas, ...} */
} else {
VALUE vv = Qnil;
rb_hash_foreach(rv, cb_first_value_i, (VALUE)&vv);
return vv;
}
return rv;
}
}