Merge branch 'master' into patch-7

Author: House-Men

Makefile

@@ -233,6 +233,7 @@ unittest: prepare
 	$(CC)  -g -Wall -O0 -std=c99   -I. -Ibase            -o bin/mkdir_p           unittest/mkdir_test.c         base/hbase.c
 	$(CC)  -g -Wall -O0 -std=c99   -I. -Ibase            -o bin/rmdir_p           unittest/rmdir_test.c         base/hbase.c
 	$(CC)  -g -Wall -O0 -std=c99   -I. -Ibase            -o bin/date              unittest/date_test.c          base/htime.c
+	$(CC)  -g -Wall -O0 -std=c99   -I. -Ibase            -o bin/hlog_test         unittest/hlog_test.c          base/hlog.c
 	$(CC)  -g -Wall -O0 -std=c99   -I. -Ibase            -o bin/hatomic_test      unittest/hatomic_test.c       -pthread
 	$(CXX) -g -Wall -O0 -std=c++11 -I. -Ibase            -o bin/hatomic_cpp_test  unittest/hatomic_test.cpp     -pthread
 	$(CXX) -g -Wall -O0 -std=c++11 -I. -Ibase            -o bin/hthread_test      unittest/hthread_test.cpp     -pthread

base/hlog.c

@@ -1,5 +1,6 @@
 #include "hlog.h"
 
+#include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -44,6 +45,7 @@ struct logger_s {
     // for file logger
     char                filepath[256];
     unsigned long long  max_filesize;
+    float               truncate_percent;
     int                 remain_days;
     int                 enable_fsync;
     FILE*               fp_;
@@ -67,6 +69,7 @@ static void logger_init(logger_t* logger) {
 
     logger->fp_ = NULL;
     logger->max_filesize = DEFAULT_LOG_MAX_FILESIZE;
+    logger->truncate_percent = DEFAULT_LOG_TRUNCATE_PERCENT;
     logger->remain_days = DEFAULT_LOG_REMAIN_DAYS;
     logger->enable_fsync = 1;
     logger_set_file(logger, DEFAULT_LOG_FILE);
@@ -146,6 +149,11 @@ void logger_set_remain_days(logger_t* logger, int days) {
     logger->remain_days = days;
 }
 
+void logger_set_truncate_percent(logger_t* logger, float percent) {
+    assert(percent <= 1.0f);
+    logger->truncate_percent = percent;
+}
+
 void logger_set_max_bufsize(logger_t* logger, unsigned int bufsize) {
     logger->bufsize = bufsize;
     logger->buf = (char*)realloc(logger->buf, bufsize);
@@ -214,6 +222,68 @@ static void logfile_name(const char* filepath, time_t ts, char* buf, int len) {
             tm->tm_mday);
 }
 
+static void logfile_truncate(logger_t* logger) {
+    // close
+    if (logger->fp_) {
+        fclose(logger->fp_);
+        logger->fp_ = NULL;
+    }
+    char tmp_logfile[sizeof(logger->cur_logfile) + 4] = {0};
+    FILE* tmpfile = NULL;
+    if (logger->truncate_percent < 1.0f) {
+        snprintf(tmp_logfile, sizeof(tmp_logfile), "%s.tmp", logger->cur_logfile);
+        tmpfile = fopen(tmp_logfile, "w");
+    }
+    if (tmpfile) {
+        // truncate percent
+        logger->fp_ = fopen(logger->cur_logfile, "r");
+        if (logger->fp_) {
+            fseek(logger->fp_, 0, SEEK_END);
+            long filesize = ftell(logger->fp_);
+            long truncate_size = (long)((double)filesize * logger->truncate_percent);
+            fseek(logger->fp_, -(filesize - truncate_size), SEEK_CUR);
+            long cur_pos = ftell(logger->fp_);
+            char buf[4096] = {0};
+            const char* pbuf = buf;
+            size_t nread = 0, nwrite = 0;
+            char find_newline = 0;
+            while ((nread = fread(buf, 1, sizeof(buf), logger->fp_)) > 0) {
+                pbuf = buf;
+                if (find_newline == 0) {
+                    while (nread > 0) {
+                        if (*pbuf == '\n') {
+                            find_newline = 1;
+                            ++pbuf;
+                            --nread;
+                            break;
+                        }
+                        ++pbuf;
+                        --nread;
+                    }
+                }
+                if (nread > 0) {
+                    nwrite += fwrite(pbuf, 1, nread, tmpfile);
+                }
+            }
+            fclose(tmpfile);
+            fclose(logger->fp_);
+            logger->fp_ = NULL;
+            remove(logger->cur_logfile);
+            rename(tmp_logfile, logger->cur_logfile);
+        }
+    } else {
+        // truncate all
+        // remove(logger->cur_logfile);
+        logger->fp_ = fopen(logger->cur_logfile, "w");
+        if (logger->fp_) {
+            fclose(logger->fp_);
+            logger->fp_ = NULL;
+        }
+    }
+    // reopen
+    logger->fp_ = fopen(logger->cur_logfile, "a");
+}
+
 static FILE* logfile_shift(logger_t* logger) {
     time_t ts_now = time(NULL);
     int interval_days = logger->last_logfile_ts == 0 ? 0 : (ts_now+s_gmtoff) / SECONDS_PER_DAY - (logger->last_logfile_ts+s_gmtoff) / SECONDS_PER_DAY;
@@ -258,17 +328,8 @@ static FILE* logfile_shift(logger_t* logger) {
         fseek(logger->fp_, 0, SEEK_END);
         long filesize = ftell(logger->fp_);
         if (filesize > logger->max_filesize) {
-            fclose(logger->fp_);
-            logger->fp_ = NULL;
-            // ftruncate
-            logger->fp_ = fopen(logger->cur_logfile, "w");
-            // reopen with O_APPEND for multi-processes
-            if (logger->fp_) {
-                fclose(logger->fp_);
-                logger->fp_ = fopen(logger->cur_logfile, "a");
-            }
-        }
-        else {
+            logfile_truncate(logger);
+        } else {
             logger->can_write_cnt = (logger->max_filesize - filesize) / logger->bufsize;
         }
     }
@@ -419,7 +480,7 @@ int logger_print(logger_t* logger, int level, const char* fmt, ...) {
         len += snprintf(buf + len, bufsize - len, "%s", CLR_CLR);
     }
 
-    if(len<bufsize) {
+    if(len < bufsize) {
         buf[len++] = '\n';
     }
 

base/hlog.h

@@ -67,6 +67,7 @@ typedef enum {
 #define DEFAULT_LOG_REMAIN_DAYS     1
 #define DEFAULT_LOG_MAX_BUFSIZE     (1<<14)  // 16k
 #define DEFAULT_LOG_MAX_FILESIZE    (1<<24)  // 16M
+#define DEFAULT_LOG_TRUNCATE_PERCENT 0.99f   // truncate when exceeded max filesize
 
 // logger: default file_logger
 // network_logger() see event/nlog.h
@@ -113,6 +114,7 @@ HV_EXPORT void logger_set_max_filesize(logger_t* logger, unsigned long long file
 // 16, 16M, 16MB
 HV_EXPORT void logger_set_max_filesize_by_str(logger_t* logger, const char* filesize);
 HV_EXPORT void logger_set_remain_days(logger_t* logger, int days);
+HV_EXPORT void logger_set_truncate_percent(logger_t* logger, float percent);
 HV_EXPORT void logger_enable_fsync(logger_t* logger, int on);
 HV_EXPORT void logger_fsync(logger_t* logger);
 HV_EXPORT const char* logger_get_cur_file(logger_t* logger);
@@ -133,6 +135,7 @@ HV_EXPORT void      hv_destroy_default_logger(void);
 #define hlog_set_max_filesize(filesize) logger_set_max_filesize(hlog, filesize)
 #define hlog_set_max_filesize_by_str(filesize) logger_set_max_filesize_by_str(hlog, filesize)
 #define hlog_set_remain_days(days)      logger_set_remain_days(hlog, days)
+#define hlog_set_truncate_percent(val)  logger_set_truncate_percent(hlog, val)
 #define hlog_enable_fsync()             logger_enable_fsync(hlog, 1)
 #define hlog_disable_fsync()            logger_enable_fsync(hlog, 0)
 #define hlog_fsync()                    logger_fsync(hlog)

base/hmain.c

@@ -18,6 +18,7 @@
 static FILE* s_fp = NULL;
 
 main_ctx_t  g_main_ctx;
+printf_t printf_fn = printf;
 
 static void init_arg_kv(int maxsize) {
     g_main_ctx.arg_kv_size = 0;
@@ -238,7 +239,7 @@ int parse_opt(int argc, char** argv, const char* options) {
         while (*++p) {
             int arg_type = get_arg_type(*p, options);
             if (arg_type == UNDEFINED_OPTION) {
-                printf("Invalid option '%c'\n", *p);
+                printf_fn("Invalid option '%c'\n", *p);
                 return -20;
             } else if (arg_type == NO_ARGUMENT) {
                 save_arg_kv(p, 1, OPTION_ENABLE, 0);
@@ -251,7 +252,7 @@ int parse_opt(int argc, char** argv, const char* options) {
                     save_arg_kv(p, 1, argv[++i], 0);
                     break;
                 } else {
-                    printf("Option '%c' requires param\n", *p);
+                    printf_fn("Option '%c' requires param\n", *p);
                     return -30;
                 }
             }
@@ -309,7 +310,7 @@ int parse_opt_long(int argc, char** argv, const option_t* long_options, int size
         char* delim = strchr(arg, OPTION_DELIM);
         if (delim) {
             if (delim == arg || delim == arg+arg_len-1 || delim-arg > MAX_OPTION) {
-                printf("Invalid option '%s'\n", argv[i]);
+                printf_fn("Invalid option '%s'\n", argv[i]);
                 return -10;
             }
             memcpy(opt, arg, delim-arg);
@@ -329,7 +330,7 @@ int parse_opt_long(int argc, char** argv, const option_t* long_options, int size
                 save_arg_list(arg);
                 continue;
             } else {
-                printf("Invalid option: '%s'\n", argv[i]);
+                printf_fn("Invalid option: '%s'\n", argv[i]);
                 return -10;
             }
         }
@@ -349,7 +350,7 @@ int parse_opt_long(int argc, char** argv, const option_t* long_options, int size
                     // --port 80
                     value = argv[++i];
                 } else if (pOption->arg_type == REQUIRED_ARGUMENT) {
-                    printf("Option '%s' requires parament\n", opt);
+                    printf_fn("Option '%s' requires parament\n", opt);
                     return -20;
                 } else {
                     // arg_type == OPTIONAL_ARGUMENT
@@ -586,21 +587,22 @@ int signal_init(procedure_t reload_fn, void* reload_userdata) {
 #include <mmsystem.h> // for timeSetEvent
 
 // win32 use Event
-//static HANDLE s_hEventTerm = NULL;
+static HANDLE s_hEventTerm = NULL;
+static HANDLE s_hEventTermWait = NULL;
 static HANDLE s_hEventReload = NULL;
 
 static void WINAPI on_timer(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2) {
     DWORD ret;
-    /*
+
     ret = WaitForSingleObject(s_hEventTerm, 0);
     if (ret == WAIT_OBJECT_0) {
         hlogi("pid=%d recv event [TERM]", getpid());
         if (getpid_from_pidfile() == getpid()) {
+            SetEvent(s_hEventTermWait);
             timeKillEvent(uTimerID);
             exit(0);
         }
     }
-    */
 
     ret = WaitForSingleObject(s_hEventReload, 0);
     if (ret == WAIT_OBJECT_0) {
@@ -612,8 +614,10 @@ static void WINAPI on_timer(UINT uTimerID, UINT uMsg, DWORD_PTR dwUser, DWORD_PT
 }
 
 static void signal_cleanup(void) {
-    //CloseHandle(s_hEventTerm);
-    //s_hEventTerm = NULL;
+    CloseHandle(s_hEventTerm);
+    s_hEventTerm = NULL;
+    CloseHandle(s_hEventTermWait);
+    s_hEventTermWait = NULL;
     CloseHandle(s_hEventReload);
     s_hEventReload = NULL;
 }
@@ -623,11 +627,17 @@ int signal_init(procedure_t reload_fn, void* reload_userdata) {
     g_main_ctx.reload_userdata = reload_userdata;
 
     char eventname[MAX_PATH] = {0};
-    //snprintf(eventname, sizeof(eventname), "%s_term_event", g_main_ctx.program_name);
-    //s_hEventTerm = CreateEvent(NULL, FALSE, FALSE, eventname);
-    //s_hEventTerm = OpenEvent(EVENT_ALL_ACCESS, FALSE, eventname);
+    snprintf(eventname, sizeof(eventname), "%s_term_event", g_main_ctx.program_name);
+    s_hEventTerm = CreateEvent(NULL, FALSE, FALSE, eventname);
+    if(s_hEventTerm == NULL) return -1;
+
+    snprintf(eventname, sizeof(eventname), "%s_term_wait_event", g_main_ctx.program_name);
+    s_hEventTermWait = CreateEvent(NULL, FALSE, FALSE, eventname);
+    if(s_hEventTermWait == NULL) return -2;
+
     snprintf(eventname, sizeof(eventname), "%s_reload_event", g_main_ctx.program_name);
     s_hEventReload = CreateEvent(NULL, FALSE, FALSE, eventname);
+    if(s_hEventReload == NULL) return -3;
 
     timeSetEvent(1000, 1000, on_timer, 0, TIME_PERIODIC);
 
@@ -640,8 +650,8 @@ static void kill_proc(int pid) {
 #ifdef OS_UNIX
     kill(pid, SIGNAL_TERMINATE);
 #else
-    //SetEvent(s_hEventTerm);
-    //hv_sleep(1);
+    SetEvent(s_hEventTerm);
+    if (WaitForSingleObject(s_hEventTermWait, 2000) == WAIT_OBJECT_0) return;
     HANDLE hproc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
     if (hproc) {
         TerminateProcess(hproc, 0);
@@ -651,50 +661,55 @@ static void kill_proc(int pid) {
 }
 
 void signal_handle(const char* signal) {
+    if (signal_handle_noexit(signal)) exit(0);
+}
+
+bool signal_handle_noexit(const char* signal) {
     if (strcmp(signal, "start") == 0) {
         if (g_main_ctx.oldpid > 0) {
-            printf("%s is already running, pid=%d\n", g_main_ctx.program_name, g_main_ctx.oldpid);
-            exit(0);
+            printf_fn("%s is already running, pid=%d\n", g_main_ctx.program_name, g_main_ctx.oldpid);
+            return true;
         }
     } else if (strcmp(signal, "stop") == 0) {
         if (g_main_ctx.oldpid > 0) {
             kill_proc(g_main_ctx.oldpid);
-            printf("%s stop/waiting\n", g_main_ctx.program_name);
+            printf_fn("%s stop/waiting\n", g_main_ctx.program_name);
         } else {
-            printf("%s is already stopped\n", g_main_ctx.program_name);
+            printf_fn("%s is already stopped\n", g_main_ctx.program_name);
         }
-        exit(0);
+        return true;
     } else if (strcmp(signal, "restart") == 0) {
         if (g_main_ctx.oldpid > 0) {
             kill_proc(g_main_ctx.oldpid);
-            printf("%s stop/waiting\n", g_main_ctx.program_name);
+            printf_fn("%s stop/waiting\n", g_main_ctx.program_name);
             hv_sleep(1);
         }
     } else if (strcmp(signal, "status") == 0) {
         if (g_main_ctx.oldpid > 0) {
-            printf("%s start/running, pid=%d\n", g_main_ctx.program_name, g_main_ctx.oldpid);
+            printf_fn("%s start/running, pid=%d\n", g_main_ctx.program_name, g_main_ctx.oldpid);
         } else {
-            printf("%s is already stopped\n", g_main_ctx.program_name);
+            printf_fn("%s is already stopped\n", g_main_ctx.program_name);
         }
-        exit(0);
+        return true;
     } else if (strcmp(signal, "reload") == 0) {
         if (g_main_ctx.oldpid > 0) {
-            printf("reload confile [%s]\n", g_main_ctx.confile);
+            printf_fn("reload confile [%s]\n", g_main_ctx.confile);
 #ifdef OS_UNIX
             kill(g_main_ctx.oldpid, SIGNAL_RELOAD);
 #else
             SetEvent(s_hEventReload);
 #endif
             hv_sleep(1);
         } else {
-            printf("%s is already stopped\n", g_main_ctx.program_name);
+            printf_fn("%s is already stopped\n", g_main_ctx.program_name);
         }
-        exit(0);
+        return true;
     } else {
-        printf("Invalid signal: '%s'\n", signal);
-        exit(0);
+        printf_fn("Invalid signal: '%s'\n", signal);
+        return true;
     }
-    printf("%s start/running\n", g_main_ctx.program_name);
+    printf_fn("%s start/running\n", g_main_ctx.program_name);
+    return false;
 }
 
 // master-workers processes

base/hmain.h

@@ -12,6 +12,8 @@
 
 BEGIN_EXTERN_C
 
+typedef int (*printf_t)(const char *const fmt, ...);
+
 typedef struct main_ctx_s {
     char    run_dir[MAX_PATH];
     char    program_name[MAX_PATH];
@@ -94,6 +96,7 @@ HV_EXPORT pid_t getpid_from_pidfile();
 // signal=[start,stop,restart,status,reload]
 HV_EXPORT int  signal_init(procedure_t reload_fn DEFAULT(NULL), void* reload_userdata DEFAULT(NULL));
 HV_EXPORT void signal_handle(const char* signal);
+HV_EXPORT bool signal_handle_noexit(const char* signal);
 #ifdef OS_UNIX
 // we use SIGTERM to quit process, SIGUSR1 to reload confile
 #define SIGNAL_TERMINATE    SIGTERM
@@ -105,6 +108,7 @@ void signal_handler(int signo);
 #define DEFAULT_WORKER_PROCESSES    4
 #define MAXNUM_WORKER_PROCESSES     256
 HV_EXPORT extern main_ctx_t   g_main_ctx;
+HV_EXPORT extern printf_t     printf_fn;
 
 // master-workers processes
 HV_EXPORT int master_workers_run(