/*
 *  call-seq:
 *     lmc.clear -> Qnil
 *
 *  Clears content of hashtable.
 */
static mrb_value Cache__clear(mrb_state *mrb, mrb_value self)
{
  local_memcache_t *lmc = get_Cache(mrb, self);
  if (!local_memcache_clear(lmc))
    rb_lmc_raise_exception(mrb, &lmc->error);
  return mrb_nil_value();
}
/* :nodoc: */
static mrb_value Cache_init(mrb_state *mrb, mrb_value self)
{
  mrb_value o;
  mrb_get_args(mrb, "o", &o);
  lmc_check_dict(mrb, o);
  lmc_error_t e;
  rb_lmc_handle_t *h;

  local_memcache_t *l = local_memcache_create(rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_namespace(mrb))),
                                              rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_filename(mrb))),
                                              double_value(mrb, mrb_hash_get(mrb, o, lmc_rb_sym_size_mb(mrb))),
                                              size_t_value(mrb_hash_get(mrb, o, lmc_rb_sym_min_alloc_size(mrb))), &e);

  if (!l)
    rb_lmc_raise_exception(mrb, &e);

  h = (rb_lmc_handle_t *)DATA_PTR(self);
  if (h) {
    mrb_free(mrb, h);
  }
  DATA_TYPE(self) = &lmc_cache_type;
  DATA_PTR(self) = NULL;

  h = (rb_lmc_handle_t *)mrb_malloc(mrb, sizeof(rb_lmc_handle_t));
  if (!h) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "memory allocation error");
  }

  h->lmc = l;
  h->open = 1;

  DATA_PTR(self) = h;

  return self;
}
/*
 *  call-seq:
 *     lmc.close()   ->   Qnil
 *
 *  Releases hashtable.
 */
static mrb_value Cache__close(mrb_state *mrb, mrb_value self)
{
  lmc_error_t e;
  rb_lmc_handle_t *h = DATA_PTR(self);
  if (!local_memcache_free(rb_lmc_check_handle_access(mrb, h), &e))
    rb_lmc_raise_exception(mrb, &e);
  h->open = 0;
  return mrb_nil_value();
}
예제 #4
0
/* 
 *  call-seq:
 *     lmc.close()   ->   Qnil
 *
 *  Releases hashtable.
 */
static VALUE LocalMemCache__close(VALUE obj) {
  lmc_error_t e;
  rb_lmc_handle_t *h;
  Data_Get_Struct(obj, rb_lmc_handle_t, h);
  if (!local_memcache_free(rb_lmc_check_handle_access(h), &e)) 
      rb_lmc_raise_exception(&e);
  h->open = 0;
  return Qnil;
}
예제 #5
0
/* 
 *  call-seq:
 *     lmc.set(key, value)   ->   Qnil
 *     lmc[key]=value        ->   Qnil
 *
 *  Set value for key in hashtable.  Value and key will be converted to
 *  string.
 */
static VALUE LocalMemCache__set(VALUE obj, VALUE key, VALUE value) {
  local_memcache_t *lmc = get_LocalMemCache(obj);
  lmc_rb_str_d_t k, v;
  rstring_acquire(key, &k);
  rstring_acquire(value, &v);
  if (!local_memcache_set(lmc, k.cstr, k.len, v.cstr, v.len)) { 
    rb_lmc_raise_exception(&lmc->error); 
  }
  return Qnil;
}
예제 #6
0
/*
 * call-seq: LocalMemCache.check(*args)
 *
 * Tries to repair a corrupt namespace.  Usually one doesn't call this method
 * directly, it's invoked automatically when operations time out.
 *
 * valid options are 
 * [:namespace] 
 * [:filename] 
 *
 * The memory pool must be specified by either setting the :filename or
 * :namespace option. 
 */
static VALUE LocalMemCache__check(VALUE klass, VALUE o) {
  lmc_check_dict(o);
  lmc_error_t e;
  if (!local_memcache_check_namespace(
      rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_namespace)), 
      rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_filename)),
      &e)) {
    rb_lmc_raise_exception(&e); 
  }
  return Qnil;
}
/*
 * call-seq: Cache.drop(*args)
 *
 * Deletes a memory pool.  If the :force option is set, locked semaphores are
 * removed as well.
 *
 * WARNING: Do only call this method with the :force option if you are sure
 * that you really want to remove this memory pool and no more processes are
 * still using it.
 *
 * If you delete a pool and other processes still have handles open on it, the
 * status of these handles becomes undefined.  There's no way for a process to
 * know when a handle is not valid anymore, so only delete a memory pool if
 * you are sure that all handles are closed.
 *
 * valid options for drop are
 * [:namespace]
 * [:filename]
 * [:force]
 *
 * The memory pool must be specified by either setting the :filename or
 * :namespace option.  The default for :force is false.
 */
static mrb_value Cache__drop(mrb_state *mrb, mrb_value self)
{
  mrb_value o;
  mrb_get_args(mrb, "o", &o);
  lmc_check_dict(mrb, o);
  lmc_error_t e;
  if (!local_memcache_drop_namespace(rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_namespace(mrb))),
                                     rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_filename(mrb))),
                                     bool_value(mrb_hash_get(mrb, o, lmc_rb_sym_force(mrb))), &e)) {
    rb_lmc_raise_exception(mrb, &e);
  }
  return mrb_nil_value();
}
예제 #8
0
/* :nodoc: */
static VALUE LocalMemCache__new2(VALUE klass, VALUE o) {
  lmc_check_dict(o);
  lmc_error_t e;
  local_memcache_t *l = local_memcache_create(
      rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_namespace)),
      rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_filename)), 
      double_value(rb_hash_aref(o, lmc_rb_sym_size_mb)),
      long_value(rb_hash_aref(o, lmc_rb_sym_min_alloc_size)), &e);
  if (!l)  rb_lmc_raise_exception(&e);
  rb_lmc_handle_t *h = calloc(1, sizeof(rb_lmc_handle_t));
  if (!h) rb_raise(rb_eRuntimeError, "memory allocation error");
  h->lmc = l;
  h->open = 1;
  return Data_Wrap_Struct(klass, NULL, rb_lmc_free_handle, h);
}
/* :nodoc: */
static void rb_lmc_cache_destructor(mrb_state *mrb, void *p)
{
  rb_lmc_handle_t *h;
  lmc_error_t e;

  h = (rb_lmc_handle_t *)p;
  if (!h || (h->open == 0) || !h->lmc)
    return;

  if (!local_memcache_free(h->lmc, &e)) {
    mrb_free(mrb, p);
    rb_lmc_raise_exception(mrb, &e);
    return;
  }

  mrb_free(mrb, p);
}
예제 #10
0
/*
 *  call-seq:
 *     lmc.set(key, value)   ->   Qnil
 *     lmc[key]=value        ->   Qnil
 *
 *  Set value for key in hashtable.  Value and key will be converted to
 *  string.
 */
static mrb_value Cache__set(mrb_state *mrb, mrb_value self)
{
  local_memcache_t *lmc = get_Cache(mrb, self);
  mrb_value key, value;
  mrb_cache_iovec_t k, v;

  mrb_get_args(mrb, "oo", &key, &value);
  if (mrb_type(key) != MRB_TT_STRING || mrb_type(value) != MRB_TT_STRING) {
    mrb_raise(mrb, E_TYPE_ERROR, "both key and value must be STRING");
  }

  mrb_cache_str_to_iovec(mrb, key, &k);
  mrb_cache_str_to_iovec(mrb, value, &v);

  if (!local_memcache_set(lmc, k.base, k.len, v.base, v.len)) {
    rb_lmc_raise_exception(mrb, &lmc->error);
  }
  return mrb_nil_value();
}
예제 #11
0
/*
 *  call-seq: 
 *     lmc.clear -> Qnil
 *
 *  Clears content of hashtable.
 */
static VALUE LocalMemCache__clear(VALUE obj) {
  local_memcache_t *lmc = get_LocalMemCache(obj);
  if (!local_memcache_clear(lmc)) rb_lmc_raise_exception(&lmc->error); 
  return Qnil;
}