static int memcachefs_mknod(const char *path, mode_t mode, dev_t rdev) { int ret; handle_t *handle; char *key; size_t keylen; if(opt.verbose){ fprintf(stderr, "%s(\"%s\", 0%o)\n", __func__, path, mode); } if(!S_ISREG(mode)){ return -ENOSYS; } handle = handle_get(pool); if(!handle){ return -EMFILE; } key = (char *)path + 1; keylen = strlen(key); ret = mc_set(handle->mc, key, keylen, "", 0, 0, 0); handle_release(pool, handle->index); if(ret){ return -EIO; } return 0; }
static int memcachefs_truncate(const char* path, off_t length) { int ret; handle_t *handle; char *key; size_t keylen; if(opt.verbose){ fprintf(stderr, "%s(\"%s\", %lld)\n", __func__, path, length); } if(length != 0){ return -ENOSYS; } handle = handle_get(pool); if(!handle){ return -EMFILE; } key = (char *)path + 1; keylen = strlen(key); ret = mc_set(handle->mc, key, keylen, "", 0, 0, 0); handle_release(pool, handle->index); if(ret){ return -EIO; } return 0; }
int main ( int argc, char *argv[] ) { struct memcache *mc= mc_new(); uint32_t value; char key[100]; FILE *fp=fopen("a.txt","r"); mc_server_add4(mc, "localhost:11211"); while(feof(fp )){ fscanf(fp, "%s %d", key, &value ); DEBUG_LOG("%s",key); mc_set(mc,key, strlen(key), &value , sizeof(value) ,0,0 ); } return 0; } /* ---------- end of function main ---------- */
/* updates file attributes */ int update_attrs(char *key, int attr) { char buf[1024]; handle_t *handle = handle_get(pool); snprintf(buf, sizeof buf, "%d", attr); int ret = mc_set( handle->mc, get_attrkey(key), strlen(get_attrkey(key)), buf, strlen(buf), 0, 0 ); handle_release(pool, handle->index); return ret; }
static int memcachefs_mkdir(const char *path, mode_t mode) { /* if(opt.verbose){ fprintf(stderr, "%s(\"%s\", 0%o)\n", __func__, path, mode); } return -ENOSYS; */ // res = mkdir(strcat("../", path), mode); int ret; handle_t *handle; char *key; size_t keylen; char dir_path[PATH_MAX]; // gets handler of connections memcache handle = handle_get(pool); if(!handle){ return -EMFILE; } // gets key key = (char *)path + 1; // gets key size keylen = strlen(key); // write new empty directory ret = mc_set(handle->mc, key, keylen, "", 0, 0, 0); // write attrs of a file update_attrs(key, S_IFDIR); // I dont know yet what is this handle_release(pool, handle->index); // copies path of directory // strncpy(dir_path, path, PATH_MAX); // dirname(dir_path); if (ret == -1) return -errno; return 0; }
static int memcachefs_rename(const char *from, const char *to) { int ret; handle_t *handle; char *key; size_t keylen; void *val; size_t vallen; if(opt.verbose){ fprintf(stderr, "%s(%s -> %s)\n", __func__, from, to); } handle = handle_get(pool); key = (char *)from + 1; keylen = strlen(key); val = (char*)mc_aget2(handle->mc, key, keylen, &vallen); if(!val){ handle_release(pool, handle->index); return -ENOENT; } key = (char *)to + 1; keylen = strlen(key); ret = mc_set(handle->mc, key, keylen, val, vallen, 0, 0); if(ret){ handle_release(pool, handle->index); return -EIO; } key = (char *)from + 1; keylen = strlen(key); ret = mc_delete(handle->mc, key, keylen, 0); if(ret){ handle_release(pool, handle->index); return -EIO; } free(val); return 0; }
int main(int argc, char *argv[]) { struct memcache *mc = NULL; int i, ret; u_int32_t hash_pre, hash_post; void *v; mc = mc_new(); if (mc == NULL) err(EX_OSERR, "Unable to allocate a new memcache object"); mc_server_add4(mc, "localhost:11211"); warnx("mc_add"); mc_err_filter_del(MCM_ERR_LVL_INFO); mc_err_filter_del(MCM_ERR_LVL_NOTICE); ret = mc_add(mc, key, strlen(key), val, strlen(val), 0, 0); printf("add %d\n", ret); ret = mc_set(mc, key, strlen(key), val, strlen(val), 0, 0); hash_pre = mc_hash_key(val, strlen(val)); printf("set %d\n", ret); for (i = 0; i < 10000; i++) { v = mc_aget(mc, key, strlen(key)); if (v != NULL) { hash_post = mc_hash_key(v, strlen(v)); if (hash_post != hash_pre) { printf("Hash pre (%u) != post (%u)\n", hash_pre, hash_post); } free(v); } else { printf("Return value null on iteration %d\n", i); } } mc_free(mc); return EX_OK; }
static int memcachefs_fsync(const char *path, int i, struct fuse_file_info *fi) { int ret; handle_t *handle; char *key; size_t keylen; if(opt.verbose){ fprintf(stderr, "%s(\"%s\", %d)\n", __func__, path, i); } handle = pool->handles[fi->fh]; key = (char *)path + 1; keylen = strlen(key); ret = mc_set(handle->mc, key, keylen, handle->buf, handle->buf_len , 0, 0); if(ret){ return -EIO; } return 0; }
int main(int argc, char *argv[]) { struct memcache *mc = NULL; u_int32_t num_tests = 0, valsize = 0; u_int32_t i; struct timeval t1, t2; const char *key; char *tests = NULL; char *val; u_int32_t keylen; double addtime, deltime; const char fmt[] = "%s\t%f\t%f\t%f\n"; struct memcache_req *req; struct memcache_res *res; if (argc > 1) num_tests = strtol(argv[1], NULL, 10); if (num_tests == 0) num_tests = 10; if (argc > 2) valsize = strtol(argv[2], NULL, 10); if (argc > 3) tests = strdup(argv[3]); if (tests == NULL) tests = strdup("adgs"); if (valsize == 0) valsize = 50; val = (char *)malloc(valsize + 1); memset(val, 69, valsize); val[valsize] = '\0'; /* XXX I should add a min/max time value for each request */ printf("Value size:\t%d\n", valsize); printf("Num tests:\t%d\n", num_tests); printf("Test\tOps per second\tTotal Time\tTime per Request\n"); key = "bench_key"; keylen = strlen(key); mc = mc_new(); if (mc == NULL) err(EX_OSERR, "Unable to allocate a new memcache object"); mc_err_filter_del(MCM_ERR_LVL_INFO); mc_err_filter_del(MCM_ERR_LVL_NOTICE); mc_server_add4(mc, "localhost:11211"); /* Establish a connection */ mc_set(mc, key, keylen, val, valsize, 0, 0); /* BEGIN set test, if specified */ if (strchr(tests, (int)'s') != NULL) { if (gettimeofday(&t1, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); for (i = 0; i < num_tests; i++) { mc_set(mc, key, keylen, val, valsize, 0, 0); } if (gettimeofday(&t2, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); /* END set test */ printf(fmt, "set", num_tests / tt(&t1, &t2), tt(&t1, &t2), tt(&t1, &t2) / num_tests); } if (strchr(tests, (int)'g') != NULL) { /* BEGIN get request */ req = mc_req_new(); res = mc_req_add(req, key, keylen); res->size = valsize; res->val = malloc(res->size); mc_res_free_on_delete(res, 1); if (gettimeofday(&t1, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); for (i = 0; i < num_tests; i++) { mc_get(mc, req); } if (gettimeofday(&t2, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); mc_req_free(req); /* END get test */ printf(fmt, "get", num_tests / tt(&t1, &t2), tt(&t1, &t2), tt(&t1, &t2) / num_tests); } if (strchr(tests, 'a') != NULL || strchr(tests, 'd') != NULL) { /* Run the add/delete test */ mc_delete(mc, key, keylen, 0); addtime = deltime = 0.0; for (i = 0; i < num_tests; i++) { /* BEGIN add test */ if (strchr(tests, 'a') != NULL) { if (gettimeofday(&t1, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); mc_add(mc, key, keylen, val, valsize, 0, 0); if (gettimeofday(&t2, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); addtime += tt(&t1, &t2); /* END add test */ } /* BEGIN delete test */ if (strchr(tests, 'd') != NULL) { if (gettimeofday(&t1, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); mc_delete(mc, key, keylen, 0); if (gettimeofday(&t2, NULL) != 0) err(EX_OSERR, "gettimeofday(2)"); deltime += tt(&t1, &t2); /* END delete test */ } } if (strchr(tests, 'a') != NULL) printf(fmt, "add", num_tests / addtime, addtime, addtime / num_tests); if (strchr(tests, 'd') != NULL) printf(fmt, "delete", num_tests / deltime, deltime, deltime / num_tests); } free(tests); free(val); mc_free(mc); return EX_OK; }
int cw_db_get(const char *family, const char *keys, char *value, int valuelen) { char *sql; char *zErr = 0; int res = 0; struct cw_db_data result; sqlite3 *db; int retry=0; if (!family || cw_strlen_zero(family)) { family = "_undef_"; } #ifdef HAVE_MEMCACHE int fullkeylen; char fullkey[256] = ""; fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys); if ( memcached_data.active ) { if ( memcached_data.has_error ) database_cache_retry_connect(); //cw_log(LOG_ERROR,"MEMCACHE GET Family %s : %s \n", family, keys); memset(value,0,valuelen); struct memcache_req *mreq; struct memcache_res *mres; mreq = mc_req_new(); mres = mc_req_add(mreq, fullkey, fullkeylen); mc_res_free_on_delete(mres, 0); mres->size = valuelen; mres->val = value; mc_get(memcached_data.mc, mreq); if ( mres->bytes ) { // FOUND //cw_log(LOG_WARNING,"MEMCACHE GET FOUND for %s: (%d) %s\n", fullkey, mres->size,(char *) mres->val); //value = mres->val; mc_req_free(mreq); return 0; } mc_req_free(mreq); } #endif sanity_check(); if (!(db = sqlite_open_db(globals.dbfile))) { return -1; } result.data = value; result.datalen = valuelen; result.rownum = 0; retry_1: if ((sql = sqlite3_mprintf("select value from %q where family='%q' and keys='%q'", globals.tablename, family, keys))) { cw_log(LOG_DEBUG, "SQL [%s]\n", sql); res = sqlite3_exec(db, sql, get_callback, &result, &zErr ); if (zErr) { if (retry >= SQL_MAX_RETRIES) { cw_log(LOG_ERROR, "SQL ERR Query: [%s] Error: [%s] Retries: %d Max: %d\n", sql, zErr, retry, SQL_MAX_RETRIES); sqlite3_free(zErr); } else { cw_log(LOG_DEBUG, "SQL ERR Query: %s Error: [%s] Retries %d\n", sql, zErr, ++retry); sqlite3_free(zErr); usleep(SQL_RETRY_USEC); goto retry_1; } res = -1; } else { if (result.rownum) res = 0; else res = -1; } } else { cw_log(LOG_ERROR, "Memory Error!\n"); res = -1; /* Return an error */ } if (sql) { sqlite3_free(sql); sql = NULL; } sqlite3_close(db); #if defined(HAVE_MEMCACHE) // We got a value out of the cache. // Store it back to the cache to improve performance. if ( !res && memcached_data.active ) { if ( memcached_data.has_error ) database_cache_retry_connect(); //cw_log(LOG_ERROR,"DB GET STANDARD RETURNING AND CACHING %s\n", value); mc_set(memcached_data.mc, fullkey, fullkeylen, value, (size_t)MCM_CSTRLEN(value), db_cache_lifetime, 0); } #endif return res; }
int cw_db_put(const char *family, const char *keys, char *value) { char *sql = NULL; char *zErr = 0; int res = 0; sqlite3 *db; int retry=0; if (!family || cw_strlen_zero(family)) { family = "_undef_"; } if ( !(sql = sqlite3_mprintf("insert into %q values('%q','%q','%q')", globals.tablename, family, keys, value)) ) { cw_log(LOG_ERROR, "Memory Error!\n"); res = -1; /* Return an error */ } cw_db_del(family, keys); #ifdef HAVE_MEMCACHE if ( memcached_data.active ) { if ( memcached_data.has_error ) database_cache_retry_connect(); //cw_log(LOG_ERROR,"MEMCACHE PUT Family %s : %s => %s (%d) \n", family, keys, value, strlen(value) ); int fullkeylen; char fullkey[256] = ""; fullkeylen = snprintf(fullkey, sizeof(fullkey), "/%s/%s", family, keys); mc_delete( memcached_data.mc, fullkey, fullkeylen, 0); if ( mc_set(memcached_data.mc, fullkey, fullkeylen, value, (size_t) strlen(value) , db_cache_lifetime, 0) == 0) { // ADD THE SQL TO THE QUEUE TO BE EXECUTED ASYNCRONOUSLY if ( !database_sql_queue(sql) ) { sqlite3_free(sql); return 0; } } else { //DIDN'T WORK // So store as we did before... } } #endif sanity_check(); if (!(db = sqlite_open_db(globals.dbfile))) { return -1; } retry_0: if ( sql ) { cw_log(LOG_DEBUG, "SQL [%s]\n", sql); res = sqlite3_exec(db, sql, NULL, NULL, &zErr ); if (zErr) { if (retry >= SQL_MAX_RETRIES) { cw_log(LOG_ERROR, "SQL ERR Query: [%s] Error: [%s] Retries: %d Max: %d\n", sql, zErr, retry, SQL_MAX_RETRIES); sqlite3_free(zErr); } else { cw_log(LOG_DEBUG, "SQL ERR Query: %s Error: [%s] Retries %d\n", sql, zErr, ++retry); sqlite3_free(zErr); usleep(SQL_RETRY_USEC); goto retry_0; } res = -1; } else { res = 0; } } if (sql) { sqlite3_free(sql); sql = NULL; } sqlite3_close(db); return res; }