Context Navigation

source: trunk/email2trac.py.in @ 319

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

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

Download in other formats:

Original Format