dt_writer_t* dt_writer_create(const char *file_path, const char *version) { struct fstrm_file_options *fopt = NULL; struct fstrm_writer_options *wopt = NULL; dt_writer_t *writer = NULL; fstrm_res res; writer = calloc(1, sizeof(dt_writer_t)); if (writer == NULL) { goto fail; } // Set "version". if (version != NULL) { writer->len_version = strlen(version); writer->version = strdup(version); if (!writer->version) { goto fail; } } // Open writer. fopt = fstrm_file_options_init(); fstrm_file_options_set_file_path(fopt, file_path); wopt = fstrm_writer_options_init(); fstrm_writer_options_add_content_type(wopt, (const uint8_t *) DNSTAP_CONTENT_TYPE, strlen(DNSTAP_CONTENT_TYPE)); writer->fw = fstrm_file_writer_init(fopt, wopt); fstrm_file_options_destroy(&fopt); fstrm_writer_options_destroy(&wopt); if (writer->fw == NULL) { goto fail; } res = fstrm_writer_open(writer->fw); if (res != fstrm_res_success) { goto fail; } return writer; fail: dt_writer_free(writer); return NULL; }
int main(int argc, char **argv) { const char *input_fname = NULL; const char *output_fname = NULL; fstrm_res res = fstrm_res_failure; struct fstrm_file_options *fopt = NULL; struct fstrm_writer_options *wopt = NULL; struct fstrm_reader *r = NULL; struct fstrm_writer *w = NULL; int rv = EXIT_FAILURE; /* Args. */ if (argc != 2 && argc != 3) { fprintf(stderr, "Usage: %s <INPUT FILE> [<OUTPUT FILE>]\n", argv[0]); fprintf(stderr, "Dumps a Frame Streams formatted input file.\n\n"); return EXIT_FAILURE; } input_fname = argv[1]; if (argc == 3) output_fname = argv[2]; /* Line buffering. */ setvbuf(stdout, NULL, _IOLBF, 0); setvbuf(stderr, NULL, _IOLBF, 0); /* Setup file reader options. */ fopt = fstrm_file_options_init(); fstrm_file_options_set_file_path(fopt, input_fname); /* Initialize file reader. */ r = fstrm_file_reader_init(fopt, NULL); if (r == NULL) { fputs("Error: fstrm_file_reader_init() failed.\n", stderr); goto out; } res = fstrm_reader_open(r); if (res != fstrm_res_success) { fputs("Error: fstrm_reader_open() failed.\n", stderr); goto out; } if (output_fname != NULL) { /* Setup file writer options. */ fstrm_file_options_set_file_path(fopt, output_fname); /* Setup writer options. */ wopt = fstrm_writer_options_init(); /* Copy "content type" from the reader's START frame. */ res = process_start_frame(r, wopt); if (res != fstrm_res_success) { fputs("Error: process_start_frame() failed.\n", stderr); goto out; } /* Initialize file writer. */ w = fstrm_file_writer_init(fopt, wopt); if (w == NULL) { fputs("Error: fstrm_file_writer_init() failed.\n", stderr); goto out; } res = fstrm_writer_open(w); if (res != fstrm_res_success) { fstrm_writer_destroy(&w); fputs("Error: fstrm_writer_open() failed.\n", stderr); goto out; } } else { /* Process the START frame. */ res = process_start_frame(r, NULL); if (res != fstrm_res_success) { fprintf(stderr, "Error: process_start_frame() failed.\n"); goto out; } } /* Loop over data frames. */ for (;;) { const uint8_t *data; size_t len_data; res = fstrm_reader_read(r, &data, &len_data); if (res == fstrm_res_success) { /* Got a data frame. */ res = print_data_frame(data, len_data); if (res != fstrm_res_success) { fprintf(stderr, "Error: print_data_frame() failed.\n"); goto out; } if (w != NULL) { /* Write the data frame. */ res = fstrm_writer_write(w, data, len_data); if (res != fstrm_res_success) { fprintf(stderr, "Error: write_data_frame() failed.\n"); goto out; } } } else if (res == fstrm_res_stop) { /* Normal end of data stream. */ res = print_stop_frame(r); if (res != fstrm_res_success) { fprintf(stderr, "Error: unable to read STOP frame.\n"); goto out; } rv = EXIT_SUCCESS; break; } else { /* Abnormal end. */ fprintf(stderr, "Error: fstrm_reader_read() failed.\n"); goto out; } } out: /* Cleanup options. */ fstrm_file_options_destroy(&fopt); fstrm_writer_options_destroy(&wopt); /* Cleanup reader. */ fstrm_reader_destroy(&r); /* Cleanup writer. */ if (w != NULL) { res = fstrm_writer_close(w); if (res != fstrm_res_success) { fprintf(stderr, "Error: fstrm_writer_close() failed.\n"); rv = EXIT_FAILURE; } fstrm_writer_destroy(&w); } return rv; }
int main(int argc, char **argv) { struct timespec ts_a, ts_b; double elapsed; char *file_path; char *queue_model_str; unsigned num_messages; unsigned num_threads; fstrm_iothr_queue_model queue_model; if (argc != 5) { fprintf(stderr, "Usage: %s <FILE> <QUEUE MODEL> <NUM THREADS> <NUM MESSAGES>\n", argv[0]); fprintf(stderr, "\n"); fprintf(stderr, "FILE is a filesystem path.\n"); fprintf(stderr, "QUEUE MODEL is the string 'SPSC' or 'MPSC'.\n"); fprintf(stderr, "NUM THREADS is an integer.\n"); fprintf(stderr, "NUM MESSAGES is an integer.\n"); return EXIT_FAILURE; } file_path = argv[1]; queue_model_str = argv[2]; num_threads = atoi(argv[3]); num_messages = atoi(argv[4]); if (num_threads < 1) { fprintf(stderr, "%s: Error: invalid number of threads\n", argv[0]); return EXIT_FAILURE; } if (num_messages < 1) { fprintf(stderr, "%s: Error: invalid number of messages\n", argv[0]); return EXIT_FAILURE; } if (strcasecmp(queue_model_str, "SPSC") == 0) { queue_model = FSTRM_IOTHR_QUEUE_MODEL_SPSC; } else if (strcasecmp(queue_model_str, "MPSC") == 0) { queue_model = FSTRM_IOTHR_QUEUE_MODEL_MPSC; } else { fprintf(stderr, "%s: Error: invalid queue model\n", argv[0]); return EXIT_FAILURE; } printf("testing fstrm_iothr with file= %s " "queue_model= %s " "num_threads= %u " "num_messages= %u\n", file_path, queue_model_str, num_threads, num_messages); struct fstrm_file_options *fopt; fopt = fstrm_file_options_init(); fstrm_file_options_set_file_path(fopt, file_path); struct fstrm_writer *w = fstrm_file_writer_init(fopt, NULL); assert(w != NULL); fstrm_file_options_destroy(&fopt); struct fstrm_iothr_options *iothr_opt; iothr_opt = fstrm_iothr_options_init(); if (queue_model == FSTRM_IOTHR_QUEUE_MODEL_SPSC) { fstrm_iothr_options_set_num_input_queues(iothr_opt, num_threads); } else if (queue_model == FSTRM_IOTHR_QUEUE_MODEL_MPSC) { fstrm_iothr_options_set_num_input_queues(iothr_opt, 1); } else { assert(0); /* not reached */ } fstrm_iothr_options_set_queue_model(iothr_opt, queue_model); struct fstrm_iothr *iothr = fstrm_iothr_init(iothr_opt, &w); assert(iothr != NULL); fstrm_iothr_options_destroy(&iothr_opt); struct consumer test_consumer; struct producer test_producers[num_threads]; for (unsigned i = 0; i < num_threads; i++) { test_producers[i].iothr = iothr; test_producers[i].num_messages = num_messages; } if (queue_model == FSTRM_IOTHR_QUEUE_MODEL_SPSC) { for (unsigned i = 0; i < num_threads; i++) { test_producers[i].ioq = fstrm_iothr_get_input_queue(iothr); assert(test_producers[i].ioq != NULL); } } else if (queue_model == FSTRM_IOTHR_QUEUE_MODEL_MPSC) { struct fstrm_iothr_queue *ioq = fstrm_iothr_get_input_queue(iothr); assert(ioq != NULL); for (unsigned i = 0; i < num_threads; i++) test_producers[i].ioq = ioq; } else { assert(0); /* not reached */ } my_gettime(CLOCK_MONOTONIC, &ts_a); printf("creating %u producer threads\n", num_threads); for (unsigned i = 0; i < num_threads; i++) pthread_create(&test_producers[i].thr, NULL, thr_producer, &test_producers[i]); printf("joining %u producer threads\n", num_threads); for (unsigned i = 0; i < num_threads; i++) pthread_join(test_producers[i].thr, (void **) NULL); printf("destroying fstrm_iothr object\n"); fstrm_iothr_destroy(&iothr); my_gettime(CLOCK_MONOTONIC, &ts_b); my_timespec_sub(&ts_a, &ts_b); elapsed = my_timespec_to_double(&ts_b); printf("completed in %.2f seconds\n", elapsed); int res = consume_input(&test_consumer, file_path); if (res != EXIT_SUCCESS) return res; struct producer_stats pstat_sum; memset(&pstat_sum, 0, sizeof(pstat_sum)); for (unsigned i = 0; i < num_threads; i++) { pstat_sum.count_generated += test_producers[i].pstat.count_generated; pstat_sum.count_submitted += test_producers[i].pstat.count_submitted; pstat_sum.bytes_generated += test_producers[i].pstat.bytes_generated; pstat_sum.bytes_submitted += test_producers[i].pstat.bytes_submitted; } printf("count_generated= %" PRIu64 "\n", pstat_sum.count_generated); printf("bytes_generated= %" PRIu64 "\n", pstat_sum.bytes_generated); printf("count_submitted= %" PRIu64 "\n", pstat_sum.count_submitted); printf("bytes_submitted= %" PRIu64 "\n", pstat_sum.bytes_submitted); printf("count_received= %" PRIu64 " (%.3f)\n", test_consumer.cstat.count_received, (test_consumer.cstat.count_received + 0.0) / (pstat_sum.count_generated + 0.0) ); printf("bytes_received= %" PRIu64 " (%.3f)\n", test_consumer.cstat.bytes_received, (test_consumer.cstat.bytes_received + 0.0) / (pstat_sum.bytes_generated + 0.0) ); assert(pstat_sum.count_submitted == test_consumer.cstat.count_received); assert(pstat_sum.bytes_submitted == test_consumer.cstat.bytes_received); putchar('\n'); return EXIT_SUCCESS; }