/* perform create command */
static int proccreate(const char *name){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
if(!tcadbclose(adb)){
printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
TCADB *openadb(const char *dbname){
TCADB *adb = tcadbnew();
if(!tcadbopen(adb, dbname)) {
fprintf(stderr, "open error: %s\n", dbname);
}
return adb;
}
/* Open a concrete database */
static int
tc_adb_open (TCADB * adb, const char *params)
{
/* attempt to open the database */
if (!tcadbopen (adb, params))
return 1;
return 0;
}
/* perform map command */
static int procmap(const char *name, const char *dest, const char *fmstr){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
TCBDB *bdb = tcbdbnew();
if(!tcbdbopen(bdb, dest, BDBOWRITER | BDBOCREAT | BDBOTRUNC)){
printerr(adb);
tcbdbdel(bdb);
tcadbdel(adb);
return 1;
}
if(fmstr){
TCLIST *keys = tcadbfwmkeys2(adb, fmstr, -1);
if(!tcadbmapbdb(adb, keys, bdb, mapbdbproc, NULL, -1)){
printerr(adb);
err = true;
}
tclistdel(keys);
} else {
if(!tcadbmapbdb(adb, NULL, bdb, mapbdbproc, NULL, -1)){
printerr(adb);
err = true;
}
}
if(!tcbdbclose(bdb)){
printerr(adb);
err = true;
}
tcbdbdel(bdb);
if(!tcadbclose(adb)){
printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
static void *open_db(struct benchmark_config *config)
{
if (adb)
return adb;
adb = tcadbnew();
if (!tcadbopen(adb, config->path)) {
die("open error: %s", config->path);
}
return adb;
}
/* perform inform command */
static int procinform(const char *name){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
const char *path = tcadbpath(adb);
if(!path) path = "(unknown)";
printf("path: %s\n", path);
const char *type = "(unknown)";
switch(tcadbomode(adb)){
case ADBOVOID: type = "not opened"; break;
case ADBOMDB: type = "on-memory hash database"; break;
case ADBONDB: type = "on-memory tree database"; break;
case ADBOHDB: type = "hash database"; break;
case ADBOBDB: type = "B+ tree database"; break;
case ADBOFDB: type = "fixed-length database"; break;
case ADBOTDB: type = "table database"; break;
case ADBOSKEL: type = "skeleton database"; break;
}
printf("database type: %s\n", type);
printf("record number: %llu\n", (unsigned long long)tcadbrnum(adb));
printf("size: %llu\n", (unsigned long long)tcadbsize(adb));
if(!tcadbclose(adb)){
printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
/* perform misc command */
static int procmisc(const char *name, const char *func, const TCLIST *args, int sep, bool px){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
TCLIST *res = tcadbmisc(adb, func, args);
if(res){
for(int i = 0; i < tclistnum(res); i++){
int rsiz;
const char *rbuf = tclistval(res, i, &rsiz);
printdata(rbuf, rsiz, px, sep);
printf("\n");
}
tclistdel(res);
} else {
printerr(adb);
err = true;
}
if(!tcadbclose(adb)){
if(!err) printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
/* perform get command */
static int procget(const char *name, const char *kbuf, int ksiz, int sep, bool px, bool pz){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
int vsiz;
char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
if(vbuf){
printdata(vbuf, vsiz, px, sep);
if(!pz) putchar('\n');
tcfree(vbuf);
} else {
printerr(adb);
err = true;
}
if(!tcadbclose(adb)){
if(!err) printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
/* perform remove command */
static int procremove(const char *name, int tnum){
iprintf("<Removing Test>\n seed=%u name=%s tnum=%d\n\n", g_randseed, name, tnum);
bool err = false;
double stime = tctime();
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
eprint(adb, __LINE__, "tcadbsetskel");
err = true;
skel.del(skel.opq);
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, MULDIVNUM)){
eprint(adb, __LINE__, "tcadbsetskelmulti");
err = true;
}
name++;
}
if(!tcadbopen(adb, name)){
eprint(adb, __LINE__, "tcadbopen");
err = true;
}
int rnum = tcadbrnum(adb) / tnum;
TARGREMOVE targs[tnum];
pthread_t threads[tnum];
if(tnum == 1){
targs[0].adb = adb;
targs[0].rnum = rnum;
targs[0].id = 0;
if(threadremove(targs) != NULL) err = true;
} else {
for(int i = 0; i < tnum; i++){
targs[i].adb = adb;
targs[i].rnum = rnum;
targs[i].id = i;
if(pthread_create(threads + i, NULL, threadremove, targs + i) != 0){
eprint(adb, __LINE__, "pthread_create");
targs[i].id = -1;
err = true;
}
}
for(int i = 0; i < tnum; i++){
if(targs[i].id == -1) continue;
void *rv;
if(pthread_join(threads[i], &rv) != 0){
eprint(adb, __LINE__, "pthread_join");
err = true;
} else if(rv){
err = true;
}
}
}
iprintf("record number: %llu\n", (unsigned long long)tcadbrnum(adb));
iprintf("size: %llu\n", (unsigned long long)tcadbsize(adb));
sysprint();
if(!tcadbclose(adb)){
eprint(adb, __LINE__, "tcadbclose");
err = true;
}
tcadbdel(adb);
iprintf("time: %.3f\n", tctime() - stime);
iprintf("%s\n\n", err ? "error" : "ok");
return err ? 1 : 0;
}
/* perform list command */
static int proclist(const char *name, int sep, int max, bool pv, bool px, const char *fmstr){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
if(fmstr){
TCLIST *keys = tcadbfwmkeys2(adb, fmstr, max);
for(int i = 0; i < tclistnum(keys); i++){
int ksiz;
const char *kbuf = tclistval(keys, i, &ksiz);
printdata(kbuf, ksiz, px, sep);
if(pv){
int vsiz;
char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
if(vbuf){
putchar('\t');
printdata(vbuf, vsiz, px, sep);
tcfree(vbuf);
}
}
putchar('\n');
}
tclistdel(keys);
} else {
if(!tcadbiterinit(adb)){
printerr(adb);
err = true;
}
int ksiz;
char *kbuf;
int cnt = 0;
while((kbuf = tcadbiternext(adb, &ksiz)) != NULL){
printdata(kbuf, ksiz, px, sep);
if(pv){
int vsiz;
char *vbuf = tcadbget(adb, kbuf, ksiz, &vsiz);
if(vbuf){
putchar('\t');
printdata(vbuf, vsiz, px, sep);
tcfree(vbuf);
}
}
putchar('\n');
tcfree(kbuf);
if(max >= 0 && ++cnt >= max) break;
}
}
if(!tcadbclose(adb)){
if(!err) printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
/* perform put command */
static int procput(const char *name, const char *kbuf, int ksiz, const char *vbuf, int vsiz,
int dmode){
TCADB *adb = tcadbnew();
ADBSKEL skel;
if(*name == '@'){
setskeltran(&skel);
if(!tcadbsetskel(adb, &skel)){
printerr(adb);
skel.del(skel.opq);
tcadbdel(adb);
return 1;
}
name++;
} else if(*name == '%'){
if(!tcadbsetskelmulti(adb, 8)){
printerr(adb);
tcadbdel(adb);
return 1;
}
name++;
}
if(!tcadbopen(adb, name)){
printerr(adb);
tcadbdel(adb);
return 1;
}
bool err = false;
switch(dmode){
case -1:
if(!tcadbputkeep(adb, kbuf, ksiz, vbuf, vsiz)){
printerr(adb);
err = true;
}
break;
case 1:
if(!tcadbputcat(adb, kbuf, ksiz, vbuf, vsiz)){
printerr(adb);
err = true;
}
break;
case 10:
if(tcadbaddint(adb, kbuf, ksiz, tcatoi(vbuf)) == INT_MIN){
printerr(adb);
err = true;
}
break;
case 11:
if(isnan(tcadbadddouble(adb, kbuf, ksiz, tcatof(vbuf)))){
printerr(adb);
err = true;
}
break;
default:
if(!tcadbput(adb, kbuf, ksiz, vbuf, vsiz)){
printerr(adb);
err = true;
}
break;
}
if(!tcadbclose(adb)){
if(!err) printerr(adb);
err = true;
}
tcadbdel(adb);
return err ? 1 : 0;
}
gearman_return_t gearman_queue_libtokyocabinet_init(gearman_server_st *server,
gearman_conf_st *conf)
{
gearman_queue_libtokyocabinet_st *queue;
gearman_conf_module_st *module;
const char *name;
const char *value;
const char *opt_file= NULL;
const char *opt_optimize= NULL;
gearman_log_info(server->gearman, "Initializing libtokyocabinet module");
queue= calloc(1, sizeof(gearman_queue_libtokyocabinet_st));
if (queue == NULL)
{
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init", "malloc");
return GEARMAN_MEMORY_ALLOCATION_FAILURE;
}
if ((queue->db= tcadbnew()) == NULL)
{
free(queue);
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init",
"tcadbnew");
return GEARMAN_QUEUE_ERROR;
}
/* Get module and parse the option values that were given. */
module= gearman_conf_module_find(conf, "libtokyocabinet");
if (module == NULL)
{
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init",
"modconf_module_find:NULL");
return GEARMAN_QUEUE_ERROR;
}
while (gearman_conf_module_value(module, &name, &value))
{
if (!strcmp(name, "file"))
opt_file= value;
else if (!strcmp(name, "optimize"))
opt_optimize= value;
else
{
tcadbdel(queue->db);
free(queue);
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init",
"Unknown argument: %s", name);
return GEARMAN_QUEUE_ERROR;
}
}
if (opt_file == NULL)
{
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init",
"No --file given");
return GEARMAN_QUEUE_ERROR;
}
if (!tcadbopen(queue->db, opt_file))
{
tcadbdel(queue->db);
free(queue);
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init",
"tcadbopen(%s): %s", opt_file, _libtokyocabinet_tcaerrmsg(queue->db));
return GEARMAN_QUEUE_ERROR;
}
if (opt_optimize == NULL || !strcasecmp(opt_optimize, "yes"))
{
gearman_log_info(server->gearman, "libtokyocabinet optimizing database file");
if (!tcadboptimize(queue->db, NULL))
{
tcadbdel(queue->db);
free(queue);
gearman_log_error(server->gearman, "gearman_queue_libtokyocabinet_init",
"tcadboptimize");
return GEARMAN_QUEUE_ERROR;
}
}
gearman_server_set_queue_context(server, queue);
gearman_server_set_queue_add_fn(server, _libtokyocabinet_add);
gearman_server_set_queue_flush_fn(server, _libtokyocabinet_flush);
gearman_server_set_queue_done_fn(server, _libtokyocabinet_done);
gearman_server_set_queue_replay_fn(server, _libtokyocabinet_replay);
return GEARMAN_SUCCESS;
}
