Ejemplo n.º 1
0
/*
   Flush any data in memory to disk
*/
void db_flush(void *vhandle)
{
    dbh_t *handle = vhandle;
    VILLA * dbp = handle->dbp;

    if (!vlsync(dbp))
	print_error(__FILE__, __LINE__, "(qdbm) vlsync err: %d, %s",
		    dpecode, dperrmsg(dpecode));
}
Ejemplo n.º 2
0
static VALUE
minidb_init(VALUE self, VALUE path)
{
    DEPOT *db;
    SafeStringValue(path);
    db = dpopen(RSTRING_PTR(path), DP_OREADER|DP_OWRITER|DP_OCREAT, 0);
    if (!db) {
        rb_raise(rb_eRuntimeError, "dpopen - %s", dperrmsg(dpecode));
    }
    DATA_PTR(self) = db;
    return self;
}
Ejemplo n.º 3
0
ex_t db_foreach(void *vhandle, db_foreach_t hook, void *userdata)
{
    int ret = 0;

    dbh_t *handle = vhandle;
    VILLA *dbp = handle->dbp;

    dbv_t dbv_key, dbv_data;
    int ksiz, dsiz;
    char *key, *data;

    ret = vlcurfirst(dbp);
    if (ret) {
	while ((key = vlcurkey(dbp, &ksiz))) {
	    data = vlcurval(dbp, &dsiz);
	    if (data) {
		/* switch to "dbv_t *" variables */
		dbv_key.leng = ksiz;
		dbv_key.data = xmalloc(dbv_key.leng+1);
		memcpy(dbv_key.data, key, ksiz);
		((char *)dbv_key.data)[dbv_key.leng] = '\0';

		dbv_data.data = data;
		dbv_data.leng = dsiz;		/* read count */

		/* call user function */
		ret = hook(&dbv_key, &dbv_data, userdata);

		xfree(dbv_key.data);

		if (ret != 0)
		    break;
		free(data); /* not xfree() as allocated by dpget() */
	    }
	    free(key); /* not xfree() as allocated by dpiternext() */

	    vlcurnext(dbp);
	}
    } else {
	print_error(__FILE__, __LINE__, "(qdbm) vlcurfirst err: %d, %s",
		    dpecode, dperrmsg(dpecode));
	exit(EX_ERROR);
    }

    return EX_OK;
}
Ejemplo n.º 4
0
/*
  Initialize database.
  Returns: pointer to database handle on success, NULL otherwise.
*/
void *db_open(void * dummy, bfpath *bfp, dbmode_t open_mode)
{
    dbh_t *handle;

    int open_flags;
    VILLA *dbp;

    UNUSED(dummy);

    if (open_mode & DS_WRITE)
	open_flags = VL_OWRITER;
    else
	open_flags = VL_OREADER;

    handle = dbh_init(bfp);

    if (handle == NULL) return NULL;

    dbp = handle->dbp = vlopen(handle->name, open_flags, cmpkey);

    if ((dbp == NULL) && (open_mode & DS_WRITE)) {
	dbp = handle->dbp = vlopen(handle->name, open_flags|VL_OCREAT, cmpkey);
	if (dbp != NULL)
	    handle->created = true;
    }

    if (dbp == NULL)
	goto open_err;

    if (DEBUG_DATABASE(1))
	fprintf(dbgout, "(qdbm) vlopen( %s, %d )\n", handle->name, open_mode);

    return handle;

 open_err:
    print_error(__FILE__, __LINE__, "(qdbm) vlopen(%s, %d), err: %d, %s",
		handle->name, open_flags, 
		dpecode, dperrmsg(dpecode));
    dbh_free(handle);

    return NULL;
}
Ejemplo n.º 5
0
int db_set_dbvalue(void *vhandle, const dbv_t *token, const dbv_t *val)
{
    int ret;
    dbh_t *handle = vhandle;
    VILLA *dbp = handle->dbp;

    ret = vlput(dbp, token->data, token->leng, val->data, val->leng, VL_DOVER);

    if (ret == 0) {
	print_error(__FILE__, __LINE__,
		    "(qdbm) db_set_dbvalue( '%.*s' ) err: %d, %s",
		    CLAMP_INT_MAX(token->leng), (char *)token->data,
		    dpecode, dperrmsg(dpecode));
	exit(EX_ERROR);
    }

    db_optimize(dbp, handle->name);

    return 0;
}
Ejemplo n.º 6
0
int db_delete(void *vhandle, const dbv_t *token)
{
    int ret;
    dbh_t *handle = vhandle;
    VILLA *dbp;

    dbp = handle->dbp;
    ret = vlout(dbp, token->data, token->leng);

    if (ret == 0) {
	print_error(__FILE__, __LINE__, "(qdbm) vlout('%.*s'), err: %d, %s",
		    CLAMP_INT_MAX(token->leng),
		    (char *)token->data, 
		    dpecode, dperrmsg(dpecode));
	exit(EX_ERROR);
    }
    ret = ret ^ 1;	/* ok is 1 in qdbm and 0 in bogofilter */

    return ret;		/* 0 if ok */
}
Ejemplo n.º 7
0
bool DBPrivWrite(DBPriv *db, const void *key, int key_size, const void *value, int value_size)
{
    if (!Lock(db))
    {
        return false;
    }

    if (!dpput(db->depot, key, key_size, value, value_size, DP_DOVER))
    {
        char *db_name = dpname(db->depot);
        Log(LOG_LEVEL_ERR, "Could not write key to DB '%s'. (dpput: %s)",
              db_name, dperrmsg(dpecode));
        free(db_name);
        Unlock(db);
        return false;
    }

    Unlock(db);
    return true;
}
Ejemplo n.º 8
0
bool DBPrivRead(DBPriv *db, const void *key, int key_size, void *dest, int dest_size)
{
    if (!Lock(db))
    {
        return false;
    }

    if (dpgetwb(db->depot, key, key_size, 0, dest_size, dest) == -1)
    {
        // FIXME: distinguish between "entry not found" and "failure to read"

        Log(LOG_LEVEL_DEBUG, "QDBM DBPrivRead: Could not read '%s', (dpgetwb: %s)",
                (const char *)key, dperrmsg(dpecode));

        Unlock(db);
        return false;
    }

    Unlock(db);
    return true;
}
Ejemplo n.º 9
0
DBPriv *DBPrivOpenDB(const char *filename, ARG_UNUSED dbid id)
{
    DBPriv *db = xcalloc(1, sizeof(DBPriv));

    pthread_mutex_init(&db->lock, NULL);
    pthread_mutex_init(&db->cursor_lock, NULL);

    db->depot = dpopen(filename, DP_OWRITER | DP_OCREAT, -1);

    if ((db->depot == NULL) && (dpecode == DP_EBROKEN))
    {
        Log(LOG_LEVEL_ERR, "Database '%s' is broken, trying to repair...", filename);

        if (dprepair(filename))
        {
            Log(LOG_LEVEL_INFO, "Successfully repaired database '%s'", filename);
        }
        else
        {
            Log(LOG_LEVEL_ERR, "Failed to repair database '%s', recreating...", filename);
            return DB_PRIV_DATABASE_BROKEN;
        }

        db->depot = dpopen(filename, DP_OWRITER | DP_OCREAT, -1);
    }

    if (db->depot == NULL)
    {
        Log(LOG_LEVEL_ERR, "dpopen: Opening database '%s' failed. (dpopen: %s)",
              filename, dperrmsg(dpecode));
        pthread_mutex_destroy(&db->cursor_lock);
        pthread_mutex_destroy(&db->lock);
        free(db);
        return NULL;
    }

    return db;
}
Ejemplo n.º 10
0
void DBPrivCloseDB(DBPriv *db)
{
    int ret;

    if ((ret = pthread_mutex_destroy(&db->lock)) != 0)
    {
        errno = ret;
        Log(LOG_LEVEL_ERR, "Lock is still active during QDBM database handle close. (pthread_mutex_destroy: %s)", GetErrorStr());
    }

    if ((ret = pthread_mutex_destroy(&db->cursor_lock)) != 0)
    {
        errno = ret;
        Log(LOG_LEVEL_ERR, "Cursor lock is still active during QDBM database handle close. (pthread_mutex_destroy: %s)", GetErrorStr());
    }

    if (!dpclose(db->depot))
    {
        Log(LOG_LEVEL_ERR, "Unable to close QDBM database. (dpclose: %s)", dperrmsg(dpecode));
    }

    free(db);
}
Ejemplo n.º 11
0
/*
   Close files and clean up.
*/
void db_close(void *vhandle)
{
    dbh_t *handle = vhandle;
    VILLA *dbp;

    if (handle == NULL) return;

    if (DEBUG_DATABASE(1))
	fprintf(dbgout, "(qdbm) vlclose(%s)\n", handle->name);

    dbp = handle->dbp;

    db_optimize(dbp, handle->name);

    if (!vlclose(dbp))
	print_error(__FILE__, __LINE__, "(qdbm) vlclose for %s err: %d, %s",
		    handle->name, 
		    dpecode, dperrmsg(dpecode));

    handle->dbp = NULL;

    dbh_free(handle);
}
Ejemplo n.º 12
0
JsonDb::Transaction::Transaction(std::string const &filename, ValuePointer const &_null_element)
{
	/* The null element */
	null_element = _null_element;

  /* open the database */
	db = StorageDbPointer(vlopen(filename.c_str(), VL_OWRITER | VL_OCREAT, VL_CMPINT), CloseDatabase);

	/* Start the transaction */
	vltranbegin(db.get());

	if(db.get() == NULL)
    throw std::runtime_error((boost::format("Failed to open database: %s") % dperrmsg(dpecode)).str().c_str());
	
	ValuePointer root = Retrieve(root_key);
	if(root.get() == NULL)
	{
		root = ValuePointer(new ValueObject(root_key));
		Store(root->GetKey(), root);
	}

	ValuePointer next_id_value = Retrieve(next_id_key);
	if(next_id_value.get() == NULL)
	{
		// Initialize values
		next_id = initial_next_id;
		start_next_id = next_id;
	} else
	{
		// Retrieve values from database
		next_id = next_id_value->GetValueInt();
		start_next_id = next_id;
	}

	// std::cout << "Start transaction, next id: " << next_id << std::endl;
}
Ejemplo n.º 13
0
int main(int argc, char *argv[])
{
   DEPOT            *dbmap = NULL;
   char             *str_prefix = "dbbm_key_prefix_";
   char             *key, keystr[24];
   unsigned long    i;
   int              rc = 0;
   PDUMMY_DATA      datap;
   
   if (argc < 3) {
      fprintf(stderr, "Usage : <prog> <dbpath> <datasize>\n");
      exit(1);
   }

   dbmap = dpopen(argv[1], DP_OWRITER|DP_OCREAT|DP_OSPARSE|DP_ONOLCK, -1);
   if (!dbmap) {
      fprintf(stderr, "Unable to open the dbbm file \n");
      exit(1);
   }

   datap = (PDUMMY_DATA) malloc(sizeof(DUMMY_DATA));
   if (!datap) {
      fprintf(stderr, "Malloc error %s\n", strerror(errno));
      exit(1);
   }

   unsigned long datasize = strtoul(argv[2], NULL, 10);
   // push data 
   for (i = 0; i < datasize; i++) {
      asprintf(keystr, "%s%lu", str_prefix, i);
      datap->x = i;
      datap->y = i+1;
      datap->z = i+2;
      if (!dpput(dbmap, keystr, strlen(keystr), (char *) datap, sizeof(DUMMY_DATA), 
            DP_DOVER)) {
         fprintf(stderr, "Unable to insert to qdbm\n");
      };
   }

   if(!dpclose(dbmap)){
      fprintf(stderr, "dpclose: %s\n", dperrmsg(dpecode));
      return 1;
   }

   //read data 
   dbmap = dpopen(argv[1], DP_OREADER, -1); 
   if (!dbmap) {
      fprintf(stderr, "Unable to open the dbbm file \n");
      exit(1);
   }

   fprintf(stdout, "Starting read of the database sequentially\n");

   if(!dpiterinit(dbmap)){
      fprintf(stderr, "dpiterinit: %s\n", dperrmsg(dpecode));
   }
   
   /* scan with the iterator */
   while ((key = dpiternext(dbmap, NULL)) != NULL) {
      if (!(datap = (PDUMMY_DATA) dpget(dbmap, key, -1, 0, sizeof(DUMMY_DATA), NULL))) {
         fprintf(stderr, "Value is not found for key %s\n", key);
         fprintf(stderr, "dpget: %s\n", dperrmsg(dpecode));
         free(key);
         break;
      }
/*      fprintf(stdout, "Data read for dbm : x=%lu y=%lu z=%lu\n", 
            datap->x, datap->y, datap->z);*/
      free(datap);
   }
   
   fprintf(stdout, "End of the database reached\n");
   
   if(!dpclose(dbmap)){
      fprintf(stderr, "dpclose: %s\n", dperrmsg(dpecode));
      return 1;
   }

   return 0;
}
Ejemplo n.º 14
0
Archivo: test.c Proyecto: ADTSH/io
int main(void)
{
	VILLA *villa;
	int size;
	char *s;
	
	printf("compareFunc(\"a\", \"b\") = %i\n", compareFunc("a", 1, "b", 1));
	printf("compareFunc(\"b\", \"a\") = %i\n", compareFunc("b", 1, "a", 1));
	printf("compareFunc(\"a\", \"a\") = %i\n", compareFunc("a", 1, "a", 1));
	printf("compareFunc(\"b\", \"b\") = %i\n", compareFunc("b", 1, "b", 1));
	
	remove("test.qdbm");
	
	if(!(villa = vlopen("test.qdbm", VL_OWRITER | VL_OCREAT, compareFunc)))
	{
		printf("vlopen failed %s\n", dperrmsg(dpecode));
		return 1;
	}

	if(!vltranbegin(villa))
	{
		printf("vltranbegin failed %s\n", dperrmsg(dpecode));
		return 1;	
	}
		
	if(!vlput(villa, "a", 1, "1", 1, DP_DOVER))
	{
		printf("vlput failed %s\n", dperrmsg(dpecode));
		return 1;
	}
	
	if(!vlput(villa, "b", 1, "2", 1, DP_DOVER))
	{
		printf("vlput failed %s\n", dperrmsg(dpecode));
		return 1;
	}
	
	if(!vltrancommit(villa))
	{
		printf("vltrancommit failed %s\n", dperrmsg(dpecode));
		return 1;	
	}
	
	if(!vlclose(villa))
	{
		printf("vlclose failed %s\n", dperrmsg(dpecode));
		return 1;
	}
	
	if(!(villa = vlopen("test.qdbm", VL_OWRITER | VL_OCREAT, compareFunc)))
	{
		printf("vlopen failed %s\n", dperrmsg(dpecode));
		return 1;
	}
	
	s = vlget(villa, "a", 1, &size);
	printf("a = '%s'\n", s ? s : "NULL");

	s = vlget(villa, "b", 1, &size);
	printf("b = '%s'\n", s ? s : "NULL");

	if(!vlclose(villa))
	{
		printf("vlclose failed %s\n", dperrmsg(dpecode));
		return 1;
	}
		
	return 0;
}
Ejemplo n.º 15
0
/* print an error message */
void pdperror(const char *name){
  fprintf(stderr, "%s: %s: %s\n", progname, name, dperrmsg(dpecode));
}
Ejemplo n.º 16
0
DBCursorPriv *DBPrivOpenCursor(DBPriv *db)
{
    if (!LockCursor(db))
    {
        return NULL;
    }

    if (!Lock(db))
    {
        UnlockCursor(db);
        return NULL;
    }

    if (!dpiterinit(db->depot))
    {
        Log(LOG_LEVEL_ERR, "Could not initialize QuickDB iterator. (dpiterinit: %s)", dperrmsg(dpecode));
        Unlock(db);
        UnlockCursor(db);
        return NULL;
    }

    DBCursorPriv *cursor = xcalloc(1, sizeof(DBCursorPriv));
    cursor->db = db;

    Unlock(db);

    /* Cursor remains locked */
    return cursor;
}
Ejemplo n.º 17
0
const char *db_str_err(int e)
{
    return dperrmsg(e);
}