Navigation

← Previous Changeset
Next Changeset →

Changeset 1785

Timestamp:

08/12/08 19:11:49 (3 months ago)

Author:

alo

Message:

--

Files:

cherokee/trunk/ChangeLog (modified) (1 diff)
cherokee/trunk/admin/PageVServer.py (modified) (4 diffs)
cherokee/trunk/admin/pyscgi.py (modified) (1 diff)
cherokee/trunk/cherokee/connection.c (modified) (1 diff)
cherokee/trunk/cherokee/logger_ncsa.c (modified) (3 diffs)
cherokee/trunk/cherokee/logger_w3c.c (modified) (5 diffs)
cherokee/trunk/cherokee/logger_writer.c (modified) (8 diffs)
cherokee/trunk/cherokee/logger_writer.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

cherokee/trunk/ChangeLog

r1784	r1785
1	1	2008-08-12 Alvaro Lopez Ortega <alvaro@alobbs.com>
	2
	3	* cherokee/logger_writer.c, cherokee/logger_writer.h,
	4	cherokee/logger_w3c.c, cherokee/logger_ncsa.c,
	5	cherokee/connection.c, admin/PageVServer.py: This multipuorpose
	6	patch clean up the logger writter class, and fixes the W3C support
	7	in the administration interface. It fixes:
	8	http://code.google.com/p/cherokee/issues/detail?id=89
2	9
3	10	* admin/pyscgi.py, admin/server.py, admin/Page.py,

cherokee/trunk/admin/PageVServer.py

r1733	r1785
14	14	("vserver!.*?!ssl_certificate_key_file", (validations.is_local_file_exists, 'cfg')),
15	15	("vserver!.*?!ssl_ca_list_file", (validations.is_local_file_exists, 'cfg')),
16		("vserver!.*?!logger!access!filename", (validations.parent_is_dir, 'cfg')),
17		("vserver!.*?!logger!error!filename", (validations.parent_is_dir, 'cfg')),
18		("vserver!.*?!logger!access!command", (validations.is_local_file_exists, 'cfg')),
19		("vserver!.*?!logger!error!command", (validations.is_local_file_exists, 'cfg')),
	16	("vserver!.?!logger!.?!filename", (validations.parent_is_dir, 'cfg')),
	17	("vserver!.?!logger!.?!command", (validations.is_local_file_exists, 'cfg')),
20	18	]
21	19
…	…
38	36	NOTE_ACCESSES = 'Back-end used to store the log accesses.'
39	37	NOTE_ERRORS = 'Back-end used to store the log errors.'
	38	NOTE_ACCESSES_ERRORS = 'Back-end used to store the log accesses and errors.'
40	39	NOTE_WRT_FILE = 'Full path to the file where the information will be saved.'
41	40	NOTE_WRT_EXEC = 'Path to the executable that will be invoked on each log entry.'
…	…
356	355	pre = 'vserver!%s!logger'%(host)
357	356	cfg = self._cfg[pre]
	357	format = self._cfg.get_val(pre)
358	358	if cfg and cfg.has_child():
359	359	table = TableProps()
…	…
372	372
373	373	# Writers
374		if self._cfg.get_val(pre):
	374
	375	if format:
375	376	writers = ''
376	377
377		# Accesses
378		cfg_key = "%s!access!type"%(pre)
379		table = TableProps()
380		self.AddPropOptions_Ajax (table, 'Accesses', cfg_key, LOGGER_WRITERS, NOTE_ACCESSES)
381		writers += str(table)
382
383		access = self._cfg.get_val(cfg_key)
384		if not access or access == 'file':
385		t1 = TableProps()
386		self.AddPropEntry (t1, 'Filename', '%s!access!filename'%(pre), NOTE_WRT_FILE)
387		writers += str(t1)
388		elif access == 'exec':
389		t1 = TableProps()
390		self.AddPropEntry (t1, 'Command', '%s!access!command'%(pre), NOTE_WRT_EXEC)
391		writers += str(t1)
392
393		writers += "<hr />"
394
395		# Error
396		cfg_key = "%s!error!type"%(pre)
397		table = TableProps()
398		self.AddPropOptions_Ajax (table, 'Errors', cfg_key, LOGGER_WRITERS, NOTE_ERRORS)
399		writers += str(table)
400
401		error = self._cfg.get_val(cfg_key)
402		if not error or error == 'file':
403		t1 = TableProps()
404		self.AddPropEntry (t1, 'Filename', '%s!error!filename'%(pre), NOTE_WRT_FILE)
405		writers += str(t1)
406		elif error == 'exec':
407		t1 = TableProps()
408		self.AddPropEntry (t1, 'Command', '%s!error!command'%(pre), NOTE_WRT_EXEC)
409		writers += str(t1)
	378	# Accesses & Error together
	379	if format == 'w3c':
	380	cfg_key = "%s!all!type"%(pre)
	381	table = TableProps()
	382	self.AddPropOptions_Ajax (table, 'Accesses and Errors', cfg_key,
	383	LOGGER_WRITERS, NOTE_ACCESSES_ERRORS)
	384	writers += str(table)
	385
	386	all = self._cfg.get_val(cfg_key)
	387	if not all or all == 'file':
	388	t1 = TableProps()
	389	self.AddPropEntry (t1, 'Filename', '%s!all!filename'%(pre), NOTE_WRT_FILE)
	390	writers += str(t1)
	391	elif all == 'exec':
	392	t1 = TableProps()
	393	self.AddPropEntry (t1, 'Command', '%s!all!command'%(pre), NOTE_WRT_EXEC)
	394	writers += str(t1)
	395
	396	else:
	397	# Accesses
	398	cfg_key = "%s!access!type"%(pre)
	399	table = TableProps()
	400	self.AddPropOptions_Ajax (table, 'Accesses', cfg_key, LOGGER_WRITERS, NOTE_ACCESSES)
	401	writers += str(table)
	402
	403	access = self._cfg.get_val(cfg_key)
	404	if not access or access == 'file':
	405	t1 = TableProps()
	406	self.AddPropEntry (t1, 'Filename', '%s!access!filename'%(pre), NOTE_WRT_FILE)
	407	writers += str(t1)
	408	elif access == 'exec':
	409	t1 = TableProps()
	410	self.AddPropEntry (t1, 'Command', '%s!access!command'%(pre), NOTE_WRT_EXEC)
	411	writers += str(t1)
	412
	413	writers += "<hr />"
	414
	415	# Error
	416	cfg_key = "%s!error!type"%(pre)
	417	table = TableProps()
	418	self.AddPropOptions_Ajax (table, 'Errors', cfg_key, LOGGER_WRITERS, NOTE_ERRORS)
	419	writers += str(table)
	420
	421	error = self._cfg.get_val(cfg_key)
	422	if not error or error == 'file':
	423	t1 = TableProps()
	424	self.AddPropEntry (t1, 'Filename', '%s!error!filename'%(pre), NOTE_WRT_FILE)
	425	writers += str(t1)
	426	elif error == 'exec':
	427	t1 = TableProps()
	428	self.AddPropEntry (t1, 'Command', '%s!error!command'%(pre), NOTE_WRT_EXEC)
	429	writers += str(t1)
410	430
411	431	txt += '<h3>Writers</h3>'

cherokee/trunk/admin/pyscgi.py

r1784	r1785
54	54	def __safe_read (self, lenght):
55	55	while True:
	56	chunk = None
56	57	try:
57	58	chunk = self.rfile.read(lenght)

cherokee/trunk/cherokee/connection.c

r1766	r1785
1860	1860
1861	1861	ret = cherokee_logger_write_access (conn->logger_ref, conn);
1862		if (unlikely (ret != ret_ok)) return ret;
	1862	if (unlikely (ret != ret_ok))
	1863	return ret;
1863	1864
1864	1865	return ret_ok;

cherokee/trunk/cherokee/logger_ncsa.c

r1776	r1785
322	322	ret = cherokee_buffer_add (log, string, strlen(string));
323	323	if (unlikely (ret != ret_ok)) return ret;
324
	324
	325	/* Flush buffer if full
	326	*/
325	327	if (log->len < logger->writer_access.max_bufsize)
326	328	return ret_ok;
327	329
328		~~/* Buffer is full, flush it!~~
329		*/
330	330	ret = cherokee_logger_writer_flush (&logger->writer_access);
331
332		return ret;
	331	if (unlikely (ret != ret_ok))
	332	return ret;
	333
	334	return ret_ok;
333	335	}
334	336
…	…
350	352	if (unlikely (ret != ret_ok)) return ret;
351	353
	354	/* Flush buffer if full
	355	*/
352	356	if (log->len < logger->writer_access.max_bufsize)
353	357	return ret_ok;
354	358
355		~~/* Buffer is full, flush it!~~
356		*/
357	359	ret = cherokee_logger_writer_flush (&logger->writer_access);
358
359		return ret;
	360	if (unlikely (ret != ret_ok))
	361	return ret;
	362
	363	return ret_ok;
360	364	}
361	365
…	…
380	384	*/
381	385	ret = cherokee_logger_writer_flush (&logger->writer_error);
382
383		return ret;
	386	if (unlikely (ret != ret_ok))
	387	return ret;
	388
	389	return ret_ok;
384	390	}
385	391

cherokee/trunk/cherokee/logger_w3c.c

r1131	r1785
129	129
130	130
131
132	131	ret_t
133	132	cherokee_logger_w3c_init (cherokee_logger_w3c_t *logger)
…	…
168	167
169	168	ret_t
170		cherokee_logger_w3c_write_error (cherokee_logger_w3c_t logger, cherokee_connection_t cnt)
	169	cherokee_logger_w3c_write_error (cherokee_logger_w3c_t logger, cherokee_connection_t cnt)
171	170	{
172	171	ret_t ret;
…	…
230	229	cherokee_buffer_add_char (log, '\n');
231	230
232		if (log->len < logger->writer.max_bufsize)
233		return ret_ok;
234
235		/* Buffer is full, flush it!
236		*/
	231	/* Error are not buffered
	232	*/
237	233	ret = cherokee_logger_writer_flush (&logger->writer);
238
239		return ret;
	234	if (unlikely (ret != ret_ok))
	235	return ret;
	236
	237	return ret_ok;
240	238	}
241	239
…	…
253	251	if (unlikely (ret != ret_ok)) return ret;
254	252
	253	/* Flush buffer if full
	254	*/
255	255	if (log->len < logger->writer.max_bufsize)
256	256	return ret_ok;
257	257
258		~~/* Buffer is full, flush it!~~
259		*/
260	258	ret = cherokee_logger_writer_flush (&logger->writer);
261
262		return ret;
	259	if (unlikely (ret != ret_ok))
	260	return ret;
	261
	262	return ret_ok;
263	263	}
264	264
…	…
325	325	cherokee_buffer_add_char (log, '\n');
326	326
327		if (log->len < logger->writer.max_bufsize)
328		return ret_ok;
329
330		/* Buffer is full, flush it!
331		*/
332		ret = cherokee_logger_writer_flush (&logger->writer);
333
334		return ret;
335		}
336
	327	return ret_ok;
	328	}
	329

cherokee/trunk/cherokee/logger_writer.c

r1754	r1785
46	46	cherokee_logger_writer_init (cherokee_logger_writer_t *writer)
47	47	{
48		writer->type = cherokee_logger_writer_syslog;
49		writer->fd = -1;
	48	writer->type = cherokee_logger_writer_syslog;
	49	writer->fd = -1;
50	50	writer->max_bufsize = DEFAULT_LOGGER_MAX_BUFSIZE;
51	51
…	…
54	54	cherokee_buffer_init (&writer->buffer);
55	55
56		cherokee_buffer_ensure_size (&writer->buffer, writer->max_bufsize ~~+ LOGGER_OVF_BUFSIZE~~);
	56	cherokee_buffer_ensure_size (&writer->buffer, writer->max_bufsize);
57	57
58	58	return ret_ok;
…	…
63	63	logger_writer_close_file (cherokee_logger_writer_t *writer)
64	64	{
65		ret_t ret = ret_ok;
	65	ret_t ret = ret_ok;
66	66
67	67	if (writer->fd != -1) {
68		~~/* Don't close file if it is stderr~~
69		*/
70	68	if (writer->type != cherokee_logger_writer_stderr) {
71		if (close (writer->fd) != 0)
	69	if (cherokee_fd_close (writer->fd) != 0)
72	70	ret = ret_error;
73	71	}
…	…
97	95	{
98	96	ret_t ret;
99		int ival = 0;
100		cherokee_buffer_t *tmp = NULL;
101		cherokee_buffer_t *tmp2 = NULL;
	97	cherokee_buffer_t *tmp = NULL;
102	98
103	99	/* Check the type
…	…
108	104	return ret_ok;
109	105	}
110
	106
111	107	if (equal_buf_str (tmp, "syslog")) {
112	108	writer->type = cherokee_logger_writer_syslog;
113
114	109	} else if (equal_buf_str (tmp, "stderr")) {
115	110	writer->type = cherokee_logger_writer_stderr;
116
117	111	} else if (equal_buf_str (tmp, "file")) {
118		writer->type = cherokee_logger_writer_file;
119
	112	writer->type = cherokee_logger_writer_file;
	113	} else if (equal_buf_str (tmp, "exec")) {
	114	writer->type = cherokee_logger_writer_pipe;
	115	} else {
	116	PRINT_MSG ("Unknown logger writer type '%s'\n", tmp->buf);
	117	return ret_error;
	118	}
	119
	120	/* Extra properties
	121	*/
	122	switch (writer->type) {
	123	case cherokee_logger_writer_file:
120	124	ret = cherokee_config_node_read (config, "filename", &tmp);
121	125	if (ret != ret_ok) {
…	…
124	128	}
125	129	cherokee_buffer_add_buffer (&writer->filename, tmp);
126
127		} else if (equal_buf_str (tmp, "exec")) {
128		writer->type = cherokee_logger_writer_pipe;
129
	130	break;
	131
	132	case cherokee_logger_writer_pipe:
130	133	ret = cherokee_config_node_read (config, "command", &tmp);
131	134	if (ret != ret_ok) {
…	…
134	137	}
135	138	cherokee_buffer_add_buffer (&writer->command, tmp);
136
137		} else {
138		PRINT_MSG ("Unknown logger writer type '%s'\n", tmp->buf);
139		return ret_error;
140		}
141
142		/* Read buffer size (bytes)
143		*/
144		ret = cherokee_config_node_read (config, "bufsize", &tmp2);
145		if (ret != ret_ok) {
146		/* Item not found, but it's OK because it is optional.
147		*/
148		return ret_ok;
149		}
150
151		if (cherokee_buffer_is_empty (tmp2))
152		return ret_ok;
153
154		ival = atoi (tmp2->buf);
155		if (ival <= 0) {
156		ival = 0;
157		} else {
158		/* ival > 0
159		*/
160		if (ival < LOGGER_MIN_BUFSIZE)
161		ival = LOGGER_MIN_BUFSIZE;
162		else
163		if (ival > LOGGER_MAX_BUFSIZE)
164		ival = LOGGER_MAX_BUFSIZE;
165		}
166
167		/* NOTE: nval is always >= 0 because it is unsigned
168		*/
169		if (writer->max_bufsize != (size_t) ival) {
170		/* Reallocate buffer to the new size
171		*/
	139	break;
	140	default:
	141	break;
	142	}
	143
	144	/* Reside the internal buffer if needed
	145	*/
	146	ret = cherokee_config_node_read (config, "bufsize", &tmp);
	147	if (ret == ret_ok) {
	148	int buf_len = atoi (tmp->buf);
	149
	150	if (buf_len < LOGGER_MIN_BUFSIZE)
	151	buf_len = LOGGER_MIN_BUFSIZE;
	152	else if (buf_len > LOGGER_MAX_BUFSIZE)
	153	buf_len = LOGGER_MAX_BUFSIZE;
	154
172	155	cherokee_buffer_mrproper (&writer->buffer);
173		writer->max_bufsize = (size_t) ival;
174		ret = cherokee_buffer_ensure_size (
175		&writer->buffer,
176		writer->max_bufsize + LOGGER_OVF_BUFSIZE);
	156	cherokee_buffer_init (&writer->buffer);
	157
	158	ret = cherokee_buffer_ensure_size (&writer->buffer, buf_len);
177	159	if (ret != ret_ok) {
178	160	PRINT_ERROR ("Allocation logger->max_bufsize " FMT_SIZE " failed !\n",
179	161	(CST_SIZE) writer->max_bufsize);
180		/* Set log to "unbuffered".
181		*/
182		writer->max_bufsize = 0;
183		PRINT_MSG ("Set logger->writer->max_bufsize " FMT_SIZE "\n",
184		(CST_SIZE) writer->max_bufsize);
185		cherokee_buffer_ensure_size (
186		&writer->buffer,
187		writer->max_bufsize + LOGGER_OVF_BUFSIZE);
188		return ret;
189		}
	162	return ret_nomem;
	163	}
	164
	165	writer->max_bufsize = (size_t)buf_len;
190	166	}
191	167
…	…
317	293	cherokee_logger_writer_flush (cherokee_logger_writer_t *writer)
318	294	{
319		ret_t ret = ret_ok;
	295	ret_t ret = ret_ok;
320	296
321	297	/* The internal buffer might be empty

cherokee/trunk/cherokee/logger_writer.h

r1131	r1785
37	37
38	38	#define LOGGER_BUF_PAGESIZE 4096 /* page size to round down write(n) */
39		~~#define LOGGER_OVF_BUFSIZE 4096 /* buffer size = max_bufsize + value */~~
40	39
41	40	typedef enum {