/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/mail_client.py

  • Committer: Alexander Belchenko
  • Date: 2008-03-02 16:54:19 UTC
  • mto: This revision was merged to the branch mainline in revision 3267.
  • Revision ID: bialix@ukr.net-20080302165419-2u0r0ogn1h7s4gib
because every mail client has different rules to compose command line we should encode arguments to 8 bit string only when needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/mail_client.py
 
1
# Copyright (C) 2007 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
import errno
 
18
import os
 
19
import subprocess
 
20
import sys
 
21
import tempfile
 
22
 
 
23
import bzrlib
 
24
from bzrlib import (
 
25
    email_message,
 
26
    errors,
 
27
    msgeditor,
 
28
    osutils,
 
29
    urlutils,
 
30
    )
 
31
 
 
32
 
 
33
class MailClient(object):
 
34
    """A mail client that can send messages with attachements."""
 
35
 
 
36
    def __init__(self, config):
 
37
        self.config = config
 
38
 
 
39
    def compose(self, prompt, to, subject, attachment, mime_subtype,
 
40
                extension):
 
41
        """Compose (and possibly send) an email message
 
42
 
 
43
        Must be implemented by subclasses.
 
44
 
 
45
        :param prompt: A message to tell the user what to do.  Supported by
 
46
            the Editor client, but ignored by others
 
47
        :param to: The address to send the message to
 
48
        :param subject: The contents of the subject line
 
49
        :param attachment: An email attachment, as a bytestring
 
50
        :param mime_subtype: The attachment is assumed to be a subtype of
 
51
            Text.  This allows the precise subtype to be specified, e.g.
 
52
            "plain", "x-patch", etc.
 
53
        :param extension: The file extension associated with the attachment
 
54
            type, e.g. ".patch"
 
55
        """
 
56
        raise NotImplementedError
 
57
 
 
58
    def compose_merge_request(self, to, subject, directive):
 
59
        """Compose (and possibly send) a merge request
 
60
 
 
61
        :param to: The address to send the request to
 
62
        :param subject: The subject line to use for the request
 
63
        :param directive: A merge directive representing the merge request, as
 
64
            a bytestring.
 
65
        """
 
66
        prompt = self._get_merge_prompt("Please describe these changes:", to,
 
67
                                        subject, directive)
 
68
        self.compose(prompt, to, subject, directive,
 
69
            'x-patch', '.patch')
 
70
 
 
71
    def _get_merge_prompt(self, prompt, to, subject, attachment):
 
72
        """Generate a prompt string.  Overridden by Editor.
 
73
 
 
74
        :param prompt: A string suggesting what user should do
 
75
        :param to: The address the mail will be sent to
 
76
        :param subject: The subject line of the mail
 
77
        :param attachment: The attachment that will be used
 
78
        """
 
79
        return ''
 
80
 
 
81
 
 
82
class Editor(MailClient):
 
83
    """DIY mail client that uses commit message editor"""
 
84
 
 
85
    def _get_merge_prompt(self, prompt, to, subject, attachment):
 
86
        """See MailClient._get_merge_prompt"""
 
87
        return (u"%s\n\n"
 
88
                u"To: %s\n"
 
89
                u"Subject: %s\n\n"
 
90
                u"%s" % (prompt, to, subject,
 
91
                         attachment.decode('utf-8', 'replace')))
 
92
 
 
93
    def compose(self, prompt, to, subject, attachment, mime_subtype,
 
94
                extension):
 
95
        """See MailClient.compose"""
 
96
        if not to:
 
97
            raise errors.NoMailAddressSpecified()
 
98
        body = msgeditor.edit_commit_message(prompt)
 
99
        if body == '':
 
100
            raise errors.NoMessageSupplied()
 
101
        email_message.EmailMessage.send(self.config,
 
102
                                        self.config.username(),
 
103
                                        to,
 
104
                                        subject,
 
105
                                        body,
 
106
                                        attachment,
 
107
                                        attachment_mime_subtype=mime_subtype)
 
108
 
 
109
 
 
110
class ExternalMailClient(MailClient):
 
111
    """An external mail client."""
 
112
 
 
113
    def _get_client_commands(self):
 
114
        """Provide a list of commands that may invoke the mail client"""
 
115
        if sys.platform == 'win32':
 
116
            import win32utils
 
117
            return [win32utils.get_app_path(i) for i in self._client_commands]
 
118
        else:
 
119
            return self._client_commands
 
120
 
 
121
    def compose(self, prompt, to, subject, attachment, mime_subtype,
 
122
                extension):
 
123
        """See MailClient.compose.
 
124
 
 
125
        Writes the attachment to a temporary file, invokes _compose.
 
126
        """
 
127
        fd, pathname = tempfile.mkstemp(extension, 'bzr-mail-')
 
128
        try:
 
129
            os.write(fd, attachment)
 
130
        finally:
 
131
            os.close(fd)
 
132
        self._compose(prompt, to, subject, pathname, mime_subtype, extension)
 
133
 
 
134
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
 
135
                extension):
 
136
        """Invoke a mail client as a commandline process.
 
137
 
 
138
        Overridden by MAPIClient.
 
139
        :param to: The address to send the mail to
 
140
        :param subject: The subject line for the mail
 
141
        :param pathname: The path to the attachment
 
142
        :param mime_subtype: The attachment is assumed to have a major type of
 
143
            "text", but the precise subtype can be specified here
 
144
        :param extension: A file extension (including period) associated with
 
145
            the attachment type.
 
146
        """
 
147
        for name in self._get_client_commands():
 
148
            cmdline = [self._encode_path(name, 'executable')]
 
149
            cmdline.extend(self._get_compose_commandline(to, subject,
 
150
                                                         attach_path))
 
151
            try:
 
152
                subprocess.call(cmdline)
 
153
            except OSError, e:
 
154
                if e.errno != errno.ENOENT:
 
155
                    raise
 
156
            else:
 
157
                break
 
158
        else:
 
159
            raise errors.MailClientNotFound(self._client_commands)
 
160
 
 
161
    def _get_compose_commandline(self, to, subject, attach_path):
 
162
        """Determine the commandline to use for composing a message
 
163
 
 
164
        Implemented by various subclasses
 
165
        :param to: The address to send the mail to
 
166
        :param subject: The subject line for the mail
 
167
        :param attach_path: The path to the attachment
 
168
        """
 
169
        raise NotImplementedError
 
170
 
 
171
    def _encode_safe(self, u):
 
172
        """Encode possible unicode string argument to 8-bit string
 
173
        in user_encoding. Unencodable characters will be replaced
 
174
        with '?'.
 
175
 
 
176
        :param  u:  possible unicode string.
 
177
        :return:    encoded string if u is unicode, u itself otherwise.
 
178
        """
 
179
        if isinstance(u, unicode):
 
180
            return u.encode(bzrlib.user_encoding, 'replace')
 
181
        return u
 
182
 
 
183
    def _encode_path(self, path, kind):
 
184
        """Encode unicode path in user encoding.
 
185
 
 
186
        :param  path:   possible unicode path.
 
187
        :param  kind:   path kind ('executable' or 'attachment').
 
188
        :return:        encoded path if path is unicode,
 
189
                        path itself otherwise.
 
190
        :raise:         UnableEncodePath.
 
191
        """
 
192
        if isinstance(path, unicode):
 
193
            try:
 
194
                return path.encode(bzrlib.user_encoding)
 
195
            except UnicodeEncodeError:
 
196
                raise errors.UnableEncodePath(path, kind)
 
197
        return path
 
198
 
 
199
 
 
200
class Evolution(ExternalMailClient):
 
201
    """Evolution mail client."""
 
202
 
 
203
    _client_commands = ['evolution']
 
204
 
 
205
    def _get_compose_commandline(self, to, subject, attach_path):
 
206
        """See ExternalMailClient._get_compose_commandline"""
 
207
        message_options = {}
 
208
        if subject is not None:
 
209
            message_options['subject'] = subject
 
210
        if attach_path is not None:
 
211
            message_options['attach'] = attach_path
 
212
        options_list = ['%s=%s' % (k, urlutils.escape(v)) for (k, v) in
 
213
                        sorted(message_options.iteritems())]
 
214
        return ['mailto:%s?%s' % (self._encode_safe(to or ''),
 
215
            '&'.join(options_list))]
 
216
 
 
217
 
 
218
class Mutt(ExternalMailClient):
 
219
    """Mutt mail client."""
 
220
 
 
221
    _client_commands = ['mutt']
 
222
 
 
223
    def _get_compose_commandline(self, to, subject, attach_path):
 
224
        """See ExternalMailClient._get_compose_commandline"""
 
225
        message_options = []
 
226
        if subject is not None:
 
227
            message_options.extend(['-s', self._encode_safe(subject)])
 
228
        if attach_path is not None:
 
229
            message_options.extend(['-a',
 
230
                self._encode_path(attach_path, 'attachment')])
 
231
        if to is not None:
 
232
            message_options.append(self._encode_safe(to))
 
233
        return message_options
 
234
 
 
235
 
 
236
class Thunderbird(ExternalMailClient):
 
237
    """Mozilla Thunderbird (or Icedove)
 
238
 
 
239
    Note that Thunderbird 1.5 is buggy and does not support setting
 
240
    "to" simultaneously with including a attachment.
 
241
 
 
242
    There is a workaround if no attachment is present, but we always need to
 
243
    send attachments.
 
244
    """
 
245
 
 
246
    _client_commands = ['thunderbird', 'mozilla-thunderbird', 'icedove',
 
247
        '/Applications/Mozilla/Thunderbird.app/Contents/MacOS/thunderbird-bin']
 
248
 
 
249
    def _get_compose_commandline(self, to, subject, attach_path):
 
250
        """See ExternalMailClient._get_compose_commandline"""
 
251
        message_options = {}
 
252
        if to is not None:
 
253
            message_options['to'] = self._encode_safe(to)
 
254
        if subject is not None:
 
255
            message_options['subject'] = self._encode_safe(subject)
 
256
        if attach_path is not None:
 
257
            message_options['attachment'] = urlutils.local_path_to_url(
 
258
                attach_path)
 
259
        options_list = ["%s='%s'" % (k, v) for k, v in
 
260
                        sorted(message_options.iteritems())]
 
261
        return ['-compose', ','.join(options_list)]
 
262
 
 
263
 
 
264
class KMail(ExternalMailClient):
 
265
    """KDE mail client."""
 
266
 
 
267
    _client_commands = ['kmail']
 
268
 
 
269
    def _get_compose_commandline(self, to, subject, attach_path):
 
270
        """See ExternalMailClient._get_compose_commandline"""
 
271
        message_options = []
 
272
        if subject is not None:
 
273
            message_options.extend(['-s', self._encode_safe(subject)])
 
274
        if attach_path is not None:
 
275
            message_options.extend(['--attach',
 
276
                self._encode_path(attach_path, 'attachment')])
 
277
        if to is not None:
 
278
            message_options.extend([self._encode_safe(to)])
 
279
        return message_options
 
280
 
 
281
 
 
282
class XDGEmail(ExternalMailClient):
 
283
    """xdg-email attempts to invoke the user's preferred mail client"""
 
284
 
 
285
    _client_commands = ['xdg-email']
 
286
 
 
287
    def _get_compose_commandline(self, to, subject, attach_path):
 
288
        """See ExternalMailClient._get_compose_commandline"""
 
289
        if not to:
 
290
            raise errors.NoMailAddressSpecified()
 
291
        commandline = [self._encode_safe(to)]
 
292
        if subject is not None:
 
293
            commandline.extend(['--subject', self._encode_safe(subject)])
 
294
        if attach_path is not None:
 
295
            commandline.extend(['--attach',
 
296
                self._encode_path(attach_path, 'attachment')])
 
297
        return commandline
 
298
 
 
299
 
 
300
class MAPIClient(ExternalMailClient):
 
301
    """Default Windows mail client launched using MAPI."""
 
302
 
 
303
    def _compose(self, prompt, to, subject, attach_path, mime_subtype,
 
304
                 extension):
 
305
        """See ExternalMailClient._compose.
 
306
 
 
307
        This implementation uses MAPI via the simplemapi ctypes wrapper
 
308
        """
 
309
        from bzrlib.util import simplemapi
 
310
        try:
 
311
            simplemapi.SendMail(to or '', subject or '', '', attach_path)
 
312
        except simplemapi.MAPIError, e:
 
313
            if e.code != simplemapi.MAPI_USER_ABORT:
 
314
                raise errors.MailClientNotFound(['MAPI supported mail client'
 
315
                                                 ' (error %d)' % (e.code,)])
 
316
 
 
317
 
 
318
class DefaultMail(MailClient):
 
319
    """Default mail handling.  Tries XDGEmail (or MAPIClient on Windows),
 
320
    falls back to Editor"""
 
321
 
 
322
    def _mail_client(self):
 
323
        """Determine the preferred mail client for this platform"""
 
324
        if osutils.supports_mapi():
 
325
            return MAPIClient(self.config)
 
326
        else:
 
327
            return XDGEmail(self.config)
 
328
 
 
329
    def compose(self, prompt, to, subject, attachment, mime_subtype,
 
330
                extension):
 
331
        """See MailClient.compose"""
 
332
        try:
 
333
            return self._mail_client().compose(prompt, to, subject,
 
334
                                               attachment, mimie_subtype,
 
335
                                               extension)
 
336
        except errors.MailClientNotFound:
 
337
            return Editor(self.config).compose(prompt, to, subject,
 
338
                          attachment, mimie_subtype, extension)
 
339
 
 
340
    def compose_merge_request(self, to, subject, directive):
 
341
        """See MailClient.compose_merge_request"""
 
342
        try:
 
343
            return self._mail_client().compose_merge_request(to, subject,
 
344
                                                             directive)
 
345
        except errors.MailClientNotFound:
 
346
            return Editor(self.config).compose_merge_request(to, subject,
 
347
                          directive)