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;
}
