Context Navigation

source: trunk/email2trac.py.in @ 304

Last change on this file since 304 was 304, checked in by bas, 14 years ago
Prevent setting the reporter to the ticket email address
Property svn:executable set to ``* Property svn:keywords set to `Id`
File size: 40.7 KB

Line
1	#!@PYTHON@
2	# Copyright (C) 2002
3	#
4	# This file is part of the email2trac utils
5	#
6	# This program is free software; you can redistribute it and/or modify it
7	# under the terms of the GNU General Public License as published by the
8	# Free Software Foundation; either version 2, or (at your option) any
9	# later version.
10	#
11	# This program is distributed in the hope that it will be useful,
12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	# GNU General Public License for more details.
15	#
16	# You should have received a copy of the GNU General Public License
17	# along with this program; if not, write to the Free Software
18	# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	#
20	# For vi/emacs or other use tabstop=4 (vi: set ts=4)
21	#
22	"""
23	email2trac.py -- Email tickets to Trac.
24
25	A simple MTA filter to create Trac tickets from inbound emails.
26
27	Copyright 2005, Daniel Lundin <daniel@edgewall.com>
28	Copyright 2005, Edgewall Software
29
30	Authors:
31	Bas van der Vlies <basv@sara.nl>
32	Walter de Jong <walter@sara.nl>
33
34	The scripts reads emails from stdin and inserts directly into a Trac database.
35
36	How to use
37	----------
38	* See https://subtrac.sara.nl/oss/email2trac/
39
40	* Create an config file:
41	[DEFAULT] # REQUIRED
42	project : /data/trac/test # REQUIRED
43	debug : 1 # OPTIONAL, if set print some DEBUG info
44	trac_version : 0.10 # OPTIONAL, default is 0.11
45
46	[jouvin] # OPTIONAL project declaration, if set both fields necessary
47	project : /data/trac/jouvin # use -p\|--project jouvin.
48
49	* default config file is : /etc/email2trac.conf
50
51	* Commandline opions:
52	-h,--help
53	-f,--file <configuration file>
54	-n,--dry-run
55	-p, --project <project name>
56	-t, --ticket_prefix <name>
57
58	SVN Info:
59	$Id: email2trac.py.in 304 2010-01-11 14:54:50Z bas $
60	"""
61	import os
62	import sys
63	import string
64	import getopt
65	import stat
66	import time
67	import email
68	import email.Iterators
69	import email.Header
70	import re
71	import urllib
72	import unicodedata
73	from stat import *
74	import mimetypes
75	import traceback
76
77
78	# Will fail where unavailable, e.g. Windows
79	#
80	try:
81	import syslog
82	SYSLOG_AVAILABLE = True
83	except ImportError:
84	SYSLOG_AVAILABLE = False
85
86	from datetime import tzinfo, timedelta, datetime
87	from trac import config as trac_config
88
89	# Some global variables
90	#
91	trac_default_version = '0.11'
92	m = None
93
94	# A UTC class needed for trac version 0.11, added by
95	# tbaschak at ktc dot mb dot ca
96	#
97	class UTC(tzinfo):
98	"""UTC"""
99	ZERO = timedelta(0)
100	HOUR = timedelta(hours=1)
101
102	def utcoffset(self, dt):
103	return self.ZERO
104
105	def tzname(self, dt):
106	return "UTC"
107
108	def dst(self, dt):
109	return self.ZERO
110
111
112	class TicketEmailParser(object):
113	env = None
114	comment = '> '
115
116	def __init__(self, env, parameters, version):
117	self.env = env
118
119	# Database connection
120	#
121	self.db = None
122
123	# Save parameters
124	#
125	self.parameters = parameters
126
127	# Some useful mail constants
128	#
129	self.email_name = None
130	self.email_addr = None
131	self.email_from = None
132	self.author = None
133	self.id = None
134
135	self.STRIP_CONTENT_TYPES = list()
136
137	self.VERSION = version
138	self.DRY_RUN = parameters['dry_run']
139
140	self.get_config = self.env.config.get
141
142	if parameters.has_key('umask'):
143	os.umask(int(parameters['umask'], 8))
144
145	if parameters.has_key('debug'):
146	self.DEBUG = int(parameters['debug'])
147	else:
148	self.DEBUG = 0
149
150	if parameters.has_key('mailto_link'):
151	self.MAILTO = int(parameters['mailto_link'])
152	if parameters.has_key('mailto_cc'):
153	self.MAILTO_CC = parameters['mailto_cc']
154	else:
155	self.MAILTO_CC = ''
156	else:
157	self.MAILTO = 0
158
159	if parameters.has_key('spam_level'):
160	self.SPAM_LEVEL = int(parameters['spam_level'])
161	else:
162	self.SPAM_LEVEL = 0
163
164	if parameters.has_key('spam_header'):
165	self.SPAM_HEADER = parameters['spam_header']
166	else:
167	self.SPAM_HEADER = 'X-Spam-Score'
168
169	if parameters.has_key('email_quote'):
170	self.EMAIL_QUOTE = str(parameters['email_quote'])
171	else:
172	self.EMAIL_QUOTE = '> '
173
174	if parameters.has_key('email_header'):
175	self.EMAIL_HEADER = int(parameters['email_header'])
176	else:
177	self.EMAIL_HEADER = 0
178
179	if parameters.has_key('alternate_notify_template'):
180	self.notify_template = str(parameters['alternate_notify_template'])
181	else:
182	self.notify_template = None
183
184	if parameters.has_key('alternate_notify_template_update'):
185	self.notify_template_update = str(parameters['alternate_notify_template_update'])
186	else:
187	self.notify_template_update = None
188
189	if parameters.has_key('reply_all'):
190	self.REPLY_ALL = int(parameters['reply_all'])
191	else:
192	self.REPLY_ALL = 0
193
194	if parameters.has_key('ticket_update'):
195	self.TICKET_UPDATE = int(parameters['ticket_update'])
196	else:
197	self.TICKET_UPDATE = 0
198
199	if parameters.has_key('drop_spam'):
200	self.DROP_SPAM = int(parameters['drop_spam'])
201	else:
202	self.DROP_SPAM = 0
203
204	if parameters.has_key('verbatim_format'):
205	self.VERBATIM_FORMAT = int(parameters['verbatim_format'])
206	else:
207	self.VERBATIM_FORMAT = 1
208
209	if parameters.has_key('reflow'):
210	self.REFLOW = int(parameters['reflow'])
211	else:
212	self.REFLOW = 1
213
214	if parameters.has_key('drop_alternative_html_version'):
215	self.DROP_ALTERNATIVE_HTML_VERSION = int(parameters['drop_alternative_html_version'])
216	else:
217	self.DROP_ALTERNATIVE_HTML_VERSION = 0
218
219	if parameters.has_key('strip_signature'):
220	self.STRIP_SIGNATURE = int(parameters['strip_signature'])
221	else:
222	self.STRIP_SIGNATURE = 0
223
224	if parameters.has_key('strip_quotes'):
225	self.STRIP_QUOTES = int(parameters['strip_quotes'])
226	else:
227	self.STRIP_QUOTES = 0
228
229	if parameters.has_key('use_textwrap'):
230	self.USE_TEXTWRAP = int(parameters['use_textwrap'])
231	else:
232	self.USE_TEXTWRAP = 0
233
234	if parameters.has_key('binhex'):
235	self.STRIP_CONTENT_TYPES.append('application/mac-binhex40')
236
237	if parameters.has_key('applesingle'):
238	self.STRIP_CONTENT_TYPES.append('application/applefile')
239
240	if parameters.has_key('appledouble'):
241	self.STRIP_CONTENT_TYPES.append('application/applefile')
242
243	if parameters.has_key('strip_content_types'):
244	items = parameters['strip_content_types'].split(',')
245	for item in items:
246	self.STRIP_CONTENT_TYPES.append(item.strip())
247
248	self.WORKFLOW = None
249	if parameters.has_key('workflow'):
250	self.WORKFLOW = parameters['workflow']
251
252	# Use OS independend functions
253	#
254	self.TMPDIR = os.path.normcase('/tmp')
255	if parameters.has_key('tmpdir'):
256	self.TMPDIR = os.path.normcase(str(parameters['tmpdir']))
257
258	if parameters.has_key('ignore_trac_user_settings'):
259	self.IGNORE_TRAC_USER_SETTINGS = int(parameters['ignore_trac_user_settings'])
260	else:
261	self.IGNORE_TRAC_USER_SETTINGS = 0
262
263	if parameters.has_key('subject_field_separator'):
264	self.SUBJECT_FIELD_SEPARATOR = parameters['subject_field_separator'].strip()
265	else:
266	self.SUBJECT_FIELD_SEPARATOR = '&'
267
268	def spam(self, message):
269	"""
270	# X-Spam-Score: *** (3.255) BAYES_50,DNS_FROM_AHBL_RHSBL,HTML_
271	# Note if Spam_level then '*' are included
272	"""
273	spam = False
274	if message.has_key(self.SPAM_HEADER):
275	spam_l = string.split(message[self.SPAM_HEADER])
276
277	try:
278	number = spam_l[0].count('*')
279	except IndexError, detail:
280	number = 0
281
282	if number >= self.SPAM_LEVEL:
283	spam = True
284
285	# treat virus mails as spam
286	#
287	elif message.has_key('X-Virus-found'):
288	spam = True
289
290	# How to handle SPAM messages
291	#
292	if self.DROP_SPAM and spam:
293	if self.DEBUG > 2 :
294	print 'This message is a SPAM. Automatic ticket insertion refused (SPAM level > %d' % self.SPAM_LEVEL
295
296	return 'drop'
297
298	elif spam:
299
300	return 'Spam'
301
302	else:
303
304	return False
305
306	def email_header_acl(self, keyword, header_field, default):
307	"""
308	This function wil check if the email address is allowed or denied
309	to send mail to the ticket list
310	"""
311	try:
312	mail_addresses = self.parameters[keyword]
313
314	# Check if we have an empty string
315	#
316	if not mail_addresses:
317	return default
318
319	except KeyError, detail:
320	if self.DEBUG > 2 :
321	print 'TD: %s not defined, all messages are allowed.' %(keyword)
322
323	return default
324
325	mail_addresses = string.split(mail_addresses, ',')
326
327	for entry in mail_addresses:
328	entry = entry.strip()
329	TO_RE = re.compile(entry, re.VERBOSE\|re.IGNORECASE)
330	result = TO_RE.search(header_field)
331	if result:
332	return True
333
334	return False
335
336	def email_to_unicode(self, message_str):
337	"""
338	Email has 7 bit ASCII code, convert it to unicode with the charset
339	that is encoded in 7-bit ASCII code and encode it as utf-8 so Trac
340	understands it.
341	"""
342	results = email.Header.decode_header(message_str)
343	s = None
344	for text,format in results:
345	if format:
346	try:
347	temp = unicode(text, format)
348	except UnicodeError, detail:
349	# This always works
350	#
351	temp = unicode(text, 'iso-8859-15')
352	except LookupError, detail:
353	#text = 'ERROR: Could not find charset: %s, please install' %format
354	#temp = unicode(text, 'iso-8859-15')
355	temp = message_str
356
357	else:
358	temp = string.strip(text)
359	temp = unicode(text, 'iso-8859-15')
360
361	if s:
362	s = '%s %s' %(s, temp)
363	else:
364	s = '%s' %temp
365
366	#s = s.encode('utf-8')
367	return s
368
369	def debug_body(self, message_body, tempfile=False):
370	if tempfile:
371	import tempfile
372	body_file = tempfile.mktemp('.email2trac')
373	else:
374	body_file = os.path.join(self.TMPDIR, 'body.txt')
375
376	print 'TD: writing body (%s)' % body_file
377	fx = open(body_file, 'wb')
378	if not message_body:
379	message_body = '(None)'
380
381	message_body = message_body.encode('utf-8')
382	#message_body = unicode(message_body, 'iso-8859-15')
383
384	fx.write(message_body)
385	fx.close()
386	try:
387	os.chmod(body_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
388	except OSError:
389	pass
390
391	def debug_attachments(self, message_parts):
392	n = 0
393	for part in message_parts:
394	# Skip inline text parts
395	if not isinstance(part, tuple):
396	continue
397
398	(original, filename, part) = part
399
400	n = n + 1
401	print 'TD: part%d: Content-Type: %s' % (n, part.get_content_type())
402	print 'TD: part%d: filename: %s' % (n, part.get_filename())
403
404	part_file = os.path.join(self.TMPDIR, filename)
405	#part_file = '/var/tmp/part%d' % n
406	print 'TD: writing part%d (%s)' % (n,part_file)
407	fx = open(part_file, 'wb')
408	text = part.get_payload(decode=1)
409	if not text:
410	text = '(None)'
411	fx.write(text)
412	fx.close()
413	try:
414	os.chmod(part_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
415	except OSError:
416	pass
417
418	def email_header_txt(self, m):
419	"""
420	Display To and CC addresses in description field
421	"""
422	s = ''
423	#if m['To'] and len(m['To']) > 0 and m['To'] != 'hic@sara.nl':
424	if m['To'] and len(m['To']) > 0:
425	s = "'''To:''' %s\r\n" %(m['To'])
426	if m['Cc'] and len(m['Cc']) > 0:
427	s = "%s'''Cc:''' %s\r\n" % (s, m['Cc'])
428
429	return self.email_to_unicode(s)
430
431
432	def get_sender_info(self, message):
433	"""
434	Get the default author name and email address from the message
435	"""
436
437	self.email_to = self.email_to_unicode(message['to'])
438	self.to_name, self.to_email_addr = email.Utils.parseaddr (self.email_to)
439
440	self.email_from = self.email_to_unicode(message['from'])
441	self.email_name, self.email_addr = email.Utils.parseaddr(self.email_from)
442
443	## Trac can not handle author's name that contains spaces
444	# and forbid the ticket email address as author field
445
446	if self.author == self.trac_smtp_from:
447	self.author = "email2trac"
448	else:
449	self.author = self.email_addr
450
451	if self.IGNORE_TRAC_USER_SETTINGS:
452	return
453
454	# Is this a registered user, use email address as search key:
455	# result:
456	# u : login name
457	# n : Name that the user has set in the settings tab
458	# e : email address that the user has set in the settings tab
459	#
460	users = [ (u,n,e) for (u, n, e) in self.env.get_known_users(self.db)
461	if e and (e.lower() == self.email_addr.lower()) ]
462
463	if len(users) == 1:
464	self.email_from = users[0][0]
465	self.author = users[0][0]
466
467	def set_reply_fields(self, ticket, message):
468	"""
469	Set all the right fields for a new ticket
470	"""
471	if self.DEBUG:
472	print 'TD: set_reply_fields'
473
474	## Only use name or email adress
475	#ticket['reporter'] = self.email_from
476	ticket['reporter'] = self.author
477
478
479	# Put all CC-addresses in ticket CC field
480	#
481	if self.REPLY_ALL:
482
483	email_cc = ''
484
485	cc_addrs = email.Utils.getaddresses( message.get_all('cc', []) )
486
487	if not cc_addrs:
488	return
489
490	## Build a list of forbidden CC addresses
491	#
492	#to_addrs = email.Utils.getaddresses( message.get_all('to', []) )
493	#to_list = list()
494	#for n,e in to_addrs:
495	# to_list.append(e)
496
497	# Remove reporter email address if notification is
498	# on
499	#
500	if self.notification:
501	try:
502	cc_addrs.remove((self.author, self.email_addr))
503	except ValueError, detail:
504	pass
505
506	for name,addr in cc_addrs:
507
508	## Prevent mail loop
509	#
510	#if addr in to_list:
511
512	if addr == self.trac_smtp_from:
513	if self.DEBUG:
514	print "Skipping %s mail address for CC-field" %(addr)
515	continue
516
517	if email_cc:
518	email_cc = '%s, %s' %(email_cc, addr)
519	else:
520	email_cc = addr
521
522	if email_cc:
523	if self.DEBUG:
524	print 'TD: set_reply_fields: %s' %email_cc
525
526	ticket['cc'] = self.email_to_unicode(email_cc)
527
528	def save_email_for_debug(self, message, tempfile=False):
529	if tempfile:
530	import tempfile
531	msg_file = tempfile.mktemp('.email2trac')
532	else:
533	#msg_file = '/var/tmp/msg.txt'
534	msg_file = os.path.join(self.TMPDIR, 'msg.txt')
535
536	print 'TD: saving email to %s' % msg_file
537	fx = open(msg_file, 'wb')
538	fx.write('%s' % message)
539	fx.close()
540	try:
541	os.chmod(msg_file,S_IRWXU\|S_IRWXG\|S_IRWXO)
542	except OSError:
543	pass
544
545	def str_to_dict(self, s):
546	"""
547	Transfrom a string of the form [<key>=<value>]+ to dict[<key>] = <value>
548	"""
549
550	fields = string.split(s, self.SUBJECT_FIELD_SEPARATOR)
551
552	result = dict()
553	for field in fields:
554	try:
555	index, value = string.split(field, '=')
556
557	# We can not change the description of a ticket via the subject
558	# line. The description is the body of the email
559	#
560	if index.lower() in ['description']:
561	continue
562
563	if value:
564	result[index.lower()] = value
565
566	except ValueError:
567	pass
568	return result
569
570	def update_ticket_fields(self, ticket, user_dict, use_default=None):
571	"""
572	This will update the ticket fields. It will check if the
573	given fields are known and if the right values are specified
574	It will only update the ticket field value:
575	- If the field is known
576	- If the value supplied is valid for the ticket field.
577	If not then there are two options:
578	1) Skip the value (use_default=None)
579	2) Set default value for field (use_default=1)
580	"""
581	if self.DEBUG:
582	print "TD: update_ticket_fields"
583
584	# Build a system dictionary from the ticket fields
585	# with field as index and option as value
586	#
587	sys_dict = dict()
588	for field in ticket.fields:
589	try:
590	sys_dict[field['name']] = field['options']
591
592	except KeyError:
593	sys_dict[field['name']] = None
594	pass
595
596	## Check user supplied fields an compare them with the
597	# system one's
598	#
599	for field,value in user_dict.items():
600	if self.DEBUG >= 10:
601	print 'user_field\t %s = %s' %(field,value)
602
603	## To prevent mail loop
604	#
605	if field == 'cc':
606
607	cc_list = user_dict['cc'].split(',')
608
609	if self.trac_smtp_from in cc_list:
610	if self.DEBUG > 10:
611	print 'TD: MAIL LOOP: %s is not allowed as CC address' %(self.trac_smtp_from)
612	cc_list.remove(self.trac_smtp_from)
613
614	value = ','.join(cc_list)
615
616
617	if sys_dict.has_key(field):
618
619	# Check if value is an allowed system option, if TypeError then
620	# every value is allowed
621	#
622	try:
623	if value in sys_dict[field]:
624	ticket[field] = value
625	else:
626	# Must we set a default if value is not allowed
627	#
628	if use_default:
629	value = self.get_config('ticket', 'default_%s' %(field) )
630	ticket[field] = value
631
632	except TypeError:
633	ticket[field] = value
634
635	if self.DEBUG >= 10:
636	print 'ticket_field\t %s = %s' %(field, ticket[field])
637
638	def ticket_update(self, m, id, spam):
639	"""
640	If the current email is a reply to an existing ticket, this function
641	will append the contents of this email to that ticket, instead of
642	creating a new one.
643	"""
644	if self.DEBUG:
645	print "TD: ticket_update: %s" %id
646
647	# Must we update ticket fields
648	#
649	update_fields = dict()
650	try:
651	id, keywords = string.split(id, '?')
652
653	# Skip the last ':' character
654	#
655	keywords = keywords[:-1]
656	update_fields = self.str_to_dict(keywords)
657
658	# Strip '#'
659	#
660	self.id = int(id[1:])
661
662	except ValueError:
663	# Strip '#' and ':'
664	#
665	self.id = int(id[1:-1])
666
667
668	# When is the change committed
669	#
670	if self.VERSION == 0.11:
671	utc = UTC()
672	when = datetime.now(utc)
673	else:
674	when = int(time.time())
675
676	try:
677	tkt = Ticket(self.env, self.id, self.db)
678	except util.TracError, detail:
679	# Not a valid ticket
680	self.id = None
681	return False
682
683	# How many changes has this ticket
684	cnum = len(tkt.get_changelog())
685
686
687	# reopen the ticket if it is was closed
688	# We must use the ticket workflow framework
689	#
690	if tkt['status'] in ['closed']:
691
692	#print controller.actions['reopen']
693	#
694	# As reference
695	# req = Mock(href=Href('/'), abs_href=Href('http://www.example.com/'), authname='anonymous', perm=MockPerm(), args={})
696	#
697	#a = controller.render_ticket_action_control(req, tkt, 'reopen')
698	#print 'controller : ', a
699	#
700	#b = controller.get_all_status()
701	#print 'get all status: ', b
702	#
703	#b = controller.get_ticket_changes(req, tkt, 'reopen')
704	#print 'get_ticket_changes :', b
705
706	if self.WORKFLOW and (self.VERSION in [0.11]) :
707	from trac.ticket.default_workflow import ConfigurableTicketWorkflow
708	from trac.test import Mock, MockPerm
709
710	req = Mock(authname='anonymous', perm=MockPerm(), args={})
711
712	controller = ConfigurableTicketWorkflow(self.env)
713	fields = controller.get_ticket_changes(req, tkt, self.WORKFLOW)
714
715	if self.DEBUG:
716	print 'TD: Workflow ticket update fields: ', fields
717
718	for key in fields.keys():
719	tkt[key] = fields[key]
720
721	else:
722	tkt['status'] = 'reopened'
723	tkt['resolution'] = ''
724
725	# Must we update some ticket fields properties
726	#
727	if update_fields:
728	self.update_ticket_fields(tkt, update_fields)
729
730	message_parts = self.get_message_parts(m)
731	message_parts = self.unique_attachment_names(message_parts)
732
733	if self.EMAIL_HEADER:
734	message_parts.insert(0, self.email_header_txt(m))
735
736	body_text = self.body_text(message_parts)
737
738	if body_text.strip() or update_fields:
739	if self.DRY_RUN:
740	print 'DRY_RUN: tkt.save_changes(self.author, body_text, ticket_change_number) ', self.author, cnum
741	else:
742	tkt.save_changes(self.author, body_text, when, None, str(cnum))
743
744
745	if self.VERSION == 0.9:
746	s = self.attachments(message_parts, True)
747	else:
748	s = self.attachments(message_parts)
749
750	if self.notification and not spam:
751	self.notify(tkt, False, when)
752
753	return True
754
755	def set_ticket_fields(self, ticket):
756	"""
757	set the ticket fields to value specified
758	- /etc/email2trac.conf with <prefix>_<field>
759	- trac default values, trac.ini
760	"""
761	user_dict = dict()
762
763	for field in ticket.fields:
764
765	name = field['name']
766
767	# skip some fields like resolution
768	#
769	if name in [ 'resolution' ]:
770	continue
771
772	# default trac value
773	#
774	if not field.get('custom'):
775	value = self.get_config('ticket', 'default_%s' %(name) )
776	else:
777	value = field.get('value')
778	options = field.get('options')
779	if value and options and value not in options:
780	value = options[int(value)]
781
782	if self.DEBUG > 10:
783	print 'trac.ini name %s = %s' %(name, value)
784
785	prefix = self.parameters['ticket_prefix']
786	try:
787	value = self.parameters['%s_%s' %(prefix, name)]
788	if self.DEBUG > 10:
789	print 'email2trac.conf %s = %s ' %(name, value)
790
791	except KeyError, detail:
792	pass
793
794	if self.DEBUG:
795	print 'user_dict[%s] = %s' %(name, value)
796
797	user_dict[name] = value
798
799	self.update_ticket_fields(ticket, user_dict, use_default=1)
800
801	# Set status ticket
802	#`
803	ticket['status'] = 'new'
804
805
806
807	def new_ticket(self, msg, subject, spam, set_fields = None):
808	"""
809	Create a new ticket
810	"""
811	if self.DEBUG:
812	print "TD: new_ticket"
813
814	tkt = Ticket(self.env)
815	self.set_ticket_fields(tkt)
816
817	# Old style setting for component, will be removed
818	#
819	if spam:
820	tkt['component'] = 'Spam'
821
822	elif self.parameters.has_key('component'):
823	tkt['component'] = self.parameters['component']
824
825	if not msg['Subject']:
826	tkt['summary'] = u'(No subject)'
827	else:
828	tkt['summary'] = subject
829
830	self.set_reply_fields(tkt, msg)
831
832	if set_fields:
833	rest, keywords = string.split(set_fields, '?')
834
835	if keywords:
836	update_fields = self.str_to_dict(keywords)
837	self.update_ticket_fields(tkt, update_fields)
838
839	# produce e-mail like header
840	#
841	head = ''
842	if self.EMAIL_HEADER > 0:
843	head = self.email_header_txt(msg)
844
845
846	message_parts = self.get_message_parts(msg)
847	if self.DEBUG:
848	print 'TD: self.get_message_parts ',
849	print message_parts
850
851	message_parts = self.unique_attachment_names(message_parts)
852	if self.DEBUG:
853	print 'TD: self.unique_attachment_names',
854	print message_parts
855
856	if self.EMAIL_HEADER > 0:
857	message_parts.insert(0, self.email_header_txt(msg))
858
859	body_text = self.body_text(message_parts)
860
861	tkt['description'] = body_text
862
863	#when = int(time.time())
864	#
865	utc = UTC()
866	when = datetime.now(utc)
867
868	if not self.DRY_RUN:
869	self.id = tkt.insert()
870
871	changed = False
872	comment = ''
873
874	# some routines in trac are dependend on ticket id
875	# like alternate notify template
876	#
877	if self.notify_template:
878	tkt['id'] = self.id
879	changed = True
880
881	## Rewrite the description if we have mailto enabled
882	#
883	if self.MAILTO:
884	changed = True
885	comment = u'\nadded mailto line\n'
886	mailto = self.html_mailto_link( m['Subject'], body_text)
887
888	tkt['description'] = u'%s\r\n%s%s\r\n' \
889	%(head, mailto, body_text)
890
891	## Save the attachments to the ticket
892	#
893	has_attachments = self.attachments(message_parts)
894
895	# Disabled
896	#if has_attachments:
897	# changed = True
898	# comment = '%s\n%s\n' %(comment, has_attachments)
899
900	if changed:
901	if self.DRY_RUN:
902	print 'DRY_RUN: tkt.save_changes(self.author, comment) ', self.author
903	else:
904	tkt.save_changes(self.author, comment)
905	#print tkt.get_changelog(self.db, when)
906
907	if self.notification and not spam:
908	self.notify(tkt, True)
909
910
911	def blog(self, id):
912	"""
913	The blog create/update function
914	"""
915	# import the modules
916	#
917	from tracfullblog.core import FullBlogCore
918	from tracfullblog.model import BlogPost, BlogCommen
919
920	# instantiate blog core
921	blog = FullBlogCore(self.env)
922	req = ''
923
924	if id:
925
926	# update blog
927	#
928	comment = BlogComment(self.env, id)
929	comment.author = self.author
930	comment.comment = self.get_body_text(m)
931	blog.create_comment(req, comment)
932
933	else:
934	# create blog
935	#
936	import time
937	post = BlogPost(self.env, 'blog_'+time.strftime("%Y%m%d%H%M%S", time.gmtime()))
938
939	#post = BlogPost(self.env, blog._get_default_postname(self.env))
940
941	post.author = self.author
942	post.title = self.email_to_unicode(m['Subject'])
943	post.body = self.get_body_text(m)
944
945	blog.create_post(req, post, self.author, u'Created by email2trac', False)
946
947
948	def parse(self, fp):
949	global m
950
951	m = email.message_from_file(fp)
952
953	if not m:
954	if self.DEBUG:
955	print "TD: This is not a valid email message format"
956	return
957
958	# Work around lack of header folding in Python; see http://bugs.python.org/issue4696
959	m.replace_header('Subject', m['Subject'].replace('\r', '').replace('\n', ''))
960
961	if self.DEBUG > 1: # save the entire e-mail message text
962	message_parts = self.get_message_parts(m)
963	message_parts = self.unique_attachment_names(message_parts)
964	self.save_email_for_debug(m, True)
965	body_text = self.body_text(message_parts)
966	self.debug_body(body_text, True)
967	self.debug_attachments(message_parts)
968
969	self.db = self.env.get_db_cnx()
970	self.get_sender_info(m)
971
972	if not self.email_header_acl('white_list', self.email_addr, True):
973	if self.DEBUG > 1 :
974	print 'Message rejected : %s not in white list' %(self.email_addr)
975	return False
976
977	if self.email_header_acl('black_list', self.email_addr, False):
978	if self.DEBUG > 1 :
979	print 'Message rejected : %s in black list' %(self.email_addr)
980	return False
981
982	if not self.email_header_acl('recipient_list', self.to_email_addr, True):
983	if self.DEBUG > 1 :
984	print 'Message rejected : %s not in recipient list' %(self.to_email_addr)
985	return False
986
987	# If drop the message
988	#
989	if self.spam(m) == 'drop':
990	return False
991
992	elif self.spam(m) == 'spam':
993	spam_msg = True
994	else:
995	spam_msg = False
996
997	if self.get_config('notification', 'smtp_enabled') in ['true']:
998	self.notification = 1
999	else:
1000	self.notification = 0
1001
1002	self.trac_smtp_from = self.get_config('notification', 'smtp_from')
1003
1004	# Check if FullBlogPlugin is installed
1005	#
1006	blog_enabled = None
1007	if self.get_config('components', 'tracfullblog.*') in ['enabled']:
1008	blog_enabled = True
1009
1010	if not m['Subject']:
1011	return False
1012	else:
1013	subject = self.email_to_unicode(m['Subject'])
1014
1015	#
1016	# [hic] #1529: Re: LRZ
1017	# [hic] #1529?owner=bas,priority=medium: Re: LRZ
1018	#
1019	TICKET_RE = re.compile(r"""
1020	(?P<blog>blog:(?P<blog_id>\w*))
1021	\|(?P<new_fields>[#][?].*)
1022	\|(?P<reply>[#][\d]+:)
1023	\|(?P<reply_fields>[#][\d]+\?.*?:)
1024	""", re.VERBOSE)
1025
1026	# Find out if this is a ticket or a blog
1027	#
1028	result = TICKET_RE.search(subject)
1029
1030	if result:
1031	if result.group('blog') and blog_enabled:
1032	self.blog(result.group('blog_id'))
1033
1034	# update ticket + fields
1035	#
1036	if result.group('reply_fields') and self.TICKET_UPDATE:
1037	self.ticket_update(m, result.group('reply_fields'), spam_msg)
1038
1039	# Update ticket
1040	#
1041	elif result.group('reply') and self.TICKET_UPDATE:
1042	self.ticket_update(m, result.group('reply'), spam_msg)
1043
1044	# New ticket + fields
1045	#
1046	elif result.group('new_fields'):
1047	self.new_ticket(m, subject[:result.start('new_fields')], spam_msg, result.group('new_fields'))
1048
1049	# Create ticket
1050	#
1051	else:
1052	self.new_ticket(m, subject, spam_msg)
1053
1054	def strip_signature(self, text):
1055	"""
1056	Strip signature from message, inspired by Mailman software
1057	"""
1058	body = []
1059	for line in text.splitlines():
1060	if line == '-- ':
1061	break
1062	body.append(line)
1063
1064	return ('\n'.join(body))
1065
1066	def reflow(self, text, delsp = 0):
1067	"""
1068	Reflow the message based on the format="flowed" specification (RFC 3676)
1069	"""
1070	flowedlines = []
1071	quotelevel = 0
1072	prevflowed = 0
1073
1074	for line in text.splitlines():
1075	from re import match
1076
1077	# Figure out the quote level and the content of the current line
1078	m = match('(>)( ?)(.)', line)
1079	linequotelevel = len(m.group(1))
1080	line = m.group(3)
1081
1082	# Determine whether this line is flowed
1083	if line and line != '-- ' and line[-1] == ' ':
1084	flowed = 1
1085	else:
1086	flowed = 0
1087
1088	if flowed and delsp and line and line[-1] == ' ':
1089	line = line[:-1]
1090
1091	# If the previous line is flowed, append this line to it
1092	if prevflowed and line != '-- ' and linequotelevel == quotelevel:
1093	flowedlines[-1] += line
1094	# Otherwise, start a new line
1095	else:
1096	flowedlines.append('>' * linequotelevel + line)
1097
1098	prevflowed = flowed
1099
1100
1101	return '\n'.join(flowedlines)
1102
1103	def strip_quotes(self, text):
1104	"""
1105	Strip quotes from message by Nicolas Mendoza
1106	"""
1107	body = []
1108	for line in text.splitlines():
1109	if line.startswith(self.EMAIL_QUOTE):
1110	continue
1111	body.append(line)
1112
1113	return ('\n'.join(body))
1114
1115	def wrap_text(self, text, replace_whitespace = False):
1116	"""
1117	Will break a lines longer then given length into several small
1118	lines of size given length
1119	"""
1120	import textwrap
1121
1122	LINESEPARATOR = '\n'
1123	reformat = ''
1124
1125	for s in text.split(LINESEPARATOR):
1126	tmp = textwrap.fill(s,self.USE_TEXTWRAP)
1127	if tmp:
1128	reformat = '%s\n%s' %(reformat,tmp)
1129	else:
1130	reformat = '%s\n' %reformat
1131
1132	return reformat
1133
1134	# Python2.4 and higher
1135	#
1136	#return LINESEPARATOR.join(textwrap.fill(s,width) for s in str.split(LINESEPARATOR))
1137	#
1138
1139
1140	def get_message_parts(self, msg):
1141	"""
1142	parses the email message and returns a list of body parts and attachments
1143	body parts are returned as strings, attachments are returned as tuples of (filename, Message object)
1144	"""
1145	message_parts = []
1146
1147	ALTERNATIVE_MULTIPART = False
1148
1149	for part in msg.walk():
1150	if self.DEBUG:
1151	print 'TD: Message part: Main-Type: %s' % part.get_content_maintype()
1152	print 'TD: Message part: Content-Type: %s' % part.get_content_type()
1153
1154	## Check content type
1155	#
1156	if part.get_content_type() in self.STRIP_CONTENT_TYPES:
1157
1158	if self.DEBUG:
1159	print "TD: A %s attachment named '%s' was skipped" %(part.get_content_type(), part.get_filename())
1160
1161	continue
1162
1163	## Catch some mulitpart execptions
1164	#
1165	if part.get_content_type() == 'multipart/alternative':
1166	ALTERNATIVE_MULTIPART = True
1167	continue
1168
1169	## Skip multipart containers
1170	#
1171	if part.get_content_maintype() == 'multipart':
1172	if self.DEBUG:
1173	print "TD: Skipping multipart container"
1174	continue
1175
1176	## Check if this is an inline part. It's inline if there is co Cont-Disp header, or if there is one and it says "inline"
1177	#
1178	inline = self.inline_part(part)
1179
1180	## Drop HTML message
1181	#
1182	if ALTERNATIVE_MULTIPART and self.DROP_ALTERNATIVE_HTML_VERSION:
1183	if part.get_content_type() == 'text/html':
1184	if self.DEBUG:
1185	print "TD: Skipping alternative HTML message"
1186
1187	ALTERNATIVE_MULTIPART = False
1188	continue
1189
1190	## Inline text parts are where the body is
1191	#
1192	if part.get_content_type() == 'text/plain' and inline:
1193	if self.DEBUG:
1194	print 'TD: Inline body part'
1195
1196	# Try to decode, if fails then do not decode
1197	#
1198	body_text = part.get_payload(decode=1)
1199	if not body_text:
1200	body_text = part.get_payload(decode=0)
1201
1202	format = email.Utils.collapse_rfc2231_value(part.get_param('Format', 'fixed')).lower()
1203	delsp = email.Utils.collapse_rfc2231_value(part.get_param('DelSp', 'no')).lower()
1204
1205	if self.REFLOW and not self.VERBATIM_FORMAT and format == 'flowed':
1206	body_text = self.reflow(body_text, delsp == 'yes')
1207
1208	if self.STRIP_SIGNATURE:
1209	body_text = self.strip_signature(body_text)
1210
1211	if self.STRIP_QUOTES:
1212	body_text = self.strip_quotes(body_text)
1213
1214	if self.USE_TEXTWRAP:
1215	body_text = self.wrap_text(body_text)
1216
1217	## Get contents charset (iso-8859-15 if not defined in mail headers)
1218	#
1219	charset = part.get_content_charset()
1220	if not charset:
1221	charset = 'iso-8859-15'
1222
1223	try:
1224	ubody_text = unicode(body_text, charset)
1225
1226	except UnicodeError, detail:
1227	ubody_text = unicode(body_text, 'iso-8859-15')
1228
1229	except LookupError, detail:
1230	ubody_text = 'ERROR: Could not find charset: %s, please install' %(charset)
1231
1232	if self.VERBATIM_FORMAT:
1233	message_parts.append('{{{\r\n%s\r\n}}}' %ubody_text)
1234	else:
1235	message_parts.append('%s' %ubody_text)
1236	else:
1237	if self.DEBUG:
1238	print 'TD: Filename: %s' % part.get_filename()
1239
1240	message_parts.append((part.get_filename(), part))
1241
1242	return message_parts
1243
1244	def unique_attachment_names(self, message_parts):
1245	"""
1246	"""
1247	renamed_parts = []
1248	attachment_names = set()
1249
1250	for part in message_parts:
1251
1252	## If not an attachment, leave it alone
1253	#
1254	if not isinstance(part, tuple):
1255	renamed_parts.append(part)
1256	continue
1257
1258	(filename, part) = part
1259
1260	## If no filename, use a default one
1261	#
1262	if not filename:
1263	filename = 'untitled-part'
1264
1265	# Guess the extension from the content type, use non strict mode
1266	# some additional non-standard but commonly used MIME types
1267	# are also recognized
1268	#
1269	ext = mimetypes.guess_extension(part.get_content_type(), False)
1270	if not ext:
1271	ext = '.bin'
1272
1273	filename = '%s%s' % (filename, ext)
1274
1275	# We now use the attachment insert function
1276	#
1277	## Discard relative paths in attachment names
1278	#
1279	#filename = filename.replace('\\', '/').replace(':', '/')
1280	#filename = os.path.basename(filename)
1281	#
1282	# We try to normalize the filename to utf-8 NFC if we can.
1283	# Files uploaded from OS X might be in NFD.
1284	# Check python version and then try it
1285	#
1286	#if sys.version_info[0] > 2 or (sys.version_info[0] == 2 and sys.version_info[1] >= 3):
1287	# try:
1288	# filename = unicodedata.normalize('NFC', unicode(filename, 'utf-8')).encode('utf-8')
1289	# except TypeError:
1290	# pass
1291
1292	# Make the filename unique for this ticket
1293	num = 0
1294	unique_filename = filename
1295	dummy_filename, ext = os.path.splitext(filename)
1296
1297	while unique_filename in attachment_names or self.attachment_exists(unique_filename):
1298	num += 1
1299	unique_filename = "%s-%s%s" % (dummy_filename, num, ext)
1300
1301	if self.DEBUG:
1302	print 'TD: Attachment with filename %s will be saved as %s' % (filename, unique_filename)
1303
1304	attachment_names.add(unique_filename)
1305
1306	renamed_parts.append((filename, unique_filename, part))
1307
1308	return renamed_parts
1309
1310	def inline_part(self, part):
1311	return part.get_param('inline', None, 'Content-Disposition') == '' or not part.has_key('Content-Disposition')
1312
1313
1314	def attachment_exists(self, filename):
1315
1316	if self.DEBUG:
1317	print "TD: attachment_exists: Ticket number : %s, Filename : %s" %(self.id, filename)
1318
1319	# We have no valid ticket id
1320	#
1321	if not self.id:
1322	return False
1323
1324	try:
1325	att = attachment.Attachment(self.env, 'ticket', self.id, filename)
1326	return True
1327	except attachment.ResourceNotFound:
1328	return False
1329
1330	def body_text(self, message_parts):
1331	body_text = []
1332
1333	for part in message_parts:
1334	# Plain text part, append it
1335	if not isinstance(part, tuple):
1336	body_text.extend(part.strip().splitlines())
1337	body_text.append("")
1338	continue
1339
1340	(original, filename, part) = part
1341	inline = self.inline_part(part)
1342
1343	if part.get_content_maintype() == 'image' and inline:
1344	body_text.append('[[Image(%s)]]' % filename)
1345	body_text.append("")
1346	else:
1347	body_text.append('[attachment:"%s"]' % filename)
1348	body_text.append("")
1349
1350	body_text = '\r\n'.join(body_text)
1351	return body_text
1352
1353	def notify(self, tkt, new=True, modtime=0):
1354	"""
1355	A wrapper for the TRAC notify function. So we can use templates
1356	"""
1357	if self.DRY_RUN:
1358	print 'DRY_RUN: self.notify(tkt, True) ', self.author
1359	return
1360	try:
1361	# create false {abs_}href properties, to trick Notify()
1362	#
1363	if not self.VERSION == 0.11:
1364	self.env.abs_href = Href(self.get_config('project', 'url'))
1365	self.env.href = Href(self.get_config('project', 'url'))
1366
1367	tn = TicketNotifyEmail(self.env)
1368
1369	if self.notify_template:
1370
1371	if self.VERSION == 0.11:
1372
1373	from trac.web.chrome import Chrome
1374
1375	if self.notify_template_update and not new:
1376	tn.template_name = self.notify_template_update
1377	else:
1378	tn.template_name = self.notify_template
1379
1380	tn.template = Chrome(tn.env).load_template(tn.template_name, method='text')
1381
1382	else:
1383
1384	tn.template_name = self.notify_template;
1385
1386	tn.notify(tkt, new, modtime)
1387
1388	except Exception, e:
1389	print 'TD: Failure sending notification on creation of ticket #%s: %s' %(self.id, e)
1390
1391	def html_mailto_link(self, subject, body):
1392	"""
1393	This function returns a HTML mailto tag with the ticket id and author email address
1394	"""
1395	if not self.author:
1396	author = self.email_addr
1397	else:
1398	author = self.author
1399
1400	# use urllib to escape the chars
1401	#
1402	s = 'mailto:%s?Subject=%s&Cc=%s' %(
1403	urllib.quote(self.email_addr),
1404	urllib.quote('Re: #%s: %s' %(self.id, subject)),
1405	urllib.quote(self.MAILTO_CC)
1406	)
1407
1408	s = '\r\n{{{\r\n#!html\r\n<a\r\n href="%s">Reply to: %s\r\n</a>\r\n}}}\r\n' %(s, author)
1409	return s
1410
1411	def attachments(self, message_parts, update=False):
1412	'''
1413	save any attachments as files in the ticket's directory
1414	'''
1415	if self.DRY_RUN:
1416	print "DRY_RUN: no attachments saved"
1417	return ''
1418
1419	count = 0
1420
1421	# Get Maxium attachment size
1422	#
1423	max_size = int(self.get_config('attachment', 'max_size'))
1424	status = ''
1425
1426	for part in message_parts:
1427	# Skip body parts
1428	if not isinstance(part, tuple):
1429	continue
1430
1431	(original, filename, part) = part
1432	#
1433	# Must be tuneables HvB
1434	#
1435	path, fd = util.create_unique_file(os.path.join(self.TMPDIR, filename))
1436	text = part.get_payload(decode=1)
1437	if not text:
1438	text = '(None)'
1439	fd.write(text)
1440	fd.close()
1441
1442	# get the file_size
1443	#
1444	stats = os.lstat(path)
1445	file_size = stats[stat.ST_SIZE]
1446
1447	# Check if the attachment size is allowed
1448	#
1449	if (max_size != -1) and (file_size > max_size):
1450	status = '%s\nFile %s is larger then allowed attachment size (%d > %d)\n\n' \
1451	%(status, original, file_size, max_size)
1452
1453	os.unlink(path)
1454	continue
1455	else:
1456	count = count + 1
1457
1458	# Insert the attachment
1459	#
1460	fd = open(path, 'rb')
1461	att = attachment.Attachment(self.env, 'ticket', self.id)
1462
1463	# This will break the ticket_update system, the body_text is vaporized
1464	# ;-(
1465	#
1466	if not update:
1467	att.author = self.author
1468	att.description = self.email_to_unicode('Added by email2trac')
1469
1470	att.insert(filename, fd, file_size)
1471
1472	#except util.TracError, detail:
1473	# print detail
1474
1475	# Remove the created temporary filename
1476	#
1477	fd.close()
1478	os.unlink(path)
1479
1480	# Return how many attachments
1481	#
1482	status = 'This message has %d attachment(s)\n%s' %(count, status)
1483	return status
1484
1485
1486	def mkdir_p(dir, mode):
1487	'''do a mkdir -p'''
1488
1489	arr = string.split(dir, '/')
1490	path = ''
1491	for part in arr:
1492	path = '%s/%s' % (path, part)
1493	try:
1494	stats = os.stat(path)
1495	except OSError:
1496	os.mkdir(path, mode)
1497
1498	def ReadConfig(file, name):
1499	"""
1500	Parse the config file
1501	"""
1502	if not os.path.isfile(file):
1503	print 'File %s does not exist' %file
1504	sys.exit(1)
1505
1506	config = trac_config.Configuration(file)
1507
1508	# Use given project name else use defaults
1509	#
1510	if name:
1511	sections = config.sections()
1512	if not name in sections:
1513	print "Not a valid project name: %s" %name
1514	print "Valid names: %s" %sections
1515	sys.exit(1)
1516
1517	project = dict()
1518	for option, value in config.options(name):
1519	project[option] = value
1520
1521	else:
1522	# use some trac internals to get the defaults
1523	#
1524	project = config.parser.defaults()
1525
1526	return project
1527
1528
1529	if __name__ == '__main__':
1530	# Default config file
1531	#
1532	configfile = '@email2trac_conf@'
1533	project = ''
1534	component = ''
1535	ticket_prefix = 'default'
1536	dry_run = None
1537
1538	ENABLE_SYSLOG = 0
1539
1540
1541	SHORT_OPT = 'chf:np:t:'
1542	LONG_OPT = ['component=', 'dry-run', 'help', 'file=', 'project=', 'ticket_prefix=']
1543
1544	try:
1545	opts, args = getopt.getopt(sys.argv[1:], SHORT_OPT, LONG_OPT)
1546	except getopt.error,detail:
1547	print __doc__
1548	print detail
1549	sys.exit(1)
1550
1551	project_name = None
1552	for opt,value in opts:
1553	if opt in [ '-h', '--help']:
1554	print __doc__
1555	sys.exit(0)
1556	elif opt in ['-c', '--component']:
1557	component = value
1558	elif opt in ['-f', '--file']:
1559	configfile = value
1560	elif opt in ['-n', '--dry-run']:
1561	dry_run = True
1562	elif opt in ['-p', '--project']:
1563	project_name = value
1564	elif opt in ['-t', '--ticket_prefix']:
1565	ticket_prefix = value
1566
1567	settings = ReadConfig(configfile, project_name)
1568	if not settings.has_key('project'):
1569	print __doc__
1570	print 'No Trac project is defined in the email2trac config file.'
1571	sys.exit(1)
1572
1573	if component:
1574	settings['component'] = component
1575
1576	# The default prefix for ticket values in email2trac.conf
1577	#
1578	settings['ticket_prefix'] = ticket_prefix
1579	settings['dry_run'] = dry_run
1580
1581	if settings.has_key('trac_version'):
1582	version = settings['trac_version']
1583	else:
1584	version = trac_default_version
1585
1586
1587	#debug HvB
1588	#print settings
1589
1590	try:
1591	if version == '0.9':
1592	from trac import attachment
1593	from trac.env import Environment
1594	from trac.ticket import Ticket
1595	from trac.web.href import Href
1596	from trac import util
1597	from trac.Notify import TicketNotifyEmail
1598	elif version == '0.10':
1599	from trac import attachment
1600	from trac.env import Environment
1601	from trac.ticket import Ticket
1602	from trac.web.href import Href
1603	from trac import util
1604	#
1605	# return util.text.to_unicode(str)
1606	#
1607	# see http://projects.edgewall.com/trac/changeset/2799
1608	from trac.ticket.notification import TicketNotifyEmail
1609	from trac import config as trac_config
1610	elif version == '0.11':
1611	from trac import attachment
1612	from trac.env import Environment
1613	from trac.ticket import Ticket
1614	from trac.web.href import Href
1615	from trac import config as trac_config
1616	from trac import util
1617
1618
1619	#
1620	# return util.text.to_unicode(str)
1621	#
1622	# see http://projects.edgewall.com/trac/changeset/2799
1623	from trac.ticket.notification import TicketNotifyEmail
1624	else:
1625	print 'TRAC version %s is not supported' %version
1626	sys.exit(1)
1627
1628	if settings.has_key('enable_syslog'):
1629	if SYSLOG_AVAILABLE:
1630	ENABLE_SYSLOG = float(settings['enable_syslog'])
1631
1632
1633	# Must be set before environment is created
1634	#
1635	if settings.has_key('python_egg_cache'):
1636	python_egg_cache = str(settings['python_egg_cache'])
1637	os.environ['PYTHON_EGG_CACHE'] = python_egg_cache
1638
1639	env = Environment(settings['project'], create=0)
1640	tktparser = TicketEmailParser(env, settings, float(version))
1641	tktparser.parse(sys.stdin)
1642
1643	# Catch all errors ans log to SYSLOG if we have enabled this
1644	# else stdout
1645	#
1646	except Exception, error:
1647	if ENABLE_SYSLOG:
1648	syslog.openlog('email2trac', syslog.LOG_NOWAIT)
1649
1650	etype, evalue, etb = sys.exc_info()
1651	for e in traceback.format_exception(etype, evalue, etb):
1652	syslog.syslog(e)
1653
1654	syslog.closelog()
1655	else:
1656	traceback.print_exc()
1657
1658	if m:
1659	tktparser.save_email_for_debug(m, True)
1660
1661	sys.exit(1)
1662	# EOB

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format