static PyObject *
Bucket_get_configured_replica_count(pycbc_Bucket *self, void *unused)
{
PyObject *iret = pycbc_IntFromUL(lcb_get_num_replicas(self->instance));
(void)unused;
return iret;
}
PHP_COUCHBASE_LOCAL
int validate_simple_observe_clause(lcb_t instance,
int persist,
int replicas TSRMLS_DC)
{
int num_replicas = lcb_get_num_replicas(instance);
int num_nodes = lcb_get_num_nodes(instance);
if ((persist > (num_replicas + 1)) || (replicas > num_replicas)) {
zend_throw_exception(cb_not_enough_nodes_exception,
"Not enough replicas to fulfill the request",
0 TSRMLS_CC);
return -1;
}
if ((persist > num_nodes) || ((replicas + 1) > num_nodes)) {
zend_throw_exception(cb_not_enough_nodes_exception,
"Not enough nodes to fulfill the request",
0 TSRMLS_CC);
return -1;
}
return 0;
}
/*
* 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 PyObject *
Connection_get_configured_replica_count(pycbc_Connection *self, void *unused)
{
PyObject *iret = pycbc_IntFromUL(lcb_get_num_replicas(self->instance));
return iret;
}
static int oks_extract_durability(php_couchbase_res *res,
struct observe_expectation *expectation,
struct observe_pollprefs *pollprefs,
zval *adurability)
{
zval *tmpval;
long tmplong = 0;
int available = lcb_get_num_replicas(res->handle);
#define _must_get_long(k, gt) \
tmplong = 0; \
tmpval = NULL; \
if ((tmpval = pcbc_ht_find(adurability, k, -1))) { \
if (IS_LONG != Z_TYPE_P(tmpval)) { \
php_error(E_RECOVERABLE_ERROR, k " must be numeric"); \
return -1; \
} \
tmplong = Z_LVAL_P(tmpval); \
if (tmplong < gt) { \
php_error(E_RECOVERABLE_ERROR, k " must be greater than %d", gt); \
} \
}
_must_get_long(COUCHBASE_OBSERVE_PERSIST_TO_KEY, 0);
expectation->persist = tmplong;
_must_get_long(COUCHBASE_OBSERVE_REPLICATE_TO_KEY, 0);
expectation->replicate = tmplong;
if (expectation->replicate > available) {
php_error(E_WARNING,
"Not enough replicas (want=%d, max=%d). Capping",
expectation->replicate, available);
expectation->replicate = available;
}
if (expectation->persist > available + 1) {
php_error(E_WARNING,
"Not enough nodes for persistence (want=%d, max=%d). Capping",
expectation->persist, available + 1);
expectation->persist = available + 1;
}
if (pollprefs) {
_must_get_long(COUCHBASE_OBSERVE_TIMEOUT_KEY, 1);
if (tmplong) {
pollprefs->timeout = tmplong;
} else {
pollprefs->timeout = INI_INT(PCBC_INIENT_OBS_TIMEOUT);
}
_must_get_long(COUCHBASE_OBSERVE_INTERVAL_KEY, 1);
if (tmplong) {
pollprefs->interval = tmplong;
} else {
pollprefs->interval = INI_INT(PCBC_INIENT_OBS_INTERVAL);
}
if (pollprefs->timeout <= 0 || pollprefs->interval <= 0) {
php_error(E_RECOVERABLE_ERROR,
"interval or timeout must be greater than 0");
return -1;
}
}
return 0;
#undef _must_get_long
}
