← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Robey Pointer
  • Date: 2006-09-08 18:46:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1996.
  • Revision ID: robey@lag.net-20060908184629-e3fc4c61ca21508c
pychecker is on crack; go back to using 'is None'.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
18
18
"""Configuration that affects the behaviour of Bazaar.
19
19
 
20
20
Currently this configuration resides in ~/.bazaar/bazaar.conf
21
 
and ~/.bazaar/branches.conf, which is written to by bzr.
 
21
and ~/.bazaar/locations.conf, which is written to by bzr.
22
22
 
23
23
In bazaar.conf the following options may be set:
24
24
[DEFAULT]
27
27
check_signatures=require|ignore|check-available(default)
28
28
create_signatures=always|never|when-required(default)
29
29
gpg_signing_command=name-of-program
 
30
log_format=name-of-format
30
31
 
31
 
in branches.conf, you specify the url of a branch and options for it.
 
32
in locations.conf, you specify the url of a branch and options for it.
32
33
Wildcards may be used - * and ? as normal in shell completion. Options
33
 
set in both bazaar.conf and branches.conf are overriden by the branches.conf
 
34
set in both bazaar.conf and locations.conf are overridden by the locations.conf
34
35
setting.
35
36
[/home/robertc/source]
36
37
recurse=False|True(default)
37
38
email= as above
38
 
check_signatures= as abive 
 
39
check_signatures= as above 
39
40
create_signatures= as above.
40
41
 
41
42
explanation of options
48
49
create_signatures - this option controls whether bzr will always create 
49
50
                    gpg signatures, never create them, or create them if the
50
51
                    branch is configured to require them.
51
 
                    NB: This option is planned, but not implemented yet.
 
52
log_format - this option sets the default log format.  Possible values are
 
53
             long, short, line, or a plugin can register new formats.
 
54
 
 
55
In bazaar.conf you can also define aliases in the ALIASES sections, example
 
56
 
 
57
[ALIASES]
 
58
lastlog=log --line -r-10..-1
 
59
ll=log --line -r-10..-1
 
60
h=help
 
61
up=pull
52
62
"""
53
63
 
54
64
 
55
65
import errno
 
66
from fnmatch import fnmatch
56
67
import os
 
68
import re
57
69
import sys
58
 
from fnmatch import fnmatch
59
 
import re
 
70
from StringIO import StringIO
60
71
 
61
72
import bzrlib
62
 
import bzrlib.errors as errors
 
73
from bzrlib import errors, urlutils
 
74
from bzrlib.osutils import pathjoin
 
75
from bzrlib.trace import mutter, warning
63
76
import bzrlib.util.configobj.configobj as configobj
64
 
from StringIO import StringIO
 
77
 
65
78
 
66
79
CHECK_IF_POSSIBLE=0
67
80
CHECK_ALWAYS=1
68
81
CHECK_NEVER=2
69
82
 
70
83
 
 
84
SIGN_WHEN_REQUIRED=0
 
85
SIGN_ALWAYS=1
 
86
SIGN_NEVER=2
 
87
 
 
88
 
71
89
class ConfigObj(configobj.ConfigObj):
72
90
 
73
91
    def get_bool(self, section, key):
74
 
        val = self[section][key].lower()
75
 
        if val in ('1', 'yes', 'true', 'on'):
76
 
            return True
77
 
        elif val in ('0', 'no', 'false', 'off'):
78
 
            return False
79
 
        else:
80
 
            raise ValueError("Value %r is not boolean" % val)
 
92
        return self[section].as_bool(key)
81
93
 
82
94
    def get_value(self, section, name):
83
95
        # Try [] for the old DEFAULT section.
99
111
    def _get_signature_checking(self):
100
112
        """Template method to override signature checking policy."""
101
113
 
 
114
    def _get_signing_policy(self):
 
115
        """Template method to override signature creation policy."""
 
116
 
102
117
    def _get_user_option(self, option_name):
103
118
        """Template method to provide a user option."""
104
119
        return None
118
133
        """See gpg_signing_command()."""
119
134
        return None
120
135
 
 
136
    def log_format(self):
 
137
        """What log format should be used"""
 
138
        result = self._log_format()
 
139
        if result is None:
 
140
            result = "long"
 
141
        return result
 
142
 
 
143
    def _log_format(self):
 
144
        """See log_format()."""
 
145
        return None
 
146
 
121
147
    def __init__(self):
122
148
        super(Config, self).__init__()
123
149
 
141
167
    
142
168
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
143
169
        
144
 
        $BZREMAIL can be set to override this, then
 
170
        $BZR_EMAIL can be set to override this (as well as the
 
171
        deprecated $BZREMAIL), then
145
172
        the concrete policy type is checked, and finally
146
173
        $EMAIL is examined.
147
174
        If none is found, a reasonable default is (hopefully)
149
176
    
150
177
        TODO: Check it's reasonably well-formed.
151
178
        """
 
179
        v = os.environ.get('BZR_EMAIL')
 
180
        if v:
 
181
            return v.decode(bzrlib.user_encoding)
152
182
        v = os.environ.get('BZREMAIL')
153
183
        if v:
 
184
            warning('BZREMAIL is deprecated in favor of BZR_EMAIL. Please update your configuration.')
154
185
            return v.decode(bzrlib.user_encoding)
155
186
    
156
187
        v = self._get_user_id()
174
205
            return policy
175
206
        return CHECK_IF_POSSIBLE
176
207
 
 
208
    def signing_policy(self):
 
209
        """What is the current policy for signature checking?."""
 
210
        policy = self._get_signing_policy()
 
211
        if policy is not None:
 
212
            return policy
 
213
        return SIGN_WHEN_REQUIRED
 
214
 
177
215
    def signature_needed(self):
178
216
        """Is a signature needed when committing ?."""
179
 
        policy = self._get_signature_checking()
180
 
        if policy == CHECK_ALWAYS:
 
217
        policy = self._get_signing_policy()
 
218
        if policy is None:
 
219
            policy = self._get_signature_checking()
 
220
            if policy is not None:
 
221
                warning("Please use create_signatures, not check_signatures "
 
222
                        "to set signing policy.")
 
223
            if policy == CHECK_ALWAYS:
 
224
                return True
 
225
        elif policy == SIGN_ALWAYS:
181
226
            return True
182
227
        return False
183
228
 
 
229
    def get_alias(self, value):
 
230
        return self._get_alias(value)
 
231
 
 
232
    def _get_alias(self, value):
 
233
        pass
 
234
 
 
235
    def get_nickname(self):
 
236
        return self._get_nickname()
 
237
 
 
238
    def _get_nickname(self):
 
239
        return None
 
240
 
184
241
 
185
242
class IniBasedConfig(Config):
186
243
    """A configuration policy that draws from ini files."""
193
250
        else:
194
251
            input = file
195
252
        try:
196
 
            self._parser = ConfigObj(input)
 
253
            self._parser = ConfigObj(input, encoding='utf-8')
197
254
        except configobj.ConfigObjError, e:
198
255
            raise errors.ParseConfigError(e.errors, e.config.filename)
199
256
        return self._parser
208
265
        if policy:
209
266
            return self._string_to_signature_policy(policy)
210
267
 
 
268
    def _get_signing_policy(self):
 
269
        """See Config._get_signing_policy"""
 
270
        policy = self._get_user_option('create_signatures')
 
271
        if policy:
 
272
            return self._string_to_signing_policy(policy)
 
273
 
211
274
    def _get_user_id(self):
212
275
        """Get the user id from the 'email' key in the current section."""
213
276
        return self._get_user_option('email')
224
287
        """See Config.gpg_signing_command."""
225
288
        return self._get_user_option('gpg_signing_command')
226
289
 
 
290
    def _log_format(self):
 
291
        """See Config.log_format."""
 
292
        return self._get_user_option('log_format')
 
293
 
227
294
    def __init__(self, get_filename):
228
295
        super(IniBasedConfig, self).__init__()
229
296
        self._get_filename = get_filename
244
311
        raise errors.BzrError("Invalid signatures policy '%s'"
245
312
                              % signature_string)
246
313
 
 
314
    def _string_to_signing_policy(self, signature_string):
 
315
        """Convert a string to a signing policy."""
 
316
        if signature_string.lower() == 'when-required':
 
317
            return SIGN_WHEN_REQUIRED
 
318
        if signature_string.lower() == 'never':
 
319
            return SIGN_NEVER
 
320
        if signature_string.lower() == 'always':
 
321
            return SIGN_ALWAYS
 
322
        raise errors.BzrError("Invalid signing policy '%s'"
 
323
                              % signature_string)
 
324
 
 
325
    def _get_alias(self, value):
 
326
        try:
 
327
            return self._get_parser().get_value("ALIASES", 
 
328
                                                value)
 
329
        except KeyError:
 
330
            pass
 
331
 
 
332
    def _get_nickname(self):
 
333
        return self.get_user_option('nickname')
 
334
 
247
335
 
248
336
class GlobalConfig(IniBasedConfig):
249
337
    """The configuration that should be used for a specific location."""
254
342
    def __init__(self):
255
343
        super(GlobalConfig, self).__init__(config_filename)
256
344
 
 
345
    def set_user_option(self, option, value):
 
346
        """Save option and its value in the configuration."""
 
347
        # FIXME: RBC 20051029 This should refresh the parser and also take a
 
348
        # file lock on bazaar.conf.
 
349
        conf_dir = os.path.dirname(self._get_filename())
 
350
        ensure_config_dir_exists(conf_dir)
 
351
        if 'DEFAULT' not in self._get_parser():
 
352
            self._get_parser()['DEFAULT'] = {}
 
353
        self._get_parser()['DEFAULT'][option] = value
 
354
        f = open(self._get_filename(), 'wb')
 
355
        self._get_parser().write(f)
 
356
        f.close()
 
357
 
257
358
 
258
359
class LocationConfig(IniBasedConfig):
259
360
    """A configuration object that gives the policy for a location."""
260
361
 
261
362
    def __init__(self, location):
262
 
        super(LocationConfig, self).__init__(branches_config_filename)
263
 
        self._global_config = None
 
363
        name_generator = locations_config_filename
 
364
        if (not os.path.exists(name_generator()) and 
 
365
                os.path.exists(branches_config_filename())):
 
366
            if sys.platform == 'win32':
 
367
                warning('Please rename %s to %s' 
 
368
                         % (branches_config_filename(),
 
369
                            locations_config_filename()))
 
370
            else:
 
371
                warning('Please rename ~/.bazaar/branches.conf'
 
372
                        ' to ~/.bazaar/locations.conf')
 
373
            name_generator = branches_config_filename
 
374
        super(LocationConfig, self).__init__(name_generator)
 
375
        # local file locations are looked up by local path, rather than
 
376
        # by file url. This is because the config file is a user
 
377
        # file, and we would rather not expose the user to file urls.
 
378
        if location.startswith('file://'):
 
379
            location = urlutils.local_path_from_url(location)
264
380
        self.location = location
265
381
 
266
 
    def _get_global_config(self):
267
 
        if self._global_config is None:
268
 
            self._global_config = GlobalConfig()
269
 
        return self._global_config
270
 
 
271
382
    def _get_section(self):
272
383
        """Get the section we should look in for config items.
273
384
 
281
392
            del location_names[-1]
282
393
        matches=[]
283
394
        for section in sections:
284
 
            section_names = section.split('/')
 
395
            # location is a local path if possible, so we need
 
396
            # to convert 'file://' urls to local paths if necessary.
 
397
            # This also avoids having file:///path be a more exact
 
398
            # match than '/path'.
 
399
            if section.startswith('file://'):
 
400
                section_path = urlutils.local_path_from_url(section)
 
401
            else:
 
402
                section_path = section
 
403
            section_names = section_path.split('/')
285
404
            if section.endswith('/'):
286
405
                del section_names[-1]
287
406
            names = zip(location_names, section_names)
299
418
            # if path is longer, and recurse is not true, no match
300
419
            if len(section_names) < len(location_names):
301
420
                try:
302
 
                    if not self._get_parser().get_bool(section, 'recurse'):
 
421
                    if not self._get_parser()[section].as_bool('recurse'):
303
422
                        continue
304
423
                except KeyError:
305
424
                    pass
309
428
        matches.sort(reverse=True)
310
429
        return matches[0][1]
311
430
 
312
 
    def _gpg_signing_command(self):
313
 
        """See Config.gpg_signing_command."""
314
 
        command = super(LocationConfig, self)._gpg_signing_command()
315
 
        if command is not None:
316
 
            return command
317
 
        return self._get_global_config()._gpg_signing_command()
318
 
 
319
 
    def _get_user_id(self):
320
 
        user_id = super(LocationConfig, self)._get_user_id()
321
 
        if user_id is not None:
322
 
            return user_id
323
 
        return self._get_global_config()._get_user_id()
324
 
 
325
 
    def _get_user_option(self, option_name):
326
 
        """See Config._get_user_option."""
327
 
        option_value = super(LocationConfig, 
328
 
                             self)._get_user_option(option_name)
329
 
        if option_value is not None:
330
 
            return option_value
331
 
        return self._get_global_config()._get_user_option(option_name)
332
 
 
333
 
    def _get_signature_checking(self):
334
 
        """See Config._get_signature_checking."""
335
 
        check = super(LocationConfig, self)._get_signature_checking()
336
 
        if check is not None:
337
 
            return check
338
 
        return self._get_global_config()._get_signature_checking()
339
 
 
340
 
    def _post_commit(self):
341
 
        """See Config.post_commit."""
342
 
        hook = self._get_user_option('post_commit')
343
 
        if hook is not None:
344
 
            return hook
345
 
        return self._get_global_config()._post_commit()
346
 
 
347
431
    def set_user_option(self, option, value):
348
432
        """Save option and its value in the configuration."""
349
433
        # FIXME: RBC 20051029 This should refresh the parser and also take a
350
 
        # file lock on branches.conf.
351
 
        if not os.path.isdir(os.path.dirname(self._get_filename())):
352
 
            os.mkdir(os.path.dirname(self._get_filename()))
 
434
        # file lock on locations.conf.
 
435
        conf_dir = os.path.dirname(self._get_filename())
 
436
        ensure_config_dir_exists(conf_dir)
353
437
        location = self.location
354
438
        if location.endswith('/'):
355
439
            location = location[:-1]
359
443
        elif location + '/' in self._get_parser():
360
444
            location = location + '/'
361
445
        self._get_parser()[location][option]=value
362
 
        self._get_parser().write()
 
446
        self._get_parser().write(file(self._get_filename(), 'wb'))
363
447
 
364
448
 
365
449
class BranchConfig(Config):
366
450
    """A configuration object giving the policy for a branch."""
367
451
 
 
452
    def _get_branch_data_config(self):
 
453
        if self._branch_data_config is None:
 
454
            self._branch_data_config = TreeConfig(self.branch)
 
455
        return self._branch_data_config
 
456
 
368
457
    def _get_location_config(self):
369
458
        if self._location_config is None:
370
459
            self._location_config = LocationConfig(self.branch.base)
371
460
        return self._location_config
372
461
 
 
462
    def _get_global_config(self):
 
463
        if self._global_config is None:
 
464
            self._global_config = GlobalConfig()
 
465
        return self._global_config
 
466
 
 
467
    def _get_best_value(self, option_name):
 
468
        """This returns a user option from local, tree or global config.
 
469
 
 
470
        They are tried in that order.  Use get_safe_value if trusted values
 
471
        are necessary.
 
472
        """
 
473
        for source in self.option_sources:
 
474
            value = getattr(source(), option_name)()
 
475
            if value is not None:
 
476
                return value
 
477
        return None
 
478
 
 
479
    def _get_safe_value(self, option_name):
 
480
        """This variant of get_best_value never returns untrusted values.
 
481
        
 
482
        It does not return values from the branch data, because the branch may
 
483
        not be controlled by the user.
 
484
 
 
485
        We may wish to allow locations.conf to control whether branches are
 
486
        trusted in the future.
 
487
        """
 
488
        for source in (self._get_location_config, self._get_global_config):
 
489
            value = getattr(source(), option_name)()
 
490
            if value is not None:
 
491
                return value
 
492
        return None
 
493
 
373
494
    def _get_user_id(self):
374
495
        """Return the full user id for the branch.
375
496
    
377
498
        This is looked up in the email controlfile for the branch.
378
499
        """
379
500
        try:
380
 
            return (self.branch.controlfile("email", "r") 
 
501
            return (self.branch.control_files.get_utf8("email") 
381
502
                    .read()
382
503
                    .decode(bzrlib.user_encoding)
383
504
                    .rstrip("\r\n"))
384
505
        except errors.NoSuchFile, e:
385
506
            pass
386
507
        
387
 
        return self._get_location_config()._get_user_id()
 
508
        return self._get_best_value('_get_user_id')
388
509
 
389
510
    def _get_signature_checking(self):
390
511
        """See Config._get_signature_checking."""
391
 
        return self._get_location_config()._get_signature_checking()
 
512
        return self._get_best_value('_get_signature_checking')
 
513
 
 
514
    def _get_signing_policy(self):
 
515
        """See Config._get_signing_policy."""
 
516
        return self._get_best_value('_get_signing_policy')
392
517
 
393
518
    def _get_user_option(self, option_name):
394
519
        """See Config._get_user_option."""
395
 
        return self._get_location_config()._get_user_option(option_name)
 
520
        for source in self.option_sources:
 
521
            value = source()._get_user_option(option_name)
 
522
            if value is not None:
 
523
                return value
 
524
        return None
 
525
 
 
526
    def set_user_option(self, name, value, local=False):
 
527
        if local is True:
 
528
            self._get_location_config().set_user_option(name, value)
 
529
        else:
 
530
            self._get_branch_data_config().set_option(value, name)
 
531
 
396
532
 
397
533
    def _gpg_signing_command(self):
398
534
        """See Config.gpg_signing_command."""
399
 
        return self._get_location_config()._gpg_signing_command()
 
535
        return self._get_safe_value('_gpg_signing_command')
400
536
        
401
537
    def __init__(self, branch):
402
538
        super(BranchConfig, self).__init__()
403
539
        self._location_config = None
 
540
        self._branch_data_config = None
 
541
        self._global_config = None
404
542
        self.branch = branch
 
543
        self.option_sources = (self._get_location_config, 
 
544
                               self._get_branch_data_config,
 
545
                               self._get_global_config)
405
546
 
406
547
    def _post_commit(self):
407
548
        """See Config.post_commit."""
408
 
        return self._get_location_config()._post_commit()
 
549
        return self._get_safe_value('_post_commit')
 
550
 
 
551
    def _get_nickname(self):
 
552
        value = self._get_explicit_nickname()
 
553
        if value is not None:
 
554
            return value
 
555
        return self.branch.base.split('/')[-2]
 
556
 
 
557
    def has_explicit_nickname(self):
 
558
        """Return true if a nickname has been explicitly assigned."""
 
559
        return self._get_explicit_nickname() is not None
 
560
 
 
561
    def _get_explicit_nickname(self):
 
562
        return self._get_best_value('_get_nickname')
 
563
 
 
564
    def _log_format(self):
 
565
        """See Config.log_format."""
 
566
        return self._get_best_value('_log_format')
 
567
 
 
568
 
 
569
def ensure_config_dir_exists(path=None):
 
570
    """Make sure a configuration directory exists.
 
571
    This makes sure that the directory exists.
 
572
    On windows, since configuration directories are 2 levels deep,
 
573
    it makes sure both the directory and the parent directory exists.
 
574
    """
 
575
    if path is None:
 
576
        path = config_dir()
 
577
    if not os.path.isdir(path):
 
578
        if sys.platform == 'win32':
 
579
            parent_dir = os.path.dirname(path)
 
580
            if not os.path.isdir(parent_dir):
 
581
                mutter('creating config parent directory: %r', parent_dir)
 
582
            os.mkdir(parent_dir)
 
583
        mutter('creating config directory: %r', path)
 
584
        os.mkdir(path)
409
585
 
410
586
 
411
587
def config_dir():
422
598
        if base is None:
423
599
            base = os.environ.get('HOME', None)
424
600
        if base is None:
425
 
            raise BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
426
 
        return os.path.join(base, 'bazaar', '2.0')
 
601
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
 
602
        return pathjoin(base, 'bazaar', '2.0')
427
603
    else:
428
604
        # cygwin, linux, and darwin all have a $HOME directory
429
605
        if base is None:
430
606
            base = os.path.expanduser("~")
431
 
        return os.path.join(base, ".bazaar")
 
607
        return pathjoin(base, ".bazaar")
432
608
 
433
609
 
434
610
def config_filename():
435
611
    """Return per-user configuration ini file filename."""
436
 
    return os.path.join(config_dir(), 'bazaar.conf')
 
612
    return pathjoin(config_dir(), 'bazaar.conf')
437
613
 
438
614
 
439
615
def branches_config_filename():
440
616
    """Return per-user configuration ini file filename."""
441
 
    return os.path.join(config_dir(), 'branches.conf')
 
617
    return pathjoin(config_dir(), 'branches.conf')
 
618
 
 
619
 
 
620
def locations_config_filename():
 
621
    """Return per-user configuration ini file filename."""
 
622
    return pathjoin(config_dir(), 'locations.conf')
 
623
 
 
624
 
 
625
def user_ignore_config_filename():
 
626
    """Return the user default ignore filename"""
 
627
    return pathjoin(config_dir(), 'ignore')
442
628
 
443
629
 
444
630
def _auto_user_id():
460
646
        import pwd
461
647
        uid = os.getuid()
462
648
        w = pwd.getpwuid(uid)
463
 
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
464
 
        username = w.pw_name.decode(bzrlib.user_encoding)
 
649
 
 
650
        # we try utf-8 first, because on many variants (like Linux),
 
651
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
 
652
        # false positives.  (many users will have their user encoding set to
 
653
        # latin-1, which cannot raise UnicodeError.)
 
654
        try:
 
655
            gecos = w.pw_gecos.decode('utf-8')
 
656
            encoding = 'utf-8'
 
657
        except UnicodeError:
 
658
            try:
 
659
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
660
                encoding = bzrlib.user_encoding
 
661
            except UnicodeError:
 
662
                raise errors.BzrCommandError('Unable to determine your name.  '
 
663
                   'Use "bzr whoami" to set it.')
 
664
        try:
 
665
            username = w.pw_name.decode(encoding)
 
666
        except UnicodeError:
 
667
            raise errors.BzrCommandError('Unable to determine your name.  '
 
668
                'Use "bzr whoami" to set it.')
 
669
 
465
670
        comma = gecos.find(',')
466
671
        if comma == -1:
467
672
            realname = gecos
472
677
 
473
678
    except ImportError:
474
679
        import getpass
475
 
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
680
        try:
 
681
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
 
682
        except UnicodeDecodeError:
 
683
            raise errors.BzrError("Can't decode username as %s." % \
 
684
                    bzrlib.user_encoding)
476
685
 
477
686
    return realname, (username + '@' + socket.gethostname())
478
687
 
493
702
                              "a reasonable email address" % e)
494
703
    return m.group(0)
495
704
 
496
 
class TreeConfig(object):
 
705
 
 
706
class TreeConfig(IniBasedConfig):
497
707
    """Branch configuration data associated with its contents, not location"""
498
708
    def __init__(self, branch):
499
709
        self.branch = branch
500
710
 
 
711
    def _get_parser(self, file=None):
 
712
        if file is not None:
 
713
            return IniBasedConfig._get_parser(file)
 
714
        return self._get_config()
 
715
 
501
716
    def _get_config(self):
502
717
        try:
503
 
            obj = ConfigObj(self.branch.controlfile('branch.conf',
504
 
                                                    'rb').readlines())
505
 
            obj.decode('UTF-8')
 
718
            obj = ConfigObj(self.branch.control_files.get('branch.conf'), 
 
719
                            encoding='utf-8')
506
720
        except errors.NoSuchFile:
507
 
            obj = ConfigObj()
 
721
            obj = ConfigObj(encoding='utf=8')
508
722
        return obj
509
723
 
510
724
    def get_option(self, name, section=None, default=None):
535
749
                    cfg_obj[section] = {}
536
750
                    obj = cfg_obj[section]
537
751
            obj[name] = value
538
 
            cfg_obj.encode('UTF-8')
539
 
            out_file = StringIO(''.join([l+'\n' for l in cfg_obj.write()]))
 
752
            out_file = StringIO()
 
753
            cfg_obj.write(out_file)
540
754
            out_file.seek(0)
541
 
            self.branch.put_controlfile('branch.conf', out_file, encode=False)
 
755
            self.branch.control_files.put('branch.conf', out_file)
542
756
        finally:
543
757
            self.branch.unlock()