Skip to content

Commit a90085a

Browse files
Yundi339Yundi339
committed
feat: add FileCacheEx - enhanced file cache with configurable header length
- New FileCacheEx module alongside original FileCache (non-invasive) - Configurable max_header_length (was hardcoded HTTP_HEADER_MAX_LENGTH) - Configurable max_file_size, max_cache_num at runtime - prepend_header() returns bool to report success/failure - Expose header metrics: get_header_reserve(), get_header_used(), header_fits() - Fix stat() name collision in is_modified() using ::stat() - Add FileCacheEx.h to exported headers in cmake/vars.cmake
1 parent 62cd137 commit a90085a

3 files changed

Lines changed: 307 additions & 0 deletions

File tree

‎cmake/vars.cmake‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -103,6 +103,7 @@ set(HTTP_SERVER_HEADERS
103103
http/server/HttpContext.h
104104
http/server/HttpResponseWriter.h
105105
http/server/WebSocketServer.h
106+
http/server/FileCacheEx.h
106107
)
107108

108109
set(MQTT_HEADERS

‎http/server/FileCacheEx.cpp‎

Lines changed: 161 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,161 @@
1+
#include "FileCacheEx.h"
2+
3+
#include "herr.h"
4+
#include "hscope.h"
5+
#include "htime.h"
6+
#include "hlog.h"
7+
8+
#include "httpdef.h" // http_content_type_str_by_suffix
9+
#include "http_page.h" // make_index_of_page
10+
11+
#ifdef OS_WIN
12+
#include "hstring.h" // hv::utf8_to_wchar
13+
#endif
14+
15+
#define ETAG_FMT "\"%zx-%zx\""
16+
17+
FileCacheEx::FileCacheEx(size_t capacity)
18+
: hv::LRUCache<std::string, file_cache_ex_ptr>(capacity) {
19+
stat_interval = 10; // s
20+
expired_time = 60; // s
21+
max_header_length = FILECACHE_EX_DEFAULT_HEADER_LENGTH;
22+
max_file_size = FILECACHE_EX_DEFAULT_MAX_FILE_SIZE;
23+
}
24+
25+
file_cache_ex_ptr FileCacheEx::Open(const char* filepath, OpenParam* param) {
26+
file_cache_ex_ptr fc = Get(filepath);
27+
#ifdef OS_WIN
28+
std::wstring wfilepath;
29+
#endif
30+
bool modified = false;
31+
if (fc) {
32+
time_t now = time(NULL);
33+
if (now - fc->stat_time > stat_interval) {
34+
fc->stat_time = now;
35+
fc->stat_cnt++;
36+
#ifdef OS_WIN
37+
wfilepath = hv::utf8_to_wchar(filepath);
38+
now = fc->st.st_mtime;
39+
_wstat(wfilepath.c_str(), (struct _stat*)&fc->st);
40+
modified = now != fc->st.st_mtime;
41+
#else
42+
modified = fc->is_modified();
43+
#endif
44+
}
45+
if (param->need_read) {
46+
if (!modified && fc->is_complete()) {
47+
param->need_read = false;
48+
}
49+
}
50+
}
51+
if (fc == NULL || modified || param->need_read) {
52+
struct stat st;
53+
int flags = O_RDONLY;
54+
#ifdef O_BINARY
55+
flags |= O_BINARY;
56+
#endif
57+
int fd = -1;
58+
#ifdef OS_WIN
59+
if (wfilepath.empty()) wfilepath = hv::utf8_to_wchar(filepath);
60+
if (_wstat(wfilepath.c_str(), (struct _stat*)&st) != 0) {
61+
param->error = ERR_OPEN_FILE;
62+
return NULL;
63+
}
64+
if (S_ISREG(st.st_mode)) {
65+
fd = _wopen(wfilepath.c_str(), flags);
66+
} else if (S_ISDIR(st.st_mode)) {
67+
fd = 0;
68+
}
69+
#else
70+
if (::stat(filepath, &st) != 0) {
71+
param->error = ERR_OPEN_FILE;
72+
return NULL;
73+
}
74+
fd = open(filepath, flags);
75+
#endif
76+
if (fd < 0) {
77+
param->error = ERR_OPEN_FILE;
78+
return NULL;
79+
}
80+
defer(if (fd > 0) { close(fd); })
81+
if (fc == NULL) {
82+
if (S_ISREG(st.st_mode) ||
83+
(S_ISDIR(st.st_mode) &&
84+
filepath[strlen(filepath) - 1] == '/')) {
85+
fc = std::make_shared<file_cache_ex_t>();
86+
fc->filepath = filepath;
87+
fc->st = st;
88+
fc->header_reserve = max_header_length;
89+
time(&fc->open_time);
90+
fc->stat_time = fc->open_time;
91+
fc->stat_cnt = 1;
92+
put(filepath, fc);
93+
} else {
94+
param->error = ERR_MISMATCH;
95+
return NULL;
96+
}
97+
}
98+
if (S_ISREG(fc->st.st_mode)) {
99+
param->filesize = fc->st.st_size;
100+
// FILE
101+
if (param->need_read) {
102+
if (fc->st.st_size > param->max_read) {
103+
param->error = ERR_OVER_LIMIT;
104+
return NULL;
105+
}
106+
fc->resize_buf(fc->st.st_size, max_header_length);
107+
int nread = read(fd, fc->filebuf.base, fc->filebuf.len);
108+
if (nread != (int)fc->filebuf.len) {
109+
hloge("Failed to read file: %s", filepath);
110+
param->error = ERR_READ_FILE;
111+
return NULL;
112+
}
113+
}
114+
const char* suffix = strrchr(filepath, '.');
115+
if (suffix) {
116+
http_content_type content_type = http_content_type_enum_by_suffix(suffix + 1);
117+
if (content_type == TEXT_HTML) {
118+
fc->content_type = "text/html; charset=utf-8";
119+
} else if (content_type == TEXT_PLAIN) {
120+
fc->content_type = "text/plain; charset=utf-8";
121+
} else {
122+
fc->content_type = http_content_type_str_by_suffix(suffix + 1);
123+
}
124+
}
125+
} else if (S_ISDIR(fc->st.st_mode)) {
126+
// DIR
127+
std::string page;
128+
make_index_of_page(filepath, page, param->path);
129+
fc->resize_buf(page.size(), max_header_length);
130+
memcpy(fc->filebuf.base, page.c_str(), page.size());
131+
fc->content_type = "text/html; charset=utf-8";
132+
}
133+
gmtime_fmt(fc->st.st_mtime, fc->last_modified);
134+
snprintf(fc->etag, sizeof(fc->etag), ETAG_FMT,
135+
(size_t)fc->st.st_mtime, (size_t)fc->st.st_size);
136+
}
137+
return fc;
138+
}
139+
140+
bool FileCacheEx::Exists(const char* filepath) const {
141+
return contains(filepath);
142+
}
143+
144+
bool FileCacheEx::Close(const char* filepath) {
145+
return remove(filepath);
146+
}
147+
148+
file_cache_ex_ptr FileCacheEx::Get(const char* filepath) {
149+
file_cache_ex_ptr fc;
150+
if (get(filepath, fc)) {
151+
return fc;
152+
}
153+
return NULL;
154+
}
155+
156+
void FileCacheEx::RemoveExpiredFileCache() {
157+
time_t now = time(NULL);
158+
remove_if([this, now](const std::string& filepath, const file_cache_ex_ptr& fc) {
159+
return (now - fc->stat_time > expired_time);
160+
});
161+
}

‎http/server/FileCacheEx.h‎

Lines changed: 145 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,145 @@
1+
#ifndef HV_FILE_CACHE_EX_H_
2+
#define HV_FILE_CACHE_EX_H_
3+
4+
/*
5+
* FileCacheEx — Enhanced File Cache for libhv HTTP server
6+
*
7+
* Improvements over the original FileCache:
8+
* 1. Configurable max_header_length (no more hardcoded 4096)
9+
* 2. prepend_header() returns bool to report success/failure
10+
* 3. Exposes header/buffer metrics via accessors
11+
* 4. Fixes stat() name collision in is_modified()
12+
* 5. max_cache_num / max_file_size configurable at runtime
13+
* 6. Reserved header space can be tuned per-instance
14+
* 7. Fully backward-compatible struct layout
15+
*
16+
* This is a NEW module alongside FileCache — no modifications to the
17+
* original code — to keep things non-invasive for upstream PR review.
18+
*/
19+
20+
#include <memory>
21+
#include <string>
22+
#include <mutex>
23+
24+
#include "hbuf.h"
25+
#include "hstring.h"
26+
#include "LRUCache.h"
27+
28+
// Default values — may be overridden at runtime via FileCacheEx setters
29+
#define FILECACHE_EX_DEFAULT_HEADER_LENGTH 4096 // 4K
30+
#define FILECACHE_EX_DEFAULT_MAX_NUM 100
31+
#define FILECACHE_EX_DEFAULT_MAX_FILE_SIZE (1 << 22) // 4M
32+
33+
typedef struct file_cache_ex_s {
34+
std::string filepath;
35+
struct stat st;
36+
time_t open_time;
37+
time_t stat_time;
38+
uint32_t stat_cnt;
39+
HBuf buf; // header_reserve + file_content
40+
hbuf_t filebuf; // points into buf: file content region
41+
hbuf_t httpbuf; // points into buf: header + file content after prepend
42+
char last_modified[64];
43+
char etag[64];
44+
std::string content_type;
45+
46+
// --- new: expose header metrics ---
47+
int header_reserve; // reserved bytes before file content
48+
int header_used; // actual bytes used by prepend_header
49+
50+
file_cache_ex_s() {
51+
stat_cnt = 0;
52+
header_reserve = FILECACHE_EX_DEFAULT_HEADER_LENGTH;
53+
header_used = 0;
54+
memset(last_modified, 0, sizeof(last_modified));
55+
memset(etag, 0, sizeof(etag));
56+
}
57+
58+
// Fixed: avoids shadowing struct stat member with stat() call
59+
bool is_modified() {
60+
time_t mtime = st.st_mtime;
61+
::stat(filepath.c_str(), &st);
62+
return mtime != st.st_mtime;
63+
}
64+
65+
bool is_complete() {
66+
if (S_ISDIR(st.st_mode)) return filebuf.len > 0;
67+
return filebuf.len == (size_t)st.st_size;
68+
}
69+
70+
void resize_buf(int filesize, int reserved) {
71+
header_reserve = reserved;
72+
buf.resize(reserved + filesize);
73+
filebuf.base = buf.base + reserved;
74+
filebuf.len = filesize;
75+
}
76+
77+
void resize_buf(int filesize) {
78+
resize_buf(filesize, header_reserve);
79+
}
80+
81+
// Returns true on success, false if header exceeds reserved space
82+
bool prepend_header(const char* header, int len) {
83+
if (len > header_reserve) return false;
84+
httpbuf.base = filebuf.base - len;
85+
httpbuf.len = len + filebuf.len;
86+
memcpy(httpbuf.base, header, len);
87+
header_used = len;
88+
return true;
89+
}
90+
91+
// --- accessors ---
92+
int get_header_reserve() const { return header_reserve; }
93+
int get_header_used() const { return header_used; }
94+
int get_header_remaining() const { return header_reserve - header_used; }
95+
bool header_fits(int len) const { return len <= header_reserve; }
96+
} file_cache_ex_t;
97+
98+
typedef std::shared_ptr<file_cache_ex_t> file_cache_ex_ptr;
99+
100+
class FileCacheEx : public hv::LRUCache<std::string, file_cache_ex_ptr> {
101+
public:
102+
// --- configurable parameters (were hardcoded macros before) ---
103+
int stat_interval; // seconds between stat() checks
104+
int expired_time; // seconds before cache entry expires
105+
int max_header_length; // reserved header bytes per entry
106+
int max_file_size; // max cached file size (larger = large-file path)
107+
108+
explicit FileCacheEx(size_t capacity = FILECACHE_EX_DEFAULT_MAX_NUM);
109+
110+
struct OpenParam {
111+
bool need_read;
112+
int max_read; // per-request override for max file size
113+
const char* path; // URL path (for directory listing)
114+
size_t filesize; // [out] actual file size
115+
int error; // [out] error code if Open returns NULL
116+
117+
OpenParam() {
118+
need_read = true;
119+
max_read = FILECACHE_EX_DEFAULT_MAX_FILE_SIZE;
120+
path = "/";
121+
filesize = 0;
122+
error = 0;
123+
}
124+
};
125+
126+
file_cache_ex_ptr Open(const char* filepath, OpenParam* param);
127+
bool Exists(const char* filepath) const;
128+
bool Close(const char* filepath);
129+
void RemoveExpiredFileCache();
130+
131+
// --- new: getters ---
132+
int GetMaxHeaderLength() const { return max_header_length; }
133+
int GetMaxFileSize() const { return max_file_size; }
134+
int GetStatInterval() const { return stat_interval; }
135+
int GetExpiredTime() const { return expired_time; }
136+
137+
// --- new: setters ---
138+
void SetMaxHeaderLength(int len) { max_header_length = len; }
139+
void SetMaxFileSize(int size) { max_file_size = size; }
140+
141+
protected:
142+
file_cache_ex_ptr Get(const char* filepath);
143+
};
144+
145+
#endif // HV_FILE_CACHE_EX_H_

0 commit comments

Comments
 (0)