int main(int argc, char* argv[]) { int f; struct bson_info* bson; int ret; fprintf_blue(stdout, "BSON Printer -- By: Wolfgang Richter " "<*****@*****.**>\n"); if (argc < 2) { fprintf_light_red(stderr, "Usage: %s <BSON file>\n", argv[0]); return EXIT_FAILURE; } fprintf_cyan(stdout, "Analyzing BSON File: %s\n", argv[1]); f = open(argv[1], O_RDONLY); if (f < 0) { fprintf_light_red(stderr, "Error opening BSON file.\n"); return EXIT_FAILURE; } bson = bson_init(); while ((ret = bson_readf(bson, f)) == 1) bson_print(stdout, bson); bson_cleanup(bson); check_syscall(close(f)); return EXIT_SUCCESS; }
void redis_disconnect_callback(const redisAsyncContext* c, int status) { struct nbd_handle* handle; if (c->data) { handle = (struct nbd_handle*) c->data; } else { fprintf_light_red(stderr, "FATAL: Handle not passed to disconnect " "callback.\n"); assert(c->data != NULL); return; } if (status != REDIS_OK) { if (c->err == REDIS_ERR_EOF) /* probably standard timeout, reconnect */ { fprintf_red(stderr, "Redis server disconnected us.\n"); if ((handle->redis_c = redisAsyncConnect(handle->redis_server, handle->redis_port)) != NULL) { fprintf_blue(stderr, "New Redis context, attaching to " "libevent.\n"); handle->redis_c->data = c->data; redisLibeventAttach(handle->redis_c, handle->eb); fprintf_blue(stderr, "Setting disconnect callback.\n"); if (redisAsyncSetDisconnectCallback(handle->redis_c, &redis_disconnect_callback) != REDIS_ERR) { assert(redisAsyncCommand(handle->redis_c, &redis_async_callback, NULL, "select %d", handle->redis_db) == REDIS_OK); fprintf_light_blue(stderr, "Successfully reconnected to " "the Redis server.\n"); } else { fprintf_light_red(stderr, "Error setting disconnect " "callback handler for Redis.\n"); } } else { fprintf_light_red(stderr, "Error trying to reconnect to " "Redis.\n"); } return; } fprintf_light_red(stderr, "FATAL ERROR DISCONNECTION FROM REDIS\n"); fprintf_light_blue(stderr, "Error: %s\n", c->errstr); assert(false); } }
int main(int argc, char* argv[]) { struct nbd_handle* handle; if (argc < 9) { fprintf_light_red(stderr, USAGE, argv[0]); exit(EXIT_FAILURE); } fprintf_blue(stdout, "nbd-queuer-test program by: Wolfgang Richter " "<*****@*****.**>\n"); handle = nbd_init_redis(argv[1], argv[2], atoi(argv[3]), atoi(argv[4]), atoll(argv[5]), argv[6], argv[7], (strncmp(argv[8], "y", 1) == 0) || (strncmp(argv[8], "Y", 1) == 0)); assert(handle != NULL); assert(handle->fd != 0); assert(strncmp(argv[1], handle->export_name, strlen(argv[1])) == 0); assert(handle->eb != NULL); assert(handle->conn != NULL); assert(handle->size >= 0); /* special case allow for example /dev/null to appear as a large file */ if (handle->size == 0) handle->size = 1024*1024*1024*1024LL; nbd_run_loop(handle); nbd_shutdown(handle); fprintf_green(stdout, "-- Shutting down --\n"); return EXIT_SUCCESS; }
int read_loop(int fd, struct kv_store* handle, struct bitarray* bits) { struct timeval start, end; uint8_t buf[QEMU_HEADER_SIZE]; int64_t total = 0, read_ret = 0; struct qemu_bdrv_write write; size_t len = QEMU_HEADER_SIZE; uint64_t counter = 0; write.data = (uint8_t*) malloc(4096); if (write.data == NULL) { fprintf_light_red(stderr, "Failed initial alloc for write.data.\n"); return EXIT_FAILURE; } while (1) { gettimeofday(&start, NULL); read_ret = read(fd, buf, QEMU_HEADER_SIZE); total = read_ret; while (read_ret > 0 && total < QEMU_HEADER_SIZE) { read_ret = read(fd, &buf[total], QEMU_HEADER_SIZE - total); total += read_ret; } /* check for EOF */ if (read_ret == 0) { fprintf_light_red(stderr, "Total read: %"PRId64".\n", total); fprintf_light_red(stderr, "Reading from stream failed, assuming " "teardown.\n"); return EXIT_SUCCESS; } if (read_ret < 0) { fprintf_light_red(stderr, "Unknown fatal error occurred, 0 bytes" "read from stream.\n"); return EXIT_FAILURE; } qemu_parse_header(buf, &write); len = write.header.nb_sectors * SECTOR_SIZE; write.data = (uint8_t*) realloc(write.data, len); if (write.data == NULL) { fprintf_light_red(stderr, "realloc() failed, assuming OOM.\n"); fprintf_light_red(stderr, "tried allocating: %d bytes\n", write.header.nb_sectors*SECTOR_SIZE); return EXIT_FAILURE; } read_ret = read(fd, (uint8_t*) write.data, write.header.nb_sectors*SECTOR_SIZE); total = read_ret; while (read_ret > 0 && total < write.header.nb_sectors*SECTOR_SIZE) { read_ret = read(fd, (uint8_t*) &write.data[total], write.header.nb_sectors*SECTOR_SIZE - total); total += read_ret; } if (read_ret <= 0) { fprintf_light_red(stderr, "Stream ended while reading sector " "data.\n"); return EXIT_FAILURE; } /* the mountain of things i still regret ! */ if (redis_async_write_enqueue(handle, bits, write.header.sector_num, write.data, len)) fprintf_light_red(stderr, "\tqueue would block: dropping write\n"); gettimeofday(&end, NULL); fprintf(stderr, "[%"PRIu64"]read_loop finished in %"PRIu64 " microseconds [%d bytes]\n", counter++, diff_time(start, end), write.header.nb_sectors*SECTOR_SIZE); } if (write.data) free(write.data); if (bits) bitarray_destroy(bits); return EXIT_SUCCESS; }
/* main thread of execution */ int main(int argc, char* args[]) { int fd; char* index, *db, *stream; FILE* indexf; struct bitarray* bits; fprintf_blue(stdout, "gammaray Async Queuer -- " "By: Wolfgang Richter " "<*****@*****.**>\n"); redis_print_version(); if (argc < 4) { fprintf_light_red(stderr, "Usage: %s <index file> <stream file>" " <redis db num>\n", args[0]); return EXIT_FAILURE; } index = args[1]; stream = args[2]; db = args[3]; /* ----------------- hiredis ----------------- */ struct kv_store* handle = redis_init(db, true); if (handle == NULL) { fprintf_light_red(stderr, "Failed getting Redis context " "(connection failure?).\n"); return EXIT_FAILURE; } fprintf_cyan(stdout, "Loading MD filter from: %s\n\n", index); indexf = fopen(index, "r"); if (indexf == NULL) { fprintf_light_red(stderr, "Error opening index file to get MD " "filter.\n"); return EXIT_FAILURE; } if (qemu_load_md_filter(indexf, &bits)) { fprintf_light_red(stderr, "Error getting MD filter from BSON file.\n"); bits = bitarray_init(5242880); bitarray_set_all(bits); } if (bits == NULL) { fprintf_light_red(stderr, "Bitarray is NULL!\n"); return EXIT_FAILURE; } fclose(indexf); fprintf_cyan(stdout, "Attaching to stream: %s\n\n", stream); on_exit((void (*) (int, void *)) redis_shutdown, handle); if (strcmp(stream, "-") != 0) { fd = open(stream, O_RDONLY); } else { fd = STDIN_FILENO; } if (fd == -1) { fprintf_light_red(stderr, "Error opening stream file. " "Does it exist?\n"); return EXIT_FAILURE; } read_loop(fd, handle, bits); close(fd); return EXIT_SUCCESS; }