static double get_balance(const char *billaccount, switch_channel_t *channel)
{
REDIS redis;
char *rediskey;
char *str;
double val;
int result;
double balance = 0.0;
if (redis_factory(&redis) != SWITCH_STATUS_SUCCESS) {
return SWITCH_STATUS_FALSE;
}
rediskey = switch_mprintf("rn_%s", billaccount);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Looking up redis key %s\n", rediskey);
result = credis_get(redis, rediskey, &str);
if (result != 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "ERR: Could not get redis value on key %s (got result %d) - returning positive value for now (FIXME)\n", rediskey, result);
balance = 1.0;
} else {
val = atof(str);
balance = val/1000000;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Key %s returned %s converted to %e / %f \n", rediskey, str, val, balance);
}
switch_safe_free(rediskey);
credis_close(redis);
return balance;
}
static void redis_drv_get(redis_drv_t *redis_drv, Reader *const reader)
{
int rc;
char *val;
REDIS redis = redis_drv->redis;
const uint64_t *keysize = NULL;
const char *key = NULL;
if(read_binary(reader, &key, &keysize)){
rc = credis_get(redis, key, &val);
if(rc > -1){
ErlDrvTermData spec[] = {
ERL_DRV_BINARY,
(ErlDrvTermData) val,
strlen(val),
0
};
driver_output_term(redis_drv->port, spec, sizeof(spec) / sizeof(spec[0]));
} else{
return_error(redis_drv, REDIS_DRV_NIL);
}
} else{
return_error(redis_drv, REDIS_DRV_ERROR);
}
}
Datum
pr_get(PG_FUNCTION_ARGS) {
text * key_arg = PG_GETARG_TEXT_P(0);
char * key = NULL;
char * value = NULL;
text * ret_val = NULL;
int ret = 0;
if (!pgredis || !pgredis->redis_server) {
elog(ERROR, "Redis instance missing, unable to get");
PG_RETURN_NULL();
}
if (!key_arg)
PG_RETURN_NULL();
key = DatumGetCString(DirectFunctionCall1(textout, PointerGetDatum(key_arg)));
if (!key || strlen(key) == 0)
PG_RETURN_NULL();
ret = credis_get(pgredis->redis_server, key, &value);
if (ret == CREDIS_OK) {
ret_val = (text *)palloc(strlen(value) + VARHDRSZ);
SET_VARSIZE(ret_val, strlen(value) + VARHDRSZ);
memcpy(VARDATA(ret_val), value, strlen(value));
PG_RETURN_TEXT_P(ret_val);
}
PG_RETURN_NULL();
}
int ZRedis::app_sleep()
{
char *val = NULL;
credis_get(m_pRedis, "SLEEP", &val);
if(val != NULL)
return atoi(val);
else
return 0;
}
int ZRedis::app_run()
{
char *val = NULL;
credis_get(m_pRedis, "RUN", &val);
if(val != NULL)
return atoi(val);
else
return 0;
}
int ZRedis::app_displaybig()
{
char *val = NULL;
int i = 0;
credis_get(m_pRedis, "DISPLAYBIG", &val);
if(val != NULL)
i = atoi(val);
return i;
}
//return value: -1: failed
int ZRedis::app_get(const char *key, PLAT_UINT8* outbuf)
{
char *val = NULL;
int ret = -1;
ret = credis_get(m_pRedis,key,&val);
if(val != NULL)
{
strcpy(m_charBuf,val);
db2app(m_charBuf,outbuf);
}
return ret;
}
//-----------------------------------------------------------------------------
int CRedisClient::get(const std::string key, std::string& value)
{
int ret;
char* val;
if (mRedisCon) {
ret = credis_get( mRedisCon, key.c_str(), &val );
if (ret == 0) {
value = val;
return 1; // succes
}
}
return 0; // failure
}
/**
* TODO - parameter polymorphism:
* when message is a list, first item is the key
* when message is a string then message is the key
*/
const string* db_get(closure* c, db* self, const fexp* message)
{
object* reply = (object*)fexp_nil;
string* key = (string*)send(message, s_fexp_join, self->delimiter);
char* keyc = (char*)send(key, s_string_tochar);
char* val;
int rc = credis_get(self->handle, keyc, &val);
wprintl(L"GET /db/get/%S -> %d %s\n", key->buffer, rc, val);
if (rc == -1) { // key does not exist
reply = (object*)fexp_nil;
} else if (rc != 0 || val == NULL) { // error
reply = send(VillageBus, s_villagebus_error, L"get failed %s", keyc);
} else { // success
reply = send(String, s_string_fromchar, val, strlen(val));
}
free(keyc);
return (string*)reply;
}
int main(int argc, char **argv) {
REDIS redis;
REDIS_INFO info;
char *val, **valv;
const char *keyv[] = {"kalle", "adam", "unknown", "bertil", "none"};
int rc, keyc=5, i;
redis = credis_connect(NULL, 0, 10000);
if (redis == NULL) {
printf("Error connecting to Redis server. Please start server to run tests.\n");
exit(1);
}
printf("\n\n************* misc info ************************************ \n");
rc = credis_info(redis, &info);
printf("info returned %d\n", rc);
printf("> redis_version: %s\n", info.redis_version);
printf("> arch_bits: %d\n", info.arch_bits);
printf("> multiplexing_api: %s\n", info.multiplexing_api);
printf("> process_id: %ld\n", info.process_id);
printf("> uptime_in_seconds: %ld\n", info.uptime_in_seconds);
printf("> uptime_in_days: %ld\n", info.uptime_in_days);
printf("> connected_clients: %d\n", info.connected_clients);
printf("> connected_slaves: %d\n", info.connected_slaves);
printf("> blocked_clients: %d\n", info.blocked_clients);
printf("> used_memory: %zu\n", (size_t)info.used_memory);
printf("> used_memory_human: %s\n", info.used_memory_human);
printf("> changes_since_last_save: %lld\n", info.changes_since_last_save);
printf("> bgsave_in_progress: %d\n", info.bgsave_in_progress);
printf("> last_save_time: %ld\n", info.last_save_time);
printf("> bgrewriteaof_in_progress: %d\n", info.bgrewriteaof_in_progress);
printf("> total_connections_received: %lld\n", info.total_connections_received);
printf("> total_commands_processed: %lld\n", info.total_commands_processed);
printf("> expired_keys: %lld\n", info.expired_keys);
printf("> hash_max_zipmap_entries: %zu\n", (size_t)info.hash_max_zipmap_entries);
printf("> hash_max_zipmap_value: %zu\n", (size_t)info.hash_max_zipmap_value);
printf("> pubsub_channels: %ld\n", info.pubsub_channels);
printf("> pubsub_patterns: %u\n", info.pubsub_patterns);
printf("> vm_enabled: %d\n", info.vm_enabled);
printf("> role: %d\n", info.role);
printf("\n\n************* get/set ************************************ \n");
rc = credis_set(redis, "kalle", "kula");
printf("set kalle=kula returned: %d\n", rc);
rc = credis_get(redis, "kalle", &val);
printf("get kalle returned: %s\n", val);
rc = credis_type(redis, "someunknownkey");
printf("get type unknown key returned: %d\n", rc);
rc = credis_type(redis, "kalle");
printf("get type known key returned: %d\n", rc);
rc = credis_getset(redis, "kalle", "buhu", &val);
printf("get set kalle=buhu returned: %s\n", val);
rc = credis_get(redis, "kalle", &val);
printf("get kalle returned: %s\n", val);
rc = credis_del(redis, "kalle");
printf("del kalle returned: %d\n", rc);
rc = credis_get(redis, "kalle", &val);
printf("get kalle returned: %s\n", val);
rc = credis_set(redis, "adam", "aaa");
rc = credis_set(redis, "bertil", "bbbbbbb");
rc = credis_set(redis, "caesar", "cccc");
rc = credis_get(redis, "adam", &val);
printf("get adam returned: %s\n", val);
rc = credis_get(redis, "bertil", &val);
printf("get bertil returned: %s\n", val);
rc = credis_get(redis, "caesar", &val);
printf("get caesar returned: %s\n", val);
rc = credis_mget(redis, keyc, keyv, &valv);
printf("mget returned: %d\n", rc);
for (i = 0; i < rc; i++)
printf(" % 2d: %s\n", i, valv[i]);
credis_close(redis);
return 0;
}
