From 574784110a6f19cd173b217f50f80097db5e3edc Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Mon, 18 Feb 2019 00:09:59 +0800 Subject: [PATCH 01/13] Add support for automatic removal of old logs GetOverdueLogNames(string log_directory, int days) will check all filenames under log_directory, and return a list of files whose last modified time is over the given days (calculated using difftime()). So that we can easily for unlink all files stored in the returned vector. --- src/logging.cc | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/src/logging.cc b/src/logging.cc index 0c86cf622..1b68dae41 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -44,6 +44,8 @@ #ifdef HAVE_SYS_UTSNAME_H # include // For uname. #endif +#include +#include #include #include #include @@ -1136,6 +1138,78 @@ void LogFileObject::Write(bool force_flush, } // namespace +namespace { + +vector SplitString(const string& s, const char delimiter) { + std::stringstream ss(s); + string t; + vector tokens; + + while (std::getline(ss, t, delimiter)) { + if (t.length() > 0) { + tokens.push_back(t); + } + } + return tokens; +} + +bool IsGlogLog(const string& log_name) { + // Check if log_name matches the pattern "Project.Hostname.Username.log..." + static const int kGlogFilenameTokenCount = 6; + vector log_name_tokens = SplitString(log_name, '.'); + + return log_name_tokens.size() >= kGlogFilenameTokenCount + && log_name_tokens[1] == LogDestination::hostname() + && log_name_tokens[2] == MyUserName() + && log_name_tokens[3] == "log"; +} + +bool LastModifiedOver(const string& log_name, int days) { + // Try to get the last modified time of log. + struct stat log_stat; + + if(stat(log_name.c_str(), &log_stat) == 0) { + // A day is 86400 seconds, so 7 days is 86400 * 7 = 604800 seconds. + time_t last_modified_time = log_stat.st_mtime; + time_t current_time = time(nullptr); + return difftime(current_time, last_modified_time) > days * 86400; + } + + // If failed to get file stat, don't return true! + return false; +} + +vector GetOverdueLogNames(string log_directory, int days) { + // The names of overdue logs. + vector overdue_log_names; + + // Try to get all files within log_directory. + DIR *dir; + struct dirent *ent; + + // If log_directory doesn't end with a slash, append a slash to it. + if (log_directory.back() != '/') { + log_directory += '/'; + } + + if ((dir=opendir(log_directory.c_str()))) { + while ((ent=readdir(dir))) { + string filename = log_directory + string(ent->d_name); + if (IsGlogLog(filename) && LastModifiedOver(filename, days)) { + overdue_log_names.push_back(filename); + } + } + closedir(dir); + } else { + perror("Unable to open directory."); + } + + return overdue_log_names; +} + +} // namespace + + // Static log data space to avoid alloc failures in a LOG(FATAL) // // Since multiple threads may call LOG(FATAL), and we want to preserve From 4dd1386c6eb7d34703f4ab00dda4f0bbcace8507 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Mon, 18 Feb 2019 12:51:22 +0800 Subject: [PATCH 02/13] Replaced the lines that require C++11 --- src/logging.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index 1b68dae41..d549ff567 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -1171,7 +1171,7 @@ bool LastModifiedOver(const string& log_name, int days) { if(stat(log_name.c_str(), &log_stat) == 0) { // A day is 86400 seconds, so 7 days is 86400 * 7 = 604800 seconds. time_t last_modified_time = log_stat.st_mtime; - time_t current_time = time(nullptr); + time_t current_time = time(NULL); return difftime(current_time, last_modified_time) > days * 86400; } @@ -1188,7 +1188,7 @@ vector GetOverdueLogNames(string log_directory, int days) { struct dirent *ent; // If log_directory doesn't end with a slash, append a slash to it. - if (log_directory.back() != '/') { + if (log_directory.at(log_directory.size() - 1) != '/') { log_directory += '/'; } From 55cfc389125bce0163ce899f63c46fbdb35ca483 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Wed, 21 Aug 2019 20:43:47 +0800 Subject: [PATCH 03/13] embed dirent.h in project --- src/logging.cc | 6 +- src/windows/dirent.h | 1160 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1165 insertions(+), 1 deletion(-) create mode 100644 src/windows/dirent.h diff --git a/src/logging.cc b/src/logging.cc index d549ff567..7924a3139 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -44,7 +44,6 @@ #ifdef HAVE_SYS_UTSNAME_H # include // For uname. #endif -#include #include #include #include @@ -60,6 +59,11 @@ #include #include // for errno #include +#ifdef OS_WINDOWS +#include "windows/dirent.h" +#else +#include // for automatic removal of old logs +#endif #include "base/commandlineflags.h" // to get the program name #include "glog/logging.h" #include "glog/raw_logging.h" diff --git a/src/windows/dirent.h b/src/windows/dirent.h new file mode 100644 index 000000000..f7a46dafc --- /dev/null +++ b/src/windows/dirent.h @@ -0,0 +1,1160 @@ +/* + * Dirent interface for Microsoft Visual Studio + * + * Copyright (C) 1998-2019 Toni Ronkko + * This file is part of dirent. Dirent may be freely distributed + * under the MIT license. For all details and documentation, see + * https://github.com/tronkko/dirent + */ +#ifndef DIRENT_H +#define DIRENT_H + +/* Hide warnings about unreferenced local functions */ +#if defined(__clang__) +# pragma clang diagnostic ignored "-Wunused-function" +#elif defined(_MSC_VER) +# pragma warning(disable:4505) +#elif defined(__GNUC__) +# pragma GCC diagnostic ignored "-Wunused-function" +#endif + +/* + * Include windows.h without Windows Sockets 1.1 to prevent conflicts with + * Windows Sockets 2.0. + */ +#ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Indicates that d_type field is available in dirent structure */ +#define _DIRENT_HAVE_D_TYPE + +/* Indicates that d_namlen field is available in dirent structure */ +#define _DIRENT_HAVE_D_NAMLEN + +/* Entries missing from MSVC 6.0 */ +#if !defined(FILE_ATTRIBUTE_DEVICE) +# define FILE_ATTRIBUTE_DEVICE 0x40 +#endif + +/* File type and permission flags for stat(), general mask */ +#if !defined(S_IFMT) +# define S_IFMT _S_IFMT +#endif + +/* Directory bit */ +#if !defined(S_IFDIR) +# define S_IFDIR _S_IFDIR +#endif + +/* Character device bit */ +#if !defined(S_IFCHR) +# define S_IFCHR _S_IFCHR +#endif + +/* Pipe bit */ +#if !defined(S_IFFIFO) +# define S_IFFIFO _S_IFFIFO +#endif + +/* Regular file bit */ +#if !defined(S_IFREG) +# define S_IFREG _S_IFREG +#endif + +/* Read permission */ +#if !defined(S_IREAD) +# define S_IREAD _S_IREAD +#endif + +/* Write permission */ +#if !defined(S_IWRITE) +# define S_IWRITE _S_IWRITE +#endif + +/* Execute permission */ +#if !defined(S_IEXEC) +# define S_IEXEC _S_IEXEC +#endif + +/* Pipe */ +#if !defined(S_IFIFO) +# define S_IFIFO _S_IFIFO +#endif + +/* Block device */ +#if !defined(S_IFBLK) +# define S_IFBLK 0 +#endif + +/* Link */ +#if !defined(S_IFLNK) +# define S_IFLNK 0 +#endif + +/* Socket */ +#if !defined(S_IFSOCK) +# define S_IFSOCK 0 +#endif + +/* Read user permission */ +#if !defined(S_IRUSR) +# define S_IRUSR S_IREAD +#endif + +/* Write user permission */ +#if !defined(S_IWUSR) +# define S_IWUSR S_IWRITE +#endif + +/* Execute user permission */ +#if !defined(S_IXUSR) +# define S_IXUSR 0 +#endif + +/* Read group permission */ +#if !defined(S_IRGRP) +# define S_IRGRP 0 +#endif + +/* Write group permission */ +#if !defined(S_IWGRP) +# define S_IWGRP 0 +#endif + +/* Execute group permission */ +#if !defined(S_IXGRP) +# define S_IXGRP 0 +#endif + +/* Read others permission */ +#if !defined(S_IROTH) +# define S_IROTH 0 +#endif + +/* Write others permission */ +#if !defined(S_IWOTH) +# define S_IWOTH 0 +#endif + +/* Execute others permission */ +#if !defined(S_IXOTH) +# define S_IXOTH 0 +#endif + +/* Maximum length of file name */ +#if !defined(PATH_MAX) +# define PATH_MAX MAX_PATH +#endif +#if !defined(FILENAME_MAX) +# define FILENAME_MAX MAX_PATH +#endif +#if !defined(NAME_MAX) +# define NAME_MAX FILENAME_MAX +#endif + +/* File type flags for d_type */ +#define DT_UNKNOWN 0 +#define DT_REG S_IFREG +#define DT_DIR S_IFDIR +#define DT_FIFO S_IFIFO +#define DT_SOCK S_IFSOCK +#define DT_CHR S_IFCHR +#define DT_BLK S_IFBLK +#define DT_LNK S_IFLNK + +/* Macros for converting between st_mode and d_type */ +#define IFTODT(mode) ((mode) & S_IFMT) +#define DTTOIF(type) (type) + +/* + * File type macros. Note that block devices, sockets and links cannot be + * distinguished on Windows and the macros S_ISBLK, S_ISSOCK and S_ISLNK are + * only defined for compatibility. These macros should always return false + * on Windows. + */ +#if !defined(S_ISFIFO) +# define S_ISFIFO(mode) (((mode) & S_IFMT) == S_IFIFO) +#endif +#if !defined(S_ISDIR) +# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR) +#endif +#if !defined(S_ISREG) +# define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) +#endif +#if !defined(S_ISLNK) +# define S_ISLNK(mode) (((mode) & S_IFMT) == S_IFLNK) +#endif +#if !defined(S_ISSOCK) +# define S_ISSOCK(mode) (((mode) & S_IFMT) == S_IFSOCK) +#endif +#if !defined(S_ISCHR) +# define S_ISCHR(mode) (((mode) & S_IFMT) == S_IFCHR) +#endif +#if !defined(S_ISBLK) +# define S_ISBLK(mode) (((mode) & S_IFMT) == S_IFBLK) +#endif + +/* Return the exact length of the file name without zero terminator */ +#define _D_EXACT_NAMLEN(p) ((p)->d_namlen) + +/* Return the maximum size of a file name */ +#define _D_ALLOC_NAMLEN(p) ((PATH_MAX)+1) + + +#ifdef __cplusplus +extern "C" { +#endif + + +/* Wide-character version */ +struct _wdirent { + /* Always zero */ + long d_ino; + + /* File position within stream */ + long d_off; + + /* Structure size */ + unsigned short d_reclen; + + /* Length of name without \0 */ + size_t d_namlen; + + /* File type */ + int d_type; + + /* File name */ + wchar_t d_name[PATH_MAX+1]; +}; +typedef struct _wdirent _wdirent; + +struct _WDIR { + /* Current directory entry */ + struct _wdirent ent; + + /* Private file data */ + WIN32_FIND_DATAW data; + + /* True if data is valid */ + int cached; + + /* Win32 search handle */ + HANDLE handle; + + /* Initial directory name */ + wchar_t *patt; +}; +typedef struct _WDIR _WDIR; + +/* Multi-byte character version */ +struct dirent { + /* Always zero */ + long d_ino; + + /* File position within stream */ + long d_off; + + /* Structure size */ + unsigned short d_reclen; + + /* Length of name without \0 */ + size_t d_namlen; + + /* File type */ + int d_type; + + /* File name */ + char d_name[PATH_MAX+1]; +}; +typedef struct dirent dirent; + +struct DIR { + struct dirent ent; + struct _WDIR *wdirp; +}; +typedef struct DIR DIR; + + +/* Dirent functions */ +static DIR *opendir (const char *dirname); +static _WDIR *_wopendir (const wchar_t *dirname); + +static struct dirent *readdir (DIR *dirp); +static struct _wdirent *_wreaddir (_WDIR *dirp); + +static int readdir_r( + DIR *dirp, struct dirent *entry, struct dirent **result); +static int _wreaddir_r( + _WDIR *dirp, struct _wdirent *entry, struct _wdirent **result); + +static int closedir (DIR *dirp); +static int _wclosedir (_WDIR *dirp); + +static void rewinddir (DIR* dirp); +static void _wrewinddir (_WDIR* dirp); + +static int scandir (const char *dirname, struct dirent ***namelist, + int (*filter)(const struct dirent*), + int (*compare)(const struct dirent**, const struct dirent**)); + +static int alphasort (const struct dirent **a, const struct dirent **b); + +static int versionsort (const struct dirent **a, const struct dirent **b); + + +/* For compatibility with Symbian */ +#define wdirent _wdirent +#define WDIR _WDIR +#define wopendir _wopendir +#define wreaddir _wreaddir +#define wclosedir _wclosedir +#define wrewinddir _wrewinddir + + +/* Internal utility functions */ +static WIN32_FIND_DATAW *dirent_first (_WDIR *dirp); +static WIN32_FIND_DATAW *dirent_next (_WDIR *dirp); + +static int dirent_mbstowcs_s( + size_t *pReturnValue, + wchar_t *wcstr, + size_t sizeInWords, + const char *mbstr, + size_t count); + +static int dirent_wcstombs_s( + size_t *pReturnValue, + char *mbstr, + size_t sizeInBytes, + const wchar_t *wcstr, + size_t count); + +static void dirent_set_errno (int error); + + +/* + * Open directory stream DIRNAME for read and return a pointer to the + * internal working area that is used to retrieve individual directory + * entries. + */ +static _WDIR* +_wopendir( + const wchar_t *dirname) +{ + _WDIR *dirp; + DWORD n; + wchar_t *p; + + /* Must have directory name */ + if (dirname == NULL || dirname[0] == '\0') { + dirent_set_errno (ENOENT); + return NULL; + } + + /* Allocate new _WDIR structure */ + dirp = (_WDIR*) malloc (sizeof (struct _WDIR)); + if (!dirp) { + return NULL; + } + + /* Reset _WDIR structure */ + dirp->handle = INVALID_HANDLE_VALUE; + dirp->patt = NULL; + dirp->cached = 0; + + /* + * Compute the length of full path plus zero terminator + * + * Note that on WinRT there's no way to convert relative paths + * into absolute paths, so just assume it is an absolute path. + */ +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + /* Desktop */ + n = GetFullPathNameW (dirname, 0, NULL, NULL); +#else + /* WinRT */ + n = wcslen (dirname); +#endif + + /* Allocate room for absolute directory name and search pattern */ + dirp->patt = (wchar_t*) malloc (sizeof (wchar_t) * n + 16); + if (dirp->patt == NULL) { + goto exit_closedir; + } + + /* + * Convert relative directory name to an absolute one. This + * allows rewinddir() to function correctly even when current + * working directory is changed between opendir() and rewinddir(). + * + * Note that on WinRT there's no way to convert relative paths + * into absolute paths, so just assume it is an absolute path. + */ +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + /* Desktop */ + n = GetFullPathNameW (dirname, n, dirp->patt, NULL); + if (n <= 0) { + goto exit_closedir; + } +#else + /* WinRT */ + wcsncpy_s (dirp->patt, n+1, dirname, n); +#endif + + /* Append search pattern \* to the directory name */ + p = dirp->patt + n; + switch (p[-1]) { + case '\\': + case '/': + case ':': + /* Directory ends in path separator, e.g. c:\temp\ */ + /*NOP*/; + break; + + default: + /* Directory name doesn't end in path separator */ + *p++ = '\\'; + } + *p++ = '*'; + *p = '\0'; + + /* Open directory stream and retrieve the first entry */ + if (!dirent_first (dirp)) { + goto exit_closedir; + } + + /* Success */ + return dirp; + + /* Failure */ +exit_closedir: + _wclosedir (dirp); + return NULL; +} + +/* + * Read next directory entry. + * + * Returns pointer to static directory entry which may be overwritten by + * subsequent calls to _wreaddir(). + */ +static struct _wdirent* +_wreaddir( + _WDIR *dirp) +{ + struct _wdirent *entry; + + /* + * Read directory entry to buffer. We can safely ignore the return value + * as entry will be set to NULL in case of error. + */ + (void) _wreaddir_r (dirp, &dirp->ent, &entry); + + /* Return pointer to statically allocated directory entry */ + return entry; +} + +/* + * Read next directory entry. + * + * Returns zero on success. If end of directory stream is reached, then sets + * result to NULL and returns zero. + */ +static int +_wreaddir_r( + _WDIR *dirp, + struct _wdirent *entry, + struct _wdirent **result) +{ + WIN32_FIND_DATAW *datap; + + /* Read next directory entry */ + datap = dirent_next (dirp); + if (datap) { + size_t n; + DWORD attr; + + /* + * Copy file name as wide-character string. If the file name is too + * long to fit in to the destination buffer, then truncate file name + * to PATH_MAX characters and zero-terminate the buffer. + */ + n = 0; + while (n < PATH_MAX && datap->cFileName[n] != 0) { + entry->d_name[n] = datap->cFileName[n]; + n++; + } + entry->d_name[n] = 0; + + /* Length of file name excluding zero terminator */ + entry->d_namlen = n; + + /* File type */ + attr = datap->dwFileAttributes; + if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) { + entry->d_type = DT_CHR; + } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) { + entry->d_type = DT_DIR; + } else { + entry->d_type = DT_REG; + } + + /* Reset dummy fields */ + entry->d_ino = 0; + entry->d_off = 0; + entry->d_reclen = sizeof (struct _wdirent); + + /* Set result address */ + *result = entry; + + } else { + + /* Return NULL to indicate end of directory */ + *result = NULL; + + } + + return /*OK*/0; +} + +/* + * Close directory stream opened by opendir() function. This invalidates the + * DIR structure as well as any directory entry read previously by + * _wreaddir(). + */ +static int +_wclosedir( + _WDIR *dirp) +{ + int ok; + if (dirp) { + + /* Release search handle */ + if (dirp->handle != INVALID_HANDLE_VALUE) { + FindClose (dirp->handle); + } + + /* Release search pattern */ + free (dirp->patt); + + /* Release directory structure */ + free (dirp); + ok = /*success*/0; + + } else { + + /* Invalid directory stream */ + dirent_set_errno (EBADF); + ok = /*failure*/-1; + + } + return ok; +} + +/* + * Rewind directory stream such that _wreaddir() returns the very first + * file name again. + */ +static void +_wrewinddir( + _WDIR* dirp) +{ + if (dirp) { + /* Release existing search handle */ + if (dirp->handle != INVALID_HANDLE_VALUE) { + FindClose (dirp->handle); + } + + /* Open new search handle */ + dirent_first (dirp); + } +} + +/* Get first directory entry (internal) */ +static WIN32_FIND_DATAW* +dirent_first( + _WDIR *dirp) +{ + WIN32_FIND_DATAW *datap; + DWORD error; + + /* Open directory and retrieve the first entry */ + dirp->handle = FindFirstFileExW( + dirp->patt, FindExInfoStandard, &dirp->data, + FindExSearchNameMatch, NULL, 0); + if (dirp->handle != INVALID_HANDLE_VALUE) { + + /* a directory entry is now waiting in memory */ + datap = &dirp->data; + dirp->cached = 1; + + } else { + + /* Failed to open directory: no directory entry in memory */ + dirp->cached = 0; + datap = NULL; + + /* Set error code */ + error = GetLastError (); + switch (error) { + case ERROR_ACCESS_DENIED: + /* No read access to directory */ + dirent_set_errno (EACCES); + break; + + case ERROR_DIRECTORY: + /* Directory name is invalid */ + dirent_set_errno (ENOTDIR); + break; + + case ERROR_PATH_NOT_FOUND: + default: + /* Cannot find the file */ + dirent_set_errno (ENOENT); + } + + } + return datap; +} + +/* + * Get next directory entry (internal). + * + * Returns + */ +static WIN32_FIND_DATAW* +dirent_next( + _WDIR *dirp) +{ + WIN32_FIND_DATAW *p; + + /* Get next directory entry */ + if (dirp->cached != 0) { + + /* A valid directory entry already in memory */ + p = &dirp->data; + dirp->cached = 0; + + } else if (dirp->handle != INVALID_HANDLE_VALUE) { + + /* Get the next directory entry from stream */ + if (FindNextFileW (dirp->handle, &dirp->data) != FALSE) { + /* Got a file */ + p = &dirp->data; + } else { + /* The very last entry has been processed or an error occurred */ + FindClose (dirp->handle); + dirp->handle = INVALID_HANDLE_VALUE; + p = NULL; + } + + } else { + + /* End of directory stream reached */ + p = NULL; + + } + + return p; +} + +/* + * Open directory stream using plain old C-string. + */ +static DIR* +opendir( + const char *dirname) +{ + struct DIR *dirp; + + /* Must have directory name */ + if (dirname == NULL || dirname[0] == '\0') { + dirent_set_errno (ENOENT); + return NULL; + } + + /* Allocate memory for DIR structure */ + dirp = (DIR*) malloc (sizeof (struct DIR)); + if (!dirp) { + return NULL; + } + { + int error; + wchar_t wname[PATH_MAX + 1]; + size_t n; + + /* Convert directory name to wide-character string */ + error = dirent_mbstowcs_s( + &n, wname, PATH_MAX + 1, dirname, PATH_MAX + 1); + if (error) { + /* + * Cannot convert file name to wide-character string. This + * occurs if the string contains invalid multi-byte sequences or + * the output buffer is too small to contain the resulting + * string. + */ + goto exit_free; + } + + + /* Open directory stream using wide-character name */ + dirp->wdirp = _wopendir (wname); + if (!dirp->wdirp) { + goto exit_free; + } + + } + + /* Success */ + return dirp; + + /* Failure */ +exit_free: + free (dirp); + return NULL; +} + +/* + * Read next directory entry. + */ +static struct dirent* +readdir( + DIR *dirp) +{ + struct dirent *entry; + + /* + * Read directory entry to buffer. We can safely ignore the return value + * as entry will be set to NULL in case of error. + */ + (void) readdir_r (dirp, &dirp->ent, &entry); + + /* Return pointer to statically allocated directory entry */ + return entry; +} + +/* + * Read next directory entry into called-allocated buffer. + * + * Returns zero on success. If the end of directory stream is reached, then + * sets result to NULL and returns zero. + */ +static int +readdir_r( + DIR *dirp, + struct dirent *entry, + struct dirent **result) +{ + WIN32_FIND_DATAW *datap; + + /* Read next directory entry */ + datap = dirent_next (dirp->wdirp); + if (datap) { + size_t n; + int error; + + /* Attempt to convert file name to multi-byte string */ + error = dirent_wcstombs_s( + &n, entry->d_name, PATH_MAX + 1, datap->cFileName, PATH_MAX + 1); + + /* + * If the file name cannot be represented by a multi-byte string, + * then attempt to use old 8+3 file name. This allows traditional + * Unix-code to access some file names despite of unicode + * characters, although file names may seem unfamiliar to the user. + * + * Be ware that the code below cannot come up with a short file + * name unless the file system provides one. At least + * VirtualBox shared folders fail to do this. + */ + if (error && datap->cAlternateFileName[0] != '\0') { + error = dirent_wcstombs_s( + &n, entry->d_name, PATH_MAX + 1, + datap->cAlternateFileName, PATH_MAX + 1); + } + + if (!error) { + DWORD attr; + + /* Length of file name excluding zero terminator */ + entry->d_namlen = n - 1; + + /* File attributes */ + attr = datap->dwFileAttributes; + if ((attr & FILE_ATTRIBUTE_DEVICE) != 0) { + entry->d_type = DT_CHR; + } else if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) { + entry->d_type = DT_DIR; + } else { + entry->d_type = DT_REG; + } + + /* Reset dummy fields */ + entry->d_ino = 0; + entry->d_off = 0; + entry->d_reclen = sizeof (struct dirent); + + } else { + + /* + * Cannot convert file name to multi-byte string so construct + * an erroneous directory entry and return that. Note that + * we cannot return NULL as that would stop the processing + * of directory entries completely. + */ + entry->d_name[0] = '?'; + entry->d_name[1] = '\0'; + entry->d_namlen = 1; + entry->d_type = DT_UNKNOWN; + entry->d_ino = 0; + entry->d_off = -1; + entry->d_reclen = 0; + + } + + /* Return pointer to directory entry */ + *result = entry; + + } else { + + /* No more directory entries */ + *result = NULL; + + } + + return /*OK*/0; +} + +/* + * Close directory stream. + */ +static int +closedir( + DIR *dirp) +{ + int ok; + if (dirp) { + + /* Close wide-character directory stream */ + ok = _wclosedir (dirp->wdirp); + dirp->wdirp = NULL; + + /* Release multi-byte character version */ + free (dirp); + + } else { + + /* Invalid directory stream */ + dirent_set_errno (EBADF); + ok = /*failure*/-1; + + } + return ok; +} + +/* + * Rewind directory stream to beginning. + */ +static void +rewinddir( + DIR* dirp) +{ + /* Rewind wide-character string directory stream */ + _wrewinddir (dirp->wdirp); +} + +/* + * Scan directory for entries. + */ +static int +scandir( + const char *dirname, + struct dirent ***namelist, + int (*filter)(const struct dirent*), + int (*compare)(const struct dirent**, const struct dirent**)) +{ + struct dirent **files = NULL; + size_t size = 0; + size_t allocated = 0; + const size_t init_size = 1; + DIR *dir = NULL; + struct dirent *entry; + struct dirent *tmp = NULL; + size_t i; + int result = 0; + + /* Open directory stream */ + dir = opendir (dirname); + if (dir) { + + /* Read directory entries to memory */ + while (1) { + + /* Enlarge pointer table to make room for another pointer */ + if (size >= allocated) { + void *p; + size_t num_entries; + + /* Compute number of entries in the enlarged pointer table */ + if (size < init_size) { + /* Allocate initial pointer table */ + num_entries = init_size; + } else { + /* Double the size */ + num_entries = size * 2; + } + + /* Allocate first pointer table or enlarge existing table */ + p = realloc (files, sizeof (void*) * num_entries); + if (p != NULL) { + /* Got the memory */ + files = (dirent**) p; + allocated = num_entries; + } else { + /* Out of memory */ + result = -1; + break; + } + + } + + /* Allocate room for temporary directory entry */ + if (tmp == NULL) { + tmp = (struct dirent*) malloc (sizeof (struct dirent)); + if (tmp == NULL) { + /* Cannot allocate temporary directory entry */ + result = -1; + break; + } + } + + /* Read directory entry to temporary area */ + if (readdir_r (dir, tmp, &entry) == /*OK*/0) { + + /* Did we get an entry? */ + if (entry != NULL) { + int pass; + + /* Determine whether to include the entry in result */ + if (filter) { + /* Let the filter function decide */ + pass = filter (tmp); + } else { + /* No filter function, include everything */ + pass = 1; + } + + if (pass) { + /* Store the temporary entry to pointer table */ + files[size++] = tmp; + tmp = NULL; + + /* Keep up with the number of files */ + result++; + } + + } else { + + /* + * End of directory stream reached => sort entries and + * exit. + */ + qsort (files, size, sizeof (void*), + (int (*) (const void*, const void*)) compare); + break; + + } + + } else { + /* Error reading directory entry */ + result = /*Error*/ -1; + break; + } + + } + + } else { + /* Cannot open directory */ + result = /*Error*/ -1; + } + + /* Release temporary directory entry */ + free (tmp); + + /* Release allocated memory on error */ + if (result < 0) { + for (i = 0; i < size; i++) { + free (files[i]); + } + free (files); + files = NULL; + } + + /* Close directory stream */ + if (dir) { + closedir (dir); + } + + /* Pass pointer table to caller */ + if (namelist) { + *namelist = files; + } + return result; +} + +/* Alphabetical sorting */ +static int +alphasort( + const struct dirent **a, const struct dirent **b) +{ + return strcoll ((*a)->d_name, (*b)->d_name); +} + +/* Sort versions */ +static int +versionsort( + const struct dirent **a, const struct dirent **b) +{ + /* FIXME: implement strverscmp and use that */ + return alphasort (a, b); +} + +/* Convert multi-byte string to wide character string */ +static int +dirent_mbstowcs_s( + size_t *pReturnValue, + wchar_t *wcstr, + size_t sizeInWords, + const char *mbstr, + size_t count) +{ + int error; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + + /* Microsoft Visual Studio 2005 or later */ + error = mbstowcs_s (pReturnValue, wcstr, sizeInWords, mbstr, count); + +#else + + /* Older Visual Studio or non-Microsoft compiler */ + size_t n; + + /* Convert to wide-character string (or count characters) */ + n = mbstowcs (wcstr, mbstr, sizeInWords); + if (!wcstr || n < count) { + + /* Zero-terminate output buffer */ + if (wcstr && sizeInWords) { + if (n >= sizeInWords) { + n = sizeInWords - 1; + } + wcstr[n] = 0; + } + + /* Length of resulting multi-byte string WITH zero terminator */ + if (pReturnValue) { + *pReturnValue = n + 1; + } + + /* Success */ + error = 0; + + } else { + + /* Could not convert string */ + error = 1; + + } + +#endif + return error; +} + +/* Convert wide-character string to multi-byte string */ +static int +dirent_wcstombs_s( + size_t *pReturnValue, + char *mbstr, + size_t sizeInBytes, /* max size of mbstr */ + const wchar_t *wcstr, + size_t count) +{ + int error; + +#if defined(_MSC_VER) && _MSC_VER >= 1400 + + /* Microsoft Visual Studio 2005 or later */ + error = wcstombs_s (pReturnValue, mbstr, sizeInBytes, wcstr, count); + +#else + + /* Older Visual Studio or non-Microsoft compiler */ + size_t n; + + /* Convert to multi-byte string (or count the number of bytes needed) */ + n = wcstombs (mbstr, wcstr, sizeInBytes); + if (!mbstr || n < count) { + + /* Zero-terminate output buffer */ + if (mbstr && sizeInBytes) { + if (n >= sizeInBytes) { + n = sizeInBytes - 1; + } + mbstr[n] = '\0'; + } + + /* Length of resulting multi-bytes string WITH zero-terminator */ + if (pReturnValue) { + *pReturnValue = n + 1; + } + + /* Success */ + error = 0; + + } else { + + /* Cannot convert string */ + error = 1; + + } + +#endif + return error; +} + +/* Set errno variable */ +static void +dirent_set_errno( + int error) +{ +#if defined(_MSC_VER) && _MSC_VER >= 1400 + + /* Microsoft Visual Studio 2005 and later */ + _set_errno (error); + +#else + + /* Non-Microsoft compiler or older Microsoft compiler */ + errno = error; + +#endif +} + + +#ifdef __cplusplus +} +#endif +#endif /*DIRENT_H*/ From 7af21ae7af57d7bf5ca3c13e2ffa7fd5c37ed698 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Wed, 21 Aug 2019 23:19:56 +0800 Subject: [PATCH 04/13] Add support for automatic removal of old logs In this commit, at the end of LogFileObject::Write, it will perform clean up for old logs. It uses GetLoggingDirectories() and for each file in each directory, it will check if a file is a log file produced by glog. If it is, and it is last modified 3 days ago, then it will unlink() this file. (It will only remove the project's own log files, it won't remove the logs from other projects.) Currently it is hardcoded to 3 days, I'll see if this can be implemented in a more flexible manner. --- src/logging.cc | 164 +++++++++++++++++++++++++++---------------------- 1 file changed, 91 insertions(+), 73 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index 7924a3139..00e4c6cc0 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -833,6 +833,91 @@ void LogDestination::DeleteLogDestinations() { sinks_ = NULL; } +namespace { + +vector SplitString(const string& s, const char delimiter) { + std::stringstream ss(s); + string t; + vector tokens; + + while (std::getline(ss, t, delimiter)) { + if (t.length() > 0) { + tokens.push_back(t); + } + } + return tokens; +} + +bool IsGlogLog(const string& log_name) { + static const int kGlogFilenameTokenCount = 6; + vector log_name_tokens = SplitString(log_name, '.'); + + if (log_name_tokens.size() < kGlogFilenameTokenCount) { + return false; + } + + // e.g., /tmp/webserver.examplehost.root.log...... + // here we should erase "/tmp/" from the first token, + // so that we can compare it with the program name later! + log_name_tokens[0].erase(0, log_name_tokens[0].find_last_of('/') + 1); // including last '/' + + // Check if log_name matches the pattern + // "...log..". + return log_name_tokens[0] == glog_internal_namespace_::ProgramInvocationShortName() + && log_name_tokens[1] == LogDestination::hostname() + && log_name_tokens[2] == MyUserName() + && log_name_tokens[3] == "log" + && (log_name_tokens[4] == "INFO" + || log_name_tokens[4] == "ERROR" + || log_name_tokens[4] == "WARNING"); +} + +bool LastModifiedOver(const string& log_name, int days) { + // Try to get the last modified time of log. + struct stat log_stat; + + if(stat(log_name.c_str(), &log_stat) == 0) { + // A day is 86400 seconds, so 7 days is 86400 * 7 = 604800 seconds. + time_t last_modified_time = log_stat.st_mtime; + time_t current_time = time(NULL); + return difftime(current_time, last_modified_time) > days * 86400; + } + + // If failed to get file stat, don't return true! + return false; +} + +vector GetOverdueLogNames(string log_directory, int days) { + // The names of overdue logs. + vector overdue_log_names; + + // Try to get all files within log_directory. + DIR *dir; + struct dirent *ent; + + // If log_directory doesn't end with a slash, append a slash to it. + if (log_directory.at(log_directory.size() - 1) != '/') { + log_directory += '/'; + } + + if ((dir=opendir(log_directory.c_str()))) { + while ((ent=readdir(dir))) { + string filename = log_directory + ent->d_name; + if (IsGlogLog(filename) && LastModifiedOver(filename, days)) { + overdue_log_names.push_back(filename); + } + } + closedir(dir); + } else { + perror("Unable to open directory."); + } + + return overdue_log_names; +} + +} // namespace + + namespace { LogFileObject::LogFileObject(LogSeverity severity, @@ -1091,7 +1176,7 @@ void LogFileObject::Write(bool force_flush, file_length_ += header_len; bytes_since_flush_ += header_len; } - + // Write to LOG file if ( !stop_writing ) { // fwrite() doesn't return an error when the disk is full, for @@ -1136,83 +1221,16 @@ void LogFileObject::Write(bool force_flush, } } #endif - } -} - -} // namespace - - -namespace { - -vector SplitString(const string& s, const char delimiter) { - std::stringstream ss(s); - string t; - vector tokens; - - while (std::getline(ss, t, delimiter)) { - if (t.length() > 0) { - tokens.push_back(t); - } - } - return tokens; -} - -bool IsGlogLog(const string& log_name) { - // Check if log_name matches the pattern "Project.Hostname.Username.log..." - static const int kGlogFilenameTokenCount = 6; - vector log_name_tokens = SplitString(log_name, '.'); - - return log_name_tokens.size() >= kGlogFilenameTokenCount - && log_name_tokens[1] == LogDestination::hostname() - && log_name_tokens[2] == MyUserName() - && log_name_tokens[3] == "log"; -} - -bool LastModifiedOver(const string& log_name, int days) { - // Try to get the last modified time of log. - struct stat log_stat; - - if(stat(log_name.c_str(), &log_stat) == 0) { - // A day is 86400 seconds, so 7 days is 86400 * 7 = 604800 seconds. - time_t last_modified_time = log_stat.st_mtime; - time_t current_time = time(NULL); - return difftime(current_time, last_modified_time) > days * 86400; - } - - // If failed to get file stat, don't return true! - return false; -} - -vector GetOverdueLogNames(string log_directory, int days) { - // The names of overdue logs. - vector overdue_log_names; - - // Try to get all files within log_directory. - DIR *dir; - struct dirent *ent; - - // If log_directory doesn't end with a slash, append a slash to it. - if (log_directory.at(log_directory.size() - 1) != '/') { - log_directory += '/'; - } - - if ((dir=opendir(log_directory.c_str()))) { - while ((ent=readdir(dir))) { - string filename = log_directory + string(ent->d_name); - if (IsGlogLog(filename) && LastModifiedOver(filename, days)) { - overdue_log_names.push_back(filename); + // Perform clean up for old logs + for (const auto& dir : GetLoggingDirectories()) { + for (const auto& name : GetOverdueLogNames(dir, 3)) { + static_cast(unlink(name.c_str())); } } - closedir(dir); - } else { - perror("Unable to open directory."); } - - return overdue_log_names; } -} // namespace - +} // namespace // Static log data space to avoid alloc failures in a LOG(FATAL) // From cbfd1e384e1aa8f5c17cbde25e941a16bf36aba9 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 00:05:13 +0800 Subject: [PATCH 05/13] Implement old log cleaner The log cleaner can be enabled and disabled at any given time. By default, the log cleaner is disabled. For example, this will enable the log cleaner and delete the log files whose last modified time is >= x days google::EnableLogCleaner(x days); To disable it, simply call google::DisableLogCleaner(); Please note that it will only clean up the logs produced for its own project, the log files from other project will be untouched. --- src/glog/logging.h.in | 5 +++++ src/logging.cc | 27 ++++++++++++++++++++++++--- 2 files changed, 29 insertions(+), 3 deletions(-) diff --git a/src/glog/logging.h.in b/src/glog/logging.h.in index 9968b96d3..365609366 100644 --- a/src/glog/logging.h.in +++ b/src/glog/logging.h.in @@ -522,6 +522,11 @@ GOOGLE_GLOG_DLL_DECL void ShutdownGoogleLogging(); // Install a function which will be called after LOG(FATAL). GOOGLE_GLOG_DLL_DECL void InstallFailureFunction(void (*fail_func)()); +// Enable/Disable old log cleaner. +GOOGLE_GLOG_DLL_DECL void EnableLogCleaner(int overdue_days); +GOOGLE_GLOG_DLL_DECL void DisableLogCleaner(); + + class LogSink; // defined below // If a non-NULL sink pointer is given, we push this message to that sink. diff --git a/src/logging.cc b/src/logging.cc index 00e4c6cc0..fd023586b 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -915,6 +915,11 @@ vector GetOverdueLogNames(string log_directory, int days) { return overdue_log_names; } +// Is log_cleaner enabled? +// This option can be enabled by calling google::EnableLogCleaner(days) +bool log_cleaner_enabled_; +int log_cleaner_overdue_days_ = 7; + } // namespace @@ -1222,9 +1227,11 @@ void LogFileObject::Write(bool force_flush, } #endif // Perform clean up for old logs - for (const auto& dir : GetLoggingDirectories()) { - for (const auto& name : GetOverdueLogNames(dir, 3)) { - static_cast(unlink(name.c_str())); + if (log_cleaner_enabled_) { + for (const auto& dir : GetLoggingDirectories()) { + for (const auto& name : GetOverdueLogNames(dir, 3)) { + static_cast(unlink(name.c_str())); + } } } } @@ -2270,4 +2277,18 @@ void ShutdownGoogleLogging() { logging_directories_list = NULL; } +void EnableLogCleaner(int overdue_days) { + log_cleaner_enabled_ = true; + + // Setting overdue_days to 0 day should not be allowed! + // Since all logs will be deleted immediately, which will cause troubles. + if (overdue_days > 0) { + log_cleaner_overdue_days_ = overdue_days; + } +} + +void DisableLogCleaner() { + log_cleaner_overdue_days_ = false; +} + _END_GOOGLE_NAMESPACE_ From 5eef96f85d5667a638f8045cd4b4abbb0fa01276 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 00:36:22 +0800 Subject: [PATCH 06/13] logging: log_cleaner: Use blackslash for windows dir delim --- src/logging.cc | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index fd023586b..d51bea1e8 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -859,7 +859,12 @@ bool IsGlogLog(const string& log_name) { // e.g., /tmp/webserver.examplehost.root.log...... // here we should erase "/tmp/" from the first token, // so that we can compare it with the program name later! - log_name_tokens[0].erase(0, log_name_tokens[0].find_last_of('/') + 1); // including last '/' + char dir_delim = '/'; +#ifdef OS_WINDOWS + dir_delim = '\\'; +#endif + + log_name_tokens[0].erase(0, log_name_tokens[0].find_last_of(dir_delim) + 1); // including last '/' // Check if log_name matches the pattern // "...log..". @@ -895,9 +900,14 @@ vector GetOverdueLogNames(string log_directory, int days) { DIR *dir; struct dirent *ent; + char dir_delim = '/'; +#ifdef OS_WINDOWS + dir_delim = '\\'; +#endif + // If log_directory doesn't end with a slash, append a slash to it. - if (log_directory.at(log_directory.size() - 1) != '/') { - log_directory += '/'; + if (log_directory.at(log_directory.size() - 1) != dir_delim) { + log_directory += dir_delim; } if ((dir=opendir(log_directory.c_str()))) { From b8a61d70834977d18a524fc849ada2f6dea0d189 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 00:40:31 +0800 Subject: [PATCH 07/13] logging: log_cleaner: remove the range-based loops Also replaced the hardcoded overdue days with the correct variable. --- src/logging.cc | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index d51bea1e8..0aeb74e3b 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -1238,9 +1238,11 @@ void LogFileObject::Write(bool force_flush, #endif // Perform clean up for old logs if (log_cleaner_enabled_) { - for (const auto& dir : GetLoggingDirectories()) { - for (const auto& name : GetOverdueLogNames(dir, 3)) { - static_cast(unlink(name.c_str())); + const vector& dirs = GetLoggingDirectories(); + for (size_t i = 0; i < dirs.size(); i++) { + vector logs = GetOverdueLogNames(dirs[i], log_cleaner_overdue_days_); + for (size_t j = 0; j < logs.size(); j++) { + static_cast(unlink(logs[j].c_str())); } } } From 6dc3e0fa4a3421d87a9e64e41d781f60f3b89a3d Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 07:36:00 +0800 Subject: [PATCH 08/13] Add Marco Wang to AUTHORS and CONTRIBUTORS --- AUTHORS | 1 + CONTRIBUTORS | 1 + 2 files changed, 2 insertions(+) diff --git a/AUTHORS b/AUTHORS index e5111cea7..1780c12ba 100644 --- a/AUTHORS +++ b/AUTHORS @@ -15,6 +15,7 @@ Andy Ying Brian Silverman Google Inc. Guillaume Dumont +Marco Wang Michael Tanner MiniLight romange diff --git a/CONTRIBUTORS b/CONTRIBUTORS index d63f62d16..e38fd189a 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -32,6 +32,7 @@ Guillaume Dumont Håkan L. S. Younes Ivan Penkov Jim Ray +Marco Wang Michael Tanner MiniLight Peter Collingbourne From 6cb55b23040ca26132e3ffd5ddd27f3220665909 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 15:15:35 +0800 Subject: [PATCH 09/13] logging: log_cleaner: Remove redundant filename stripping Previously the full path to a file is passed into IsGlogLog(), and then std::string::erase() is used to get the filename part. If a directory name contains '.', then this function will be unreliable. Now only the filename it self is passed into IsGlogLog(), so this problem will be eradicated. --- src/logging.cc | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index 0aeb74e3b..2c2a21318 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -856,16 +856,6 @@ bool IsGlogLog(const string& log_name) { return false; } - // e.g., /tmp/webserver.examplehost.root.log...... - // here we should erase "/tmp/" from the first token, - // so that we can compare it with the program name later! - char dir_delim = '/'; -#ifdef OS_WINDOWS - dir_delim = '\\'; -#endif - - log_name_tokens[0].erase(0, log_name_tokens[0].find_last_of(dir_delim) + 1); // including last '/' - // Check if log_name matches the pattern // "...log..". return log_name_tokens[0] == glog_internal_namespace_::ProgramInvocationShortName() @@ -913,7 +903,7 @@ vector GetOverdueLogNames(string log_directory, int days) { if ((dir=opendir(log_directory.c_str()))) { while ((ent=readdir(dir))) { string filename = log_directory + ent->d_name; - if (IsGlogLog(filename) && LastModifiedOver(filename, days)) { + if (IsGlogLog(ent->d_name) && LastModifiedOver(filename, days)) { overdue_log_names.push_back(filename); } } From 3d715d7d0292a2d9dc3fc486edb66c0eb127fae5 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 20:05:24 +0800 Subject: [PATCH 10/13] logging: log_cleaner: improve readability --- src/logging.cc | 41 ++++++++++++++++++++++------------------- 1 file changed, 22 insertions(+), 19 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index 2c2a21318..afba7c257 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -848,32 +848,32 @@ vector SplitString(const string& s, const char delimiter) { return tokens; } -bool IsGlogLog(const string& log_name) { +bool IsGlogLog(const string& filename) { static const int kGlogFilenameTokenCount = 6; - vector log_name_tokens = SplitString(log_name, '.'); + vector filename_tokens = SplitString(filename, '.'); - if (log_name_tokens.size() < kGlogFilenameTokenCount) { + if (filename_tokens.size() < kGlogFilenameTokenCount) { return false; } - // Check if log_name matches the pattern + // Check if filename matches the pattern of a glog file: // "...log..". - return log_name_tokens[0] == glog_internal_namespace_::ProgramInvocationShortName() - && log_name_tokens[1] == LogDestination::hostname() - && log_name_tokens[2] == MyUserName() - && log_name_tokens[3] == "log" - && (log_name_tokens[4] == "INFO" - || log_name_tokens[4] == "ERROR" - || log_name_tokens[4] == "WARNING"); + return filename_tokens[0] == glog_internal_namespace_::ProgramInvocationShortName() + && filename_tokens[1] == LogDestination::hostname() + && filename_tokens[2] == MyUserName() + && filename_tokens[3] == "log" + && (filename_tokens[4] == "INFO" + || filename_tokens[4] == "ERROR" + || filename_tokens[4] == "WARNING"); } -bool LastModifiedOver(const string& log_name, int days) { - // Try to get the last modified time of log. - struct stat log_stat; +bool LastModifiedOver(const string& filepath, int days) { + // Try to get the last modified time of this file. + struct stat file_stat; - if(stat(log_name.c_str(), &log_stat) == 0) { + if (stat(filepath.c_str(), &file_stat) == 0) { // A day is 86400 seconds, so 7 days is 86400 * 7 = 604800 seconds. - time_t last_modified_time = log_stat.st_mtime; + time_t last_modified_time = file_stat.st_mtime; time_t current_time = time(NULL); return difftime(current_time, last_modified_time) > days * 86400; } @@ -902,9 +902,12 @@ vector GetOverdueLogNames(string log_directory, int days) { if ((dir=opendir(log_directory.c_str()))) { while ((ent=readdir(dir))) { - string filename = log_directory + ent->d_name; - if (IsGlogLog(ent->d_name) && LastModifiedOver(filename, days)) { - overdue_log_names.push_back(filename); + if (!strcmp(ent->d_name, ".") || !strcmp(ent->d_name, "..")) { + continue; + } + string filepath = log_directory + ent->d_name; + if (IsGlogLog(ent->d_name) && LastModifiedOver(filepath, days)) { + overdue_log_names.push_back(filepath); } } closedir(dir); From 41364032856a003e1f49d66e7de1f485735a3930 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 21:18:23 +0800 Subject: [PATCH 11/13] Add google::EnableLogCleaner() to windows logging.h --- src/windows/glog/logging.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/windows/glog/logging.h b/src/windows/glog/logging.h index 3681fa3fc..1e9a59352 100755 --- a/src/windows/glog/logging.h +++ b/src/windows/glog/logging.h @@ -526,6 +526,11 @@ GOOGLE_GLOG_DLL_DECL void ShutdownGoogleLogging(); // Install a function which will be called after LOG(FATAL). GOOGLE_GLOG_DLL_DECL void InstallFailureFunction(void (*fail_func)()); +// Enable/Disable old log cleaner. +GOOGLE_GLOG_DLL_DECL void EnableLogCleaner(int overdue_days); +GOOGLE_GLOG_DLL_DECL void DisableLogCleaner(); + + class LogSink; // defined below // If a non-NULL sink pointer is given, we push this message to that sink. From a1a9dc8912c48e93a2bbda5e275ade9a8a9e1c94 Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 21:19:48 +0800 Subject: [PATCH 12/13] logging: log_cleaner: Remove perror message --- src/logging.cc | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index afba7c257..732da328f 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -911,8 +911,6 @@ vector GetOverdueLogNames(string log_directory, int days) { } } closedir(dir); - } else { - perror("Unable to open directory."); } return overdue_log_names; From 77a1f39c819c7ae516bc2fd8e57a5db827420f7c Mon Sep 17 00:00:00 2001 From: Marco Wang Date: Thu, 22 Aug 2019 21:53:31 +0800 Subject: [PATCH 13/13] logging: IsGlogLog: match filename keyword by keyword Splitting a filename into tokens by '.' causes problems if the executable's filename contains a dot. Filename should be matched keyword by keyword in the following order: 1. program name 2. hostname 3. username 4. "log" --- src/logging.cc | 43 ++++++++++++++++--------------------------- 1 file changed, 16 insertions(+), 27 deletions(-) diff --git a/src/logging.cc b/src/logging.cc index 732da328f..23eee3c88 100644 --- a/src/logging.cc +++ b/src/logging.cc @@ -835,36 +835,25 @@ void LogDestination::DeleteLogDestinations() { namespace { -vector SplitString(const string& s, const char delimiter) { - std::stringstream ss(s); - string t; - vector tokens; - - while (std::getline(ss, t, delimiter)) { - if (t.length() > 0) { - tokens.push_back(t); - } - } - return tokens; -} - bool IsGlogLog(const string& filename) { - static const int kGlogFilenameTokenCount = 6; - vector filename_tokens = SplitString(filename, '.'); + // Check if filename matches the pattern of a glog file: + // "...log...". + const int kKeywordCount = 4; + std::string keywords[kKeywordCount] = { + glog_internal_namespace_::ProgramInvocationShortName(), + LogDestination::hostname(), + MyUserName(), + "log" + }; - if (filename_tokens.size() < kGlogFilenameTokenCount) { - return false; + int start_pos = 0; + for (int i = 0; i < kKeywordCount; i++) { + if (filename.find(keywords[i], start_pos) == filename.npos) { + return false; + } + start_pos += keywords[i].size() + 1; } - - // Check if filename matches the pattern of a glog file: - // "...log..". - return filename_tokens[0] == glog_internal_namespace_::ProgramInvocationShortName() - && filename_tokens[1] == LogDestination::hostname() - && filename_tokens[2] == MyUserName() - && filename_tokens[3] == "log" - && (filename_tokens[4] == "INFO" - || filename_tokens[4] == "ERROR" - || filename_tokens[4] == "WARNING"); + return true; } bool LastModifiedOver(const string& filepath, int days) {