dbgp_control_info_t *retrieve_control_info(struct transit * transit)
{
redisContext *c;
redisReply* reply;
dbgp_control_info_t *control_info;
/* Input sanity checks */
assert(transit != NULL && transit->val != NULL);
/**
* @note: (rajas) I am using this as a hook to attch to the bgpd
* process for debugging
*/
//sleep(50);
/* First retrieve the lookup key */
assert(transit->length == sizeof(dbgp_lookup_key_t));
/* Get D-BGP control info from lookup service */
c = connect_to_redis();
reply = redisCommand(c, "GET %"PRIu32"", *(dbgp_lookup_key_t *)transit->val);
if(reply->type == REDIS_REPLY_ERROR) {
zlog_err("%s:, failed to retrieve D-BGP control info. Key=%"PRIu32"",
__func__, *(dbgp_lookup_key_t *)transit->val);
assert(0);
}
control_info = unpack_redis_reply(reply->str, reply->len);
free(reply);
free(c);
return(control_info);
}
int RetrieveWiserCosts(int as1, int as2)
{
redisContext *c;
redisReply* reply;
char* command = malloc(100);
sprintf(command,"GET %i-%i", as1, as2 );
/* Get D-BGP control info from lookup service */
c = connect_to_redis();
reply = redisCommand(c, command);
if(reply->type == REDIS_REPLY_ERROR) {
zlog_err("dbgp_lookup::RetreiveWiserCosts: failed to get wiser costs for key %i-%i", as1, as2);
assert(0);
}
if(reply->type == REDIS_REPLY_NIL) {
zlog_debug("dbgp_lookup::RetreiveWiserCosts: Key (%i-%i) did not exist for retrieving", as1, as2);
return -1;
}
if(reply->type != REDIS_REPLY_INTEGER){
zlog_debug("dbgp_lookup::RetrieveWiserCosts: Key(%i-%i) exist and got back STRING cost %s", as1, as2, reply->str);
return strtol(reply->str, NULL, 0);
}
int return_val = reply->integer;
zlog_debug("dbgp_lookup::RetrieveWiserCosts: Key(%i-%i) exist and got back cost %i", as1, as2, return_val);
free(reply);
free(c);
return return_val;
}
int main(int argc, char **argv){
printf("starting ...\n");
load_confs(NULL);
connect_to_redis();
//syslog(LOG_NOTICE, "Starting URLDUMP2 v%s . PID : %d", APP_VERSION, getpid());
//connect_cache();
capture_traffic();
return 0;
}
dbgp_result_status_t set_control_info(struct transit *transit,
dbgp_control_info_t *control_info)
{
uint32_t *key = NULL;
redisContext *c;
redisReply* reply;
char packed_val[control_info->integrated_advertisement_size];
/* Input sanity checks */
assert(transit != NULL && transit->val != NULL && control_info != NULL);
/** @note: (rajas) I am using this as a hook to attch to the bgpd
* process for debugging */
//sleep(50);
/* Get a number that will serve as the new lookup key */
if (g_rand_init == 0) {
/** @bug: rajas - sleep to guarantee two instances
* of Quagga started by MiniNExT don't use same seed
*/
sleep(2);
srand(mix(clock(), time(NULL), pthread_self()));
g_rand_init = 1;
}
key = (dbgp_lookup_key_t *)malloc(sizeof(dbgp_lookup_key_t));
do {
*key = rand();
} while (*key == DBGP_LOOKUP_SVC_PATH);
assert(pack_dbgp_control_info(control_info, packed_val) == DBGP_SUCCESS);
/* Store control info in lookup service */
c = connect_to_redis();
reply = redisCommand(c, "SET %"PRIu32" %s", *key, packed_val);
if (reply->type == REDIS_REPLY_ERROR) {
zlog_err("%s: failed to store control info. Key=%"PRIu32", control info=%s",
__func__, *key, packed_val);
assert(0);
}
/* Add key to advertisement */
transit->length = sizeof(dbgp_lookup_key_t);
transit->val = (u_char *)key;
free(reply);
free(c);
return(DBGP_SUCCESS);
}
void test_redis_set() {
char cmd[200];
int64_t index=0;
redisReply* reply;
int n=1;
redisContext* rc=NULL;
while (1) {
for (int i=0;i<n;i++) {
if (NULL==rc) {
rc=connect_to_redis();
}
sprintf(cmd,"set yjb_%lld %s",index++,"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
reply=(redisReply* )redisCommand(rc,cmd);
mutex_.lock();
all_count+=1;
mutex_.unlock();
if (NULL==reply) {
printf("%s","redis_client set fail, network error");
if (rc) {
redisFree(rc);
}
mutex_.lock();
fail_count+=1;
mutex_.unlock();
continue;
}
//printf("type=%d, str=%s\n", reply->type, reply->str);
if( !(reply->type == REDIS_REPLY_STATUS && strcasecmp(reply->str,"OK")==0)) {
printf("%s","redis_client set fail");
freeReplyObject(reply);
mutex_.lock();
fail_count+=1;
mutex_.unlock();
continue;
}
mutex_.lock();
suc_count+=1;
mutex_.unlock();
freeReplyObject(reply);
}
usleep(500);//500us
}
}
int main(int argc, char * argv[])
{
opts_dump_t opts = {{DEFAULT_HOST, DEFAULT_PORT, NULL, DEFAULT_DBNUM}, DEFAULT_KEYS_FILTER};
parse_argv_for_dump(argc, argv, &opts);
redisContext * conn = connect_to_redis(&(opts.base));
redisReply * keys_rply, * dump_rply;
char * cmd = (char*) malloc(CMD_SIZE);
int unsigned i;
char * dump_str;
long long ttl;
sprintf(cmd, "KEYS %s", opts.keys_filter);
keys_rply = process_redis_command(conn, cmd);
for (i = 0; i < keys_rply->elements; ++i) {
sprintf(cmd, "PTTL %s", keys_rply->element[i]->str);
dump_rply = process_redis_command(conn, cmd);
ttl = dump_rply->integer;
if (ttl < 0) ttl = 0;
freeReplyObject(dump_rply);
sprintf(cmd, "DUMP %s", keys_rply->element[i]->str);
dump_rply = process_redis_command(conn, cmd);
dump_str = (char*) malloc(dump_rply->len * 2 + 1);
bin2hex(dump_rply->str, dump_rply->len, dump_str);
freeReplyObject(dump_rply);
printf("%s %lld %s\n", keys_rply->element[i]->str, ttl, dump_str);
free(dump_str);
}
freeReplyObject(keys_rply);
redisFree(conn);
return EXIT_SUCCESS;
}
void IncrementWiserCosts(int as1, int as2, int increment_by){
redisContext *c;
redisReply* reply;
char* key = malloc(100);
char* increment_by_str = malloc(100);
char* command = malloc(100);
// zero out so that strings is guranteed to be null terminated
memset(key, 0, 100);
memset(increment_by_str, 0, 100);
memset(command, 0, 100);
sprintf(key, "%i-%i", as1, as2);
sprintf(increment_by_str, "%i", increment_by);
sprintf(command, "INCRBY %s %s", key, increment_by_str);
zlog_debug("dbgp_lookup::IncrementWiserCosts: Command sent to Redis: %s", command);
c = connect_to_redis();
/* reply = redisCommand(c, "INCRBY %s %s", *key, *increment_by_str); */
reply = redisCommand(c, command);
if (reply->type == REDIS_REPLY_ERROR) {
zlog_err("dbgp_lookup::IncrementWiserCosts: failed to increment wiser costs for key %s", key);
assert(0);
}
// free dynamically allocated memory.
free(reply);
free(c);
free(command);
free(increment_by_str);
free(key);
}
int main(int argc, char * argv[])
{
opts_restore_t opts = {{DEFAULT_HOST, DEFAULT_PORT, NULL, DEFAULT_DBNUM}, STRATEGY_NONE};
parse_argv_for_restore(argc, argv, &opts);
redisContext * conn = connect_to_redis(&(opts.base));
redisReply * rply;
int unsigned i = 0, j = 0;
char * key = (char*) malloc(KEY_SIZE + 1);
char * dump_str = (char* ) malloc(BUFF_SIZE + 1);
char * dump_bin = (char* ) malloc(BUFF_SIZE + 1);
char * ttl = (char*) malloc(KEY_SIZE + 1);
const char * rstr_argv[4] = {"RESTORE", key, ttl, dump_bin};
size_t rstr_argvlen[4] = {7, 0, 0, 0};
char * cmd = (char*) malloc(CMD_SIZE + 1);
short int key_exists = 0;
FILE * fin = fdopen(0, "r");
if (fin == NULL) {
fprintf(stderr, "error: %s", strerror(errno));
return EXIT_FAILURE;
}
if (opts.strategy == STRATEGY_FLUSH) {
rply = process_redis_command(conn, "FLUSHDB");
freeReplyObject(rply);
};
while (!feof(fin)) {
++i;
j = fscanf(fin, "%s %s %s", key, ttl, dump_str);
if (j != 3) {
if (j != EOF) {
fprintf(stderr, "#%d error: %s\n", i, strerror(errno));
}
continue;
}
if (opts.strategy == STRATEGY_IGNORE) {
sprintf(cmd, "EXISTS %s", key);
rply = process_redis_command(conn, cmd);
key_exists = rply->integer;
freeReplyObject(rply);
if (key_exists) continue;
}
if (opts.strategy == STRATEGY_REPLACE) {
sprintf(cmd, "DEL %s", key);
rply = process_redis_command(conn, cmd);
freeReplyObject(rply);
}
hex2bin(dump_str, dump_bin);
rstr_argvlen[1] = strlen(key);
rstr_argvlen[2] = strlen(ttl);
rstr_argvlen[3] = strlen(dump_str) / 2;
rply = redisCommandArgv(conn, 4, rstr_argv, rstr_argvlen);
if (rply == NULL) {
fprintf(stderr, "#%d connection error: %s\n", i, conn->errstr);
exit(EXIT_FAILURE);
}
if (rply->type == REDIS_REPLY_ERROR) {
fprintf(stderr, "#%d Redis error: %s\n", i, rply->str);
}
freeReplyObject(rply);
}
redisFree(conn);
return EXIT_SUCCESS;
}
