← Back to branch summary

~barry/mailman/lp1423756

« back to all changes in this revision

Viewing changes to src/mailman/utilities/importer.py

  • Committer: Barry Warsaw
  • Date: 2015-01-05 01:20:33 UTC
  • mfrom: (7264.4.66 py3)
  • Revision ID: barry@list.org-20150105012033-zdrw9c2odhpf22fz
Merge the Python 3 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mailman/utilities/importer.py
17
17
 
18
18
"""Importer routines."""
19
19
 
20
 
from __future__ import absolute_import, print_function, unicode_literals
21
 
 
22
 
__metaclass__ = type
23
20
__all__ = [
24
21
    'Import21Error',
25
22
    'import_config_pck',
48
45
from mailman.interfaces.usermanager import IUserManager
49
46
from mailman.utilities.filesystem import makedirs
50
47
from mailman.utilities.i18n import search
51
 
from urllib2 import URLError
 
48
from six.moves.urllib_error import URLError
52
49
from zope.component import getUtility
53
50
 
54
51
 
58
55
 
59
56
 
60
57
 
61
 
def str_to_unicode(value):
 
58
def bytes_to_str(value):
62
59
    # Convert a string to unicode when the encoding is not declared.
63
60
    if not isinstance(value, bytes):
64
61
        return value
71
68
    return value.decode('ascii', 'replace')
72
69
 
73
70
 
74
 
def unicode_to_string(value):
75
 
    return None if value is None else str(value)
 
71
def str_to_bytes(value):
 
72
    if value is None or isinstance(value, bytes):
 
73
        return value
 
74
    return value.encode('utf-8')
76
75
 
77
76
 
78
77
def seconds_to_delta(value):
84
83
 
85
84
 
86
85
def list_members_to_unicode(value):
87
 
    return [str_to_unicode(item) for item in value]
 
86
    return [bytes_to_str(item) for item in value]
88
87
 
89
88
 
90
89
 
132
131
def check_language_code(code):
133
132
    if code is None:
134
133
        return None
135
 
    code = str_to_unicode(code)
 
134
    code = bytes_to_str(code)
136
135
    if code not in getUtility(ILanguageManager):
137
136
        msg = """Missing language: {0}
138
137
You must add a section describing this language to your mailman.cfg file.
170
169
    forward_unrecognized_bounces_to=UnrecognizedBounceDisposition,
171
170
    gateway_to_mail=bool,
172
171
    include_rfc2369_headers=bool,
173
 
    moderator_password=unicode_to_string,
 
172
    moderator_password=str_to_bytes,
174
173
    newsgroup_moderation=NewsgroupModeration,
175
174
    nntp_prefix_subject_too=bool,
176
175
    pass_extensions=list_members_to_unicode,
213
212
    ]
214
213
 
215
214
EXCLUDES = set((
 
215
    'delivery_status',
216
216
    'digest_members',
217
217
    'members',
 
218
    'user_options',
218
219
    ))
219
220
 
220
221
 
243
244
        # If the mailing list has a preferred language that isn't registered
244
245
        # in the configuration file, hasattr() will swallow the KeyError this
245
246
        # raises and return False.  Treat that attribute specially.
246
 
        if hasattr(mlist, key) or key == 'preferred_language':
247
 
            if isinstance(value, str):
248
 
                value = str_to_unicode(value)
 
247
        if key == 'preferred_language' or hasattr(mlist, key):
 
248
            if isinstance(value, bytes):
 
249
                value = bytes_to_str(value)
249
250
            # Some types require conversion.
250
251
            converter = TYPES.get(key)
251
252
            try:
279
280
    # Handle ban list.
280
281
    ban_manager = IBanManager(mlist)
281
282
    for address in config_dict.get('ban_list', []):
282
 
        ban_manager.ban(str_to_unicode(address))
 
283
        ban_manager.ban(bytes_to_str(address))
283
284
    # Handle acceptable aliases.
284
285
    acceptable_aliases = config_dict.get('acceptable_aliases', '')
285
 
    if isinstance(acceptable_aliases, basestring):
 
286
    if isinstance(acceptable_aliases, bytes):
 
287
        acceptable_aliases = acceptable_aliases.decode('utf-8')
 
288
    if isinstance(acceptable_aliases, str):
286
289
        acceptable_aliases = acceptable_aliases.splitlines()
287
290
    alias_set = IAcceptableAliasSet(mlist)
288
291
    for address in acceptable_aliases:
289
292
        address = address.strip()
290
293
        if len(address) == 0:
291
294
            continue
292
 
        address = str_to_unicode(address)
 
295
        address = bytes_to_str(address)
293
296
        try:
294
297
            alias_set.add(address)
295
298
        except ValueError:
343
346
        if oldvar not in config_dict:
344
347
            continue
345
348
        text = config_dict[oldvar]
346
 
        text = text.decode('utf-8', 'replace')
 
349
        if isinstance(text, bytes):
 
350
            text = text.decode('utf-8', 'replace')
347
351
        for oldph, newph in convert_placeholders:
348
352
            text = text.replace(oldph, newph)
349
353
        default_value, default_text  = defaults.get(newvar, (None, None))
380
384
        with codecs.open(filepath, 'w', encoding='utf-8') as fp:
381
385
            fp.write(text)
382
386
    # Import rosters.
383
 
    members = set(config_dict.get('members', {}).keys()
384
 
                + config_dict.get('digest_members', {}).keys())
 
387
    regulars_set = set(config_dict.get('members', {}))
 
388
    digesters_set = set(config_dict.get('digest_members', {}))
 
389
    members = regulars_set.union(digesters_set)
385
390
    import_roster(mlist, config_dict, members, MemberRole.member)
386
391
    import_roster(mlist, config_dict, config_dict.get('owner', []),
387
392
                  MemberRole.owner)
407
412
    for email in members:
408
413
        # For owners and members, the emails can have a mixed case, so
409
414
        # lowercase them all.
410
 
        email = str_to_unicode(email).lower()
 
415
        email = bytes_to_str(email).lower()
411
416
        if roster.get_member(email) is not None:
412
417
            print('{} is already imported with role {}'.format(email, role),
413
418
                  file=sys.stderr)
421
426
                merged_members.update(config_dict.get('members', {}))
422
427
                merged_members.update(config_dict.get('digest_members', {}))
423
428
                if merged_members.get(email, 0) != 0:
424
 
                    original_email = str_to_unicode(merged_members[email])
 
429
                    original_email = bytes_to_str(merged_members[email])
425
430
                else:
426
431
                    original_email = email
427
432
                address = usermanager.create_address(original_email)
449
454
        # overwritten.
450
455
        if email in config_dict.get('usernames', {}):
451
456
            address.display_name = \
452
 
                str_to_unicode(config_dict['usernames'][email])
 
457
                bytes_to_str(config_dict['usernames'][email])
453
458
            user.display_name    = \
454
 
                str_to_unicode(config_dict['usernames'][email])
 
459
                bytes_to_str(config_dict['usernames'][email])
455
460
        if email in config_dict.get('passwords', {}):
456
461
            user.password = config.password_context.encrypt(
457
462
                config_dict['passwords'][email])