Environment test and additional getters

ext/bdb.c

@@ -1647,16 +1647,15 @@ VALUE env_set_cachesize(VALUE obj, VALUE size)
 
   if ( TYPE(size) == T_BIGNUM ) {
     ln = rb_big2ull(size);
-    bytes = (u_int32_t) ln;
+		gbytes = ln / (1024*1024*1024);
-    gbytes = (u_int32_t) (ln >> sizeof(u_int32_t));
+		bytes = ln - (gbytes*1024*1024*1024);
   } else if (FIXNUM_P(size) ) {
-    bytes=NUM2INT(size);
+    bytes=NUM2UINT(size);
   } else {
     raise_error(0,"set_cachesize requires number");
     return Qnil;
   }
 
-  rb_warning("setting cache size %d %d %d",gbytes,bytes,1);
   rv=eh->env->set_cachesize(eh->env,gbytes,bytes,1);
   if ( rv != 0 ) {
     raise_error(rv, "set_cachesize failure: %s",db_strerror(rv));
@@ -1666,6 +1665,39 @@ VALUE env_set_cachesize(VALUE obj, VALUE size)
   return Qtrue;
 }
 
+/*
+ * call-seq:
+ * env.cachesize -> Fixnum|Bignum
+ *
+ * return the environment cache size. If it is a Bignum then it
+ * will populate the bytes and gbytes part of the DB struct.
+ * Fixnums will only populate bytes (which is still pretty big).
+ */
+VALUE env_get_cachesize(VALUE obj)
+{
+  t_envh *eh;
+  unsigned long long ln;
+  u_int32_t bytes=0,gbytes=0;
+	int ncache;
+  int rv;
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+
+  rv=eh->env->get_cachesize(eh->env,&gbytes,&bytes,&ncache);
+  if ( rv != 0 ) {
+    raise_error(rv, "get_cachesize failure: %s",db_strerror(rv));
+    return Qnil;
+  }
+
+	if (gbytes != 0)
+		return ULL2NUM(gbytes*1024*1024*1024+bytes);
+	else
+		return UINT2NUM(bytes);
+
+  return Qtrue;
+}
+
 VALUE env_set_flags(VALUE obj, VALUE vflags, int onoff)
 {
   t_envh *eh;
@@ -1688,6 +1720,32 @@ VALUE env_set_flags(VALUE obj, VALUE vflags, int onoff)
   return Qtrue;
 }
 
+/*
+ * call-seq:
+ * env.flags -> flags
+ *
+ * get what flags are on.
+ */
+VALUE env_get_flags(VALUE obj)
+{
+  t_envh *eh;
+  int rv;
+  u_int32_t flags;
+
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+
+   rv=eh->env->get_flags(eh->env,&flags);
+
+   if ( rv != 0 ) {
+     raise_error(rv, "set_flags failure: %s",db_strerror(rv));
+     return Qnil;
+   }
+
+  return UINT2NUM(flags);
+}
+
 /*
  * call-seq:
  * env.flags_on=flags
@@ -1701,6 +1759,7 @@ VALUE env_set_flags_on(VALUE obj, VALUE vflags)
 {
   return env_set_flags(obj,vflags,1);
 }
+
 /*
  * call-seq:
  * env.flags_off=flags
@@ -1714,6 +1773,7 @@ VALUE env_set_flags_off(VALUE obj, VALUE vflags)
 {
   return env_set_flags(obj,vflags,0);
 }
+
 /*
  * call-seq:
  * env.list_dbs -> [Bdb::Db array]
@@ -2286,6 +2346,29 @@ VALUE env_set_lk_max_locks(VALUE obj, VALUE vmax)
   return vmax;
 }
 
+/*
+ * call-seq:
+ * env.get_lk_max_locks -> max
+ *
+ * Get the maximum number of locks in the environment
+ */
+VALUE env_get_lk_max_locks(VALUE obj)
+{
+  t_envh *eh;
+  u_int32_t max;
+  int rv;
+
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+  rv=eh->env->get_lk_max_locks(eh->env,&max);
+  if ( rv != 0 ) {
+    raise_error(rv, "env_get_lk_max_locks: %s",db_strerror(rv));
+  }
+
+  return UINT2NUM(max);
+}
+
 /*
  * call-seq:
  * env.set_lk_max_objects(max) -> max
@@ -2311,6 +2394,29 @@ VALUE env_set_lk_max_objects(VALUE obj, VALUE vmax)
   return vmax;
 }
 
+/*
+ * call-seq:
+ * env.get_lk_max_objects -> max
+ *
+ * Get the maximum number of locks in the environment
+ */
+VALUE env_get_lk_max_objects(VALUE obj)
+{
+  t_envh *eh;
+  u_int32_t max;
+  int rv;
+
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+  rv=eh->env->get_lk_max_objects(eh->env,&max);
+  if ( rv != 0 ) {
+    raise_error(rv, "env_get_lk_max_objects: %s",db_strerror(rv));
+  }
+
+  return UINT2NUM(max);
+}
+
 VALUE env_report_stderr(VALUE obj)
 {
   t_envh *eh;
@@ -2350,6 +2456,37 @@ VALUE env_set_data_dir(VALUE obj, VALUE vdata_dir)
   return vdata_dir;
 }
 
+/*
+ * call-seq:
+ * env.get_data_dir -> [data_dir_1, data_dir_2, ...]
+ *
+ * get data_dir
+ */
+VALUE env_get_data_dirs(VALUE obj)
+{
+  t_envh *eh;
+  const char **data_dirs;
+  int rv;
+	int ln;
+
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+  rv=eh->env->get_data_dirs(eh->env,&data_dirs);
+  if ( rv != 0 ) {
+    raise_error(rv, "env_get_data_dir: %s",db_strerror(rv));
+  }
+
+	ln = (sizeof (data_dirs))/sizeof(data_dirs[0]);
+	VALUE rb_data_dirs = rb_ary_new2(ln);
+	int i;
+	for (i=0; i<ln; i++) {
+		rb_ary_push(rb_data_dirs, rb_str_new2(data_dirs[i]));
+	}
+	
+  return rb_data_dirs;
+}
+
 /*
  * call-seq:
  * env.set_lg_dir(lg_dir) -> lg_dir
@@ -2375,6 +2512,29 @@ VALUE env_set_lg_dir(VALUE obj, VALUE vlg_dir)
   return vlg_dir;
 }
 
+/*
+ * call-seq:
+ * env.get_lg_dir -> lg_dir
+ *
+ * get lg_dir
+ */
+VALUE env_get_lg_dir(VALUE obj)
+{
+  t_envh *eh;
+  const char *lg_dir;
+  int rv;
+
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+  rv=eh->env->get_lg_dir(eh->env,&lg_dir);
+  if ( rv != 0 ) {
+    raise_error(rv, "env_get_lg_dir: %s",db_strerror(rv));
+  }
+
+  return rb_str_new2(lg_dir);
+}
+
 /*
  * call-seq:
  * env.set_tmp_dir(tmp_dir) -> tmp_dir
@@ -2400,6 +2560,29 @@ VALUE env_set_tmp_dir(VALUE obj, VALUE vtmp_dir)
   return vtmp_dir;
 }
 
+/*
+ * call-seq:
+ * env.get_tmp_dir -> tmp_dir
+ *
+ * get tmp_dir
+ */
+VALUE env_get_tmp_dir(VALUE obj)
+{
+  t_envh *eh;
+  const char *tmp_dir;
+  int rv;
+
+  Data_Get_Struct(obj,t_envh,eh);
+  if (!eh->env)
+    raise(0, "env is closed");
+  rv=eh->env->get_tmp_dir(eh->env,&tmp_dir);
+  if ( rv != 0 ) {
+    raise_error(rv, "env_get_tmp_dir: %s",db_strerror(rv));
+  }
+
+  return rb_str_new2(tmp_dir);
+}
+
 static void txn_finish(t_txnh *txn)
 {
   if ( RTEST(ruby_debug) )
@@ -2626,6 +2809,8 @@ void Init_bdb() {
   rb_define_method(cEnv,"close",env_close,0);
   rb_define_method(cEnv,"db",env_db,0);
   rb_define_method(cEnv,"cachesize=",env_set_cachesize,1);
+ 	rb_define_method(cEnv,"cachesize",env_get_cachesize,0);
+	rb_define_method(cEnv,"flags",env_get_flags,0);
   rb_define_method(cEnv,"flags_on=",env_set_flags_on,1);
   rb_define_method(cEnv,"flags_off=",env_set_flags_off,1);
   rb_define_method(cEnv,"list_dbs",env_list_dbs,0);
@@ -2640,13 +2825,18 @@ void Init_bdb() {
   rb_define_method(cEnv,"set_lk_detect",env_set_lk_detect,1);
   rb_define_method(cEnv,"get_lk_detect",env_get_lk_detect,0);
   rb_define_method(cEnv,"set_lk_max_locks",env_set_lk_max_locks,1);
+	rb_define_method(cEnv,"get_lk_max_locks",env_get_lk_max_locks,0);
   rb_define_method(cEnv,"set_lk_max_objects",env_set_lk_max_objects,1);
+	rb_define_method(cEnv,"get_lk_max_objects",env_get_lk_max_objects,0);
   rb_define_method(cEnv,"set_shm_key",env_set_shm_key,1);
   rb_define_method(cEnv,"get_shm_key",env_get_shm_key,0);
 
   rb_define_method(cEnv,"set_data_dir",env_set_data_dir,1);
+	rb_define_method(cEnv,"get_data_dirs",env_get_data_dirs,0);
   rb_define_method(cEnv,"set_lg_dir",env_set_lg_dir,1);
+	rb_define_method(cEnv,"get_lg_dir",env_get_lg_dir,0);
   rb_define_method(cEnv,"set_tmp_dir",env_set_tmp_dir,1);
+	rb_define_method(cEnv,"get_tmp_dir",env_get_tmp_dir,0);
 
   cTxnStat = rb_define_class_under(mBdb,"TxnStat",rb_cObject);
   rb_define_method(cTxnStat,"[]",stat_aref,1);

test/env_test.rb

@@ -1,105 +1,89 @@
 require 'test_helper'
 
 class EnvTest < Test::Unit::TestCase
-
-  def test_new
     
-  end
-
-  def test_open
-    
-  end
-  
-  def test_close
-    
-  end
-  
-  def test_db
-    
-  end
-  
   def test_cachesize
-    
+    env = Bdb::Env.new(0)
+    env.cachesize = 1024*1024*500
+    assert_equal 1024*1024*500, env.cachesize
+
+    env.cachesize = 1024*1024*1024*3
+    assert_equal 1024*1024*1024*3, env.cachesize
+
+    env.cachesize = 1024*1024*1024*3+1
+    assert_equal 1024*1024*1024*3+1, env.cachesize
   end
   
-  def test_flags_on
+  def test_flags
-    
+    env = Bdb::Env.new(0)
+
+    env.flags_on = Bdb::DB_AUTO_COMMIT | Bdb::DB_DSYNC_DB
+    assert_equal Bdb::DB_AUTO_COMMIT | Bdb::DB_DSYNC_DB, env.flags    
+
+    env.flags_off = Bdb::DB_AUTO_COMMIT | Bdb::DB_DSYNC_DB
+    assert_equal 0, env.flags    
   end
-  
-  def test_flags_off
     
-  end
-  
   def test_list_dbs
+    env = Bdb::Env.new(0)
+    assert env.list_dbs.empty?
     
+    db = env.db
+    assert_equal db, env.list_dbs.first
+  end
+    
+  def test_set_and_get_timeout
+    env = Bdb::Env.new(0)
+    env.set_timeout(10, Bdb::DB_SET_LOCK_TIMEOUT)
+    assert_equal 10, env.get_timeout(Bdb::DB_SET_LOCK_TIMEOUT)
   end
   
-  def test_txn_begin
+  def test_set_and_get_tx_max
-    
+    env = Bdb::Env.new(0)
+    env.set_tx_max(100)
+    assert_equal 100, env.get_tx_max
   end
   
-  def test_txn_checkpoint
+  def test_set_and_get_lk_detect
+    env = Bdb::Env.new(0)
+    env.set_lk_detect(Bdb::DB_LOCK_MAXWRITE)
+    assert_equal Bdb::DB_LOCK_MAXWRITE, env.get_lk_detect
+  end
     
+  def test_set_and_get_lk_max_locks
+    env = Bdb::Env.new(0)
+    env.set_lk_max_locks(10_000)
+    assert_equal 10_000, env.get_lk_max_locks
   end
   
-  def test_txn_stat
+  def test_set_and_get_lk_max_objects
-    
+    env = Bdb::Env.new(0)
+    env.set_lk_max_objects(10_000)
+    assert_equal 10_000, env.get_lk_max_objects
   end
   
-  def test_set_timeout
+  def test_set_and_get_shm_key
-    
+    env = Bdb::Env.new(0)
+    env.set_shm_key(2506400)
+    assert_equal 2506400, env.get_shm_key
   end
-  
-  def test_get_timeout
-    
-  end
-  
-  def test_set_tx_max
-    
-  end
-  
-  def test_get_tx_max
-    
-  end
-  
-  def test_report_stderr
-    
-  end
-  
-  def test_set_lk_detect
-    
-  end
-  
-  def test_get_lk_detect
-    
-  end
-  
-  def test_set_lk_max_locks
-    
-  end
-  
-  def test_set_lk_max_objects
-    
-  end
-  
-  def test_set_shm_key
-    
-  end
-  
-  def test_get_shm_key
-    
-  end
-  
-  def test_set_data_dir
     
+  def test_set_and_get_data_dir
+    env = Bdb::Env.new(0)
+    env.set_data_dir('/tmp')
+    assert_equal ['/tmp'], env.get_data_dirs
   end
   
   def test_set_lg_dir
-    
+    env = Bdb::Env.new(0)
+    env.set_lg_dir('/tmp')
+    assert_equal '/tmp', env.get_lg_dir
   end
   
   def test_set_tmp_dir
-    
+    env = Bdb::Env.new(0)
+    env.set_tmp_dir('/tmp')
+    assert_equal '/tmp', env.get_tmp_dir    
   end
   
 end