From 0ad25ba3ab32d658ba015848a64d0f307c5fbf36 Mon Sep 17 00:00:00 2001 From: vraatikka Date: Thu, 8 Aug 2013 23:38:00 +0300 Subject: [PATCH] Added functions skygw_log_enable(logfile_id_t) and skygw_log_disable(logfile_id_t) to Log manager API. By calling them log writing to any of predefined log files can be switched on or off. Added simple test to testlog.c --- log_manager/log_manager.cc | 158 +++++++++++++++++++++++++++++++++++-- log_manager/log_manager.h | 10 +-- log_manager/test/testlog.c | 70 +++++++++++++++- utils/skygw_utils.cc | 29 +++++-- 4 files changed, 247 insertions(+), 20 deletions(-) diff --git a/log_manager/log_manager.cc b/log_manager/log_manager.cc index 62e9e0cf9..ad159afd2 100644 --- a/log_manager/log_manager.cc +++ b/log_manager/log_manager.cc @@ -87,13 +87,15 @@ typedef struct blockbuf_st { skygw_chk_t bb_chk_tail; } blockbuf_t; -/** logfile object corresponds to physical file(s) where +/** + * logfile object corresponds to physical file(s) where * certain log is written. */ struct logfile_st { skygw_chk_t lf_chk_top; flat_obj_state_t lf_state; bool lf_init_started; + bool lf_enabled; logmanager_t* lf_lmgr; /** fwr_logmes is for messages from log clients */ skygw_message_t* lf_logmes; @@ -130,6 +132,7 @@ struct fnames_conf_st { struct logmanager_st { skygw_chk_t lm_chk_top; bool lm_enabled; + int lm_enabled_logfiles; simple_mutex_t lm_mutex; size_t lm_nlinks; /** fwr_logmes is for messages from log clients */ @@ -190,6 +193,8 @@ static char* blockbuf_get_writepos( static void blockbuf_register(blockbuf_t* bb); static void blockbuf_unregister(blockbuf_t* bb); +static bool log_set_enabled(logfile_id_t id, bool val); + const char* get_suffix_default(void) { @@ -245,6 +250,8 @@ static bool logmanager_init_nomutex( lm->lm_chk_tail = CHK_NUM_LOGMANAGER; lm->lm_clientmes = skygw_message_init(); lm->lm_logmes = skygw_message_init(); + lm->lm_enabled_logfiles |= LOGFILE_ERROR; + lm->lm_enabled_logfiles |= LOGFILE_MESSAGE; fn = &lm->lm_fnames_conf; fw = &lm->lm_filewriter; fn->fn_state = UNINIT; @@ -276,6 +283,7 @@ static bool logmanager_init_nomutex( } /** Wait message from filewriter_thr */ skygw_message_wait(fw->fwr_clientmes); + succp = TRUE; lm->lm_enabled = TRUE; @@ -639,7 +647,6 @@ static char* blockbuf_get_writepos( mlist_node_t* node; blockbuf_t* bb; ss_debug(bool succp;) - ss_debug(int i=0;) CHK_LOGMANAGER(lm); @@ -841,6 +848,114 @@ static blockbuf_t* blockbuf_init( } +int skygw_log_enable( + logfile_id_t id) +{ + bool err = 0; + + if (!logmanager_register(TRUE)) { + fprintf(stderr, "ERROR: Can't register to logmanager\n"); + err = -1; + goto return_err; + } + CHK_LOGMANAGER(lm); + + if (log_set_enabled(id, TRUE)) { + lm->lm_enabled_logfiles |= id; + } + + logmanager_unregister(); +return_err: + return err; +} + + +int skygw_log_disable( + logfile_id_t id) +{ + bool err = 0; + + if (!logmanager_register(TRUE)) { + fprintf(stderr, "ERROR: Can't register to logmanager\n"); + err = -1; + goto return_err; + } + CHK_LOGMANAGER(lm); + + if (log_set_enabled(id, FALSE)) { + lm->lm_enabled_logfiles &= ~id; + } + + logmanager_unregister(); +return_err: + return err; +} + + +static bool log_set_enabled( + logfile_id_t id, + bool val) +{ + char* logstr; + va_list notused; + bool oldval; + bool succp = FALSE; + int err = 0; + logfile_t* lf; + + CHK_LOGMANAGER(lm); + + if (id < LOGFILE_FIRST || id > LOGFILE_LAST) { + char* errstr = "Invalid logfile id argument."; + /** + * invalid id, since we don't have logfile yet. + */ + err = logmanager_write_log(LOGFILE_ERROR, + TRUE, + FALSE, + strlen(errstr)+1, + errstr, + notused); + if (err != 0) { + fprintf(stderr, + "Writing to logfile %s failed.\n", + STRLOGID(LOGFILE_ERROR)); + } + ss_dassert(FALSE); + goto return_succp; + } + lf = &lm->lm_logfile[id]; + CHK_LOGFILE(lf); + + if (val) { + logstr = strdup("---\tLogging is enabled\t--"); + } else { + logstr = strdup("---\tLogging is disabled\t--"); + } + oldval = lf->lf_enabled; + lf->lf_enabled = val; + err = logmanager_write_log(id, + TRUE, + FALSE, + strlen(logstr)+1, + logstr, + notused); + free(logstr); + + if (err != 0) { + lf->lf_enabled = oldval; + fprintf(stderr, + "log_set_enabled failed. Writing notification to logfile %s " + "failed.\n ", + STRLOGID(id)); + goto return_succp; + } + succp = TRUE; +return_succp: + return succp; +} + + int skygw_log_write_flush( logfile_id_t id, char* str, @@ -862,6 +977,13 @@ int skygw_log_write_flush( STRLOGID(id), str); #endif + /** + * If particular log is disabled only unregister and return. + */ + if (!(lm->lm_enabled_logfiles & id)) { + err = 1; + goto return_unregister; + } /** * Find out the length of log string (to be formatted str). */ @@ -915,6 +1037,13 @@ int skygw_log_write( STRLOGID(id), str); #endif + /** + * If particular log is disabled only unregister and return. + */ + if (!(lm->lm_enabled_logfiles & id)) { + err = 1; + goto return_unregister; + } /** * Find out the length of log string (to be formatted str). */ @@ -1228,19 +1357,20 @@ static char* fname_conf_get_suffix( static bool logfiles_init( - logmanager_t* lmgr) + logmanager_t* lm) { bool succp = TRUE; int i = LOGFILE_FIRST; while(i<=LOGFILE_LAST && succp) { - succp = logfile_init(&lmgr->lm_logfile[i], (logfile_id_t)i, lmgr); - + succp = logfile_init(&lm->lm_logfile[i], (logfile_id_t)i, lm); + if (!succp) { fprintf(stderr, "Initializing logfiles failed\n"); break; } - i++; + i <<= 1; + } return succp; } @@ -1278,6 +1408,7 @@ static bool logfile_init( logfile->lf_lmgr = logmanager; logfile->lf_flushflag = FALSE; logfile->lf_spinlock = 0; + logfile->lf_enabled = logmanager->lm_enabled_logfiles & logfile_id; /** Read existing files to logfile->lf_files_list and create * new file for log named after / */ @@ -1397,6 +1528,7 @@ static bool filewriter_init( logfile_t* lf; logfile_id_t id; int i; + char* start_msg_str; CHK_LOGMANAGER(logmanager); @@ -1412,7 +1544,7 @@ static bool filewriter_init( if (fw->fwr_logmes == NULL || fw->fwr_clientmes == NULL) { goto return_succp; } - for (i=LOGFILE_FIRST; i<=LOGFILE_LAST; i++) { + for (i=LOGFILE_FIRST; i<=LOGFILE_LAST; i <<= 1) { id = (logfile_id_t)i; lf = logmanager_get_logfile(logmanager, id); fw->fwr_file[id] = skygw_file_init(lf->lf_full_name); @@ -1420,6 +1552,16 @@ static bool filewriter_init( if (fw->fwr_file[id] == NULL) { goto return_succp; } + if (lf->lf_enabled) { + start_msg_str = strdup("---\tLogging is enabled.\n"); + } else { + start_msg_str = strdup("---\tLogging is disabled.\n"); + } + skygw_file_write(fw->fwr_file[id], + (void *)start_msg_str, + strlen(start_msg_str), + TRUE); + free(start_msg_str); } fw->fwr_state = RUN; CHK_FILEWRITER(fw); @@ -1534,7 +1676,7 @@ static void* thr_filewriter_fun( flushall_logfiles = skygw_thread_must_exit(thr); /** Process all logfiles which have buffered writes. */ - for (i=LOGFILE_FIRST; i<=LOGFILE_LAST; i++) { + for (i=LOGFILE_FIRST; i<=LOGFILE_LAST; i <<= 1) { /** * Get file pointer of current logfile. */ diff --git a/log_manager/log_manager.h b/log_manager/log_manager.h index a15913b41..cfaa4f567 100644 --- a/log_manager/log_manager.h +++ b/log_manager/log_manager.h @@ -23,16 +23,15 @@ typedef struct fnames_conf_st fnames_conf_t; typedef struct logmanager_st logmanager_t; typedef enum { - LOGFILE_TRACE = 0, + LOGFILE_TRACE = 1, LOGFILE_FIRST = LOGFILE_TRACE, - LOGFILE_MESSAGE, - LOGFILE_ERROR, + LOGFILE_MESSAGE = 2, + LOGFILE_ERROR = 4, LOGFILE_LAST = LOGFILE_ERROR } logfile_id_t; typedef enum { FILEWRITER_INIT, FILEWRITER_RUN, FILEWRITER_DONE } filewriter_state_t; -typedef enum { LOGFILE_INIT, LOGFILE_OPENED, LOGFILE_DONE } logfile_state_t; /** * UNINIT means zeroed memory buffer allocated for the struct. @@ -56,7 +55,8 @@ void skygw_log_done(void); int skygw_log_write(logfile_id_t id, char* format, ...); int skygw_log_flush(logfile_id_t id); int skygw_log_write_flush(logfile_id_t id, char* format, ...); - +int skygw_log_enable(logfile_id_t id); +int skygw_log_disable(logfile_id_t id); EXTERN_C_BLOCK_END diff --git a/log_manager/test/testlog.c b/log_manager/test/testlog.c index fe3a0ce44..13300ec6b 100644 --- a/log_manager/test/testlog.c +++ b/log_manager/test/testlog.c @@ -44,6 +44,9 @@ static void* thr_run_morelog(void* data); #define TEST1 #define TEST2 #endif + +#define TEST3 + int main(int argc, char* argv[]) { int err = 0; @@ -175,7 +178,9 @@ int main(int argc, char* argv[]) free(thr[i]); } #endif + #if defined(TEST2) + fprintf(stderr, "\nStarting test #2 \n"); /** 2 */ @@ -229,7 +234,70 @@ int main(int argc, char* argv[]) /** Test ended here */ skygw_message_done(mes); simple_mutex_done(mtx); -#endif +#endif /* TEST 2 */ + +#if defined(TEST3) + +/** + * Test enable/disable log. + */ + r = skygw_logmanager_init(argc, argv); + ss_dassert(r); + + logstr = ("1.\tWrite to ERROR and MESSAGE logs."); + err = skygw_log_write(LOGFILE_MESSAGE, logstr); + ss_dassert(err == 0); + err = skygw_log_write(LOGFILE_TRACE, logstr); + ss_dassert(err != 0); /**< Must fail */ + err = skygw_log_write(LOGFILE_ERROR, logstr); + ss_dassert(err == 0); + + skygw_log_enable(LOGFILE_TRACE); + + logstr = ("2.\tWrite to ERROR and MESSAGE and TRACE logs."); + err = skygw_log_write(LOGFILE_MESSAGE, logstr); + ss_dassert(err == 0); + err = skygw_log_write(LOGFILE_TRACE, logstr); + ss_dassert(err == 0); + err = skygw_log_write(LOGFILE_ERROR, logstr); + ss_dassert(err == 0); + + skygw_log_disable(LOGFILE_ERROR); + + logstr = ("3.\tWrite to MESSAGE and TRACE logs."); + err = skygw_log_write(LOGFILE_MESSAGE, logstr); + ss_dassert(err == 0); + err = skygw_log_write(LOGFILE_TRACE, logstr); + ss_dassert(err == 0); + err = skygw_log_write(LOGFILE_ERROR, logstr); + ss_dassert(err != 0); /**< Must fail */ + + skygw_log_disable(LOGFILE_MESSAGE); + skygw_log_disable(LOGFILE_TRACE); + + logstr = ("4.\tWrite to none."); + err = skygw_log_write(LOGFILE_MESSAGE, logstr); + ss_dassert(err != 0); /**< Must fail */ + err = skygw_log_write(LOGFILE_TRACE, logstr); + ss_dassert(err != 0); /**< Must fail */ + err = skygw_log_write(LOGFILE_ERROR, logstr); + ss_dassert(err != 0); /**< Must fail */ + + skygw_log_enable(LOGFILE_ERROR); + skygw_log_enable(LOGFILE_MESSAGE); + + logstr = ("4.\tWrite to ERROR and MESSAGE logs."); + err = skygw_log_write(LOGFILE_MESSAGE, logstr); + ss_dassert(err == 0); + err = skygw_log_write(LOGFILE_TRACE, logstr); + ss_dassert(err != 0); /**< Must fail */ + err = skygw_log_write(LOGFILE_ERROR, logstr); + ss_dassert(err == 0); + + skygw_logmanager_done(); + +#endif /* TEST 3 */ + fprintf(stderr, ".. done.\n"); return err; } diff --git a/utils/skygw_utils.cc b/utils/skygw_utils.cc index 3c613b163..b654d958c 100644 --- a/utils/skygw_utils.cc +++ b/utils/skygw_utils.cc @@ -1503,12 +1503,15 @@ static bool file_write_header( size_t wbytes1; size_t wbytes2; size_t wbytes3; + size_t wbytes4; size_t len1; size_t len2; size_t len3; + size_t len4; const char* header_buf1; char* header_buf2 = NULL; - const char* header_buf3; + char* header_buf3 = NULL; + const char* header_buf4; time_t* t; struct tm* tm; @@ -1519,29 +1522,38 @@ static bool file_write_header( CHK_FILE(file); header_buf1 = "\n\nSkySQL MaxScale\t"; - header_buf2 = strdup(asctime(tm)); - header_buf3 = "------------------------------------------\n"; + header_buf2 = (char *)calloc(1, strlen(file->sf_fname)+2); + snprintf(header_buf2, strlen(file->sf_fname)+2, "%s ", file->sf_fname); + header_buf3 = strdup(asctime(tm)); + header_buf4 = "---------------------------------------------------------" + "---------------------------\n"; if (header_buf2 == NULL) { goto return_succp; } + if (header_buf3 == NULL) { + goto return_succp; + } + len1 = strlen(header_buf1); len2 = strlen(header_buf2); len3 = strlen(header_buf3); + len4 = strlen(header_buf4); #if defined(LAPTOP_TEST) usleep(DISKWRITE_LATENCY); #else wbytes1=fwrite((void*)header_buf1, len1, 1, file->sf_file); wbytes2=fwrite((void*)header_buf2, len2, 1, file->sf_file); wbytes3=fwrite((void*)header_buf3, len3, 1, file->sf_file); + wbytes4=fwrite((void*)header_buf4, len4, 1, file->sf_file); - if (wbytes1 != 1 || wbytes2 != 1 || wbytes3 != 1) { + if (wbytes1 != 1 || wbytes2 != 1 || wbytes3 != 1 || wbytes4 != 1) { fprintf(stderr, "Writing header %s %s %s to %s failed.\n", header_buf1, header_buf2, header_buf3, - file->sf_fname); + header_buf4); perror("Logfile header write.\n"); goto return_succp; } @@ -1550,7 +1562,12 @@ static bool file_write_header( succp = TRUE; return_succp: - free(header_buf2); + if (header_buf2 != NULL) { + free(header_buf2); + } + if (header_buf3 != NULL) { + free(header_buf3); + } free(t); free(tm); return succp;