~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to doc/developers/configuration.txt

  • Committer: John Arbash Meinel
  • Date: 2013-05-19 14:29:37 UTC
  • mfrom: (6437.63.9 2.5)
  • mto: (6437.63.10 2.5)
  • mto: This revision was merged to the branch mainline in revision 6575.
  • Revision ID: john@arbash-meinel.com-20130519142937-21ykz2n2y2f22za9
Merge in the actual 2.5 branch. It seems I failed before

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
Configuring Bazaar
 
2
==================
 
3
 
 
4
.. contents::
 
5
   :depth: 2
 
6
 
 
7
As a Bazaar developer there are a few things you need to know about
 
8
configuration:
 
9
 
 
10
* how to add a new option,
 
11
 
 
12
* how add a new stack,
 
13
 
 
14
* how add a new store.
 
15
 
 
16
The first sections in this document summarize the steps needed when adding a
 
17
new configuration item, the rest of the document gives more internal details
 
18
on how this is implemented.
 
19
 
 
20
Get an option value
 
21
-------------------
 
22
 
 
23
Options values are obtained with ``stack.get(option_name)`` where ``stack``
 
24
is one of the daughter classes of ``config.Stack``, see their docstrings for
 
25
a description of which sections are used from which stores.
 
26
 
 
27
The value returned is of the type declared for that ``Option`` and if
 
28
nothing is specifically declared you will get the default for that option.
 
29
 
 
30
Add a new option
 
31
----------------
 
32
 
 
33
You add a new ``Option`` to the ``option_registry``, either inside
 
34
``bzrlib/config.py`` or during initialization of your plugin (use
 
35
``register_lazy`` in this case). New plugins should have systematic
 
36
hierarchical names so that related values are grouped together::
 
37
 
 
38
  option_registry.register(
 
39
      Option('dirstate.fdatasync', default=True,
 
40
            from_unicode=bool_from_store,
 
41
            help="Flush dirstate changes onto physical disk? ...."))
 
42
 
 
43
You then need to decide which stack is appropriate to implement the Option
 
44
policy:
 
45
 
 
46
* which config files (aka ``Store``) needs to be queried, which sections are
 
47
  relevant and in what order,
 
48
 
 
49
* which section will receive the modifications (if relevant).
 
50
 
 
51
The docstrings for the existing stacks cover most of the known use cases.
 
52
 
 
53
Modify an option value or delete an option
 
54
------------------------------------------
 
55
 
 
56
Just reading an option is what is needed most of the time, modifying option
 
57
values or removing options is usually something that is not automated but
 
58
left to the user (with ``bzr config``).
 
59
 
 
60
Nevertheless, if you need to save a modified option value, use
 
61
``.set(option_name, value)`` and ``.remove(option_name)`` to delete the
 
62
option. Both methods are provided by the ``Stack`` object.
 
63
 
 
64
But before doing that, you must be sure that the stack you're using have a
 
65
writable section (this is true for ``GlobalStack`` which uses the
 
66
``DEFAULT`` section in ``bazaar.conf`` and for ``BranchStack``which uses the
 
67
no-name section in ``branch.conf``).
 
68
 
 
69
Old and new configuration code
 
70
------------------------------
 
71
 
 
72
There is (as of late 2011) some older and some newer configuration code. The
 
73
old code has specific methods for various checks or uses classes like
 
74
``GlobalConfig``.  Don't add to to it; try to remove it.
 
75
 
 
76
If you encounter an option using the old code you may want to migrate
 
77
it. This generally involves:
 
78
 
 
79
* registering the option,
 
80
 
 
81
* replace the old config by a stack:
 
82
 
 
83
  * ``GlobalConfig`` became ``GlobalStack``,
 
84
 
 
85
  * ``LocationConfig`` became ``LocationStack``,
 
86
 
 
87
  * ``BranchConfig`` became ``BranchStack`` (or in this case,
 
88
    ``get_config()`` became ``get_config_stack()``.
 
89
 
 
90
* replace the custom accessor calls with ``conf.get(option_name)``.
 
91
 
 
92
The new config code provides some help for commonly encountered use cases
 
93
that can allow further simplifications like:
 
94
 
 
95
* providing a default value when the option is not defined in any way by the
 
96
  user,
 
97
 
 
98
* convert the unicode string provided by the user into a suitable
 
99
  representation (integer, list, etc).
 
100
 
 
101
Adding a new stack
 
102
------------------
 
103
 
 
104
Stacks capture the various places an option can be declared by the user with
 
105
associated levels of generality and query them in the appropriate order
 
106
returning the first definition found. For example, the
 
107
``append_revisions_only`` option may be declared for all branches of a user
 
108
in ``bazaar.conf``, or for a hierarchy of branches in ``locations.conf`` or
 
109
in a single branch in ``branch.conf``.
 
110
 
 
111
Defining a new stack means you need a new way to expose these levels to the
 
112
user that is not covered by the existing stacks.
 
113
 
 
114
This is achieved by declaring:
 
115
 
 
116
* which stores can provide a value for the option,
 
117
 
 
118
* which sections apply to the stack instance, some filtering for a given
 
119
  context can be defined,
 
120
 
 
121
* which (store, section) should receive the modifications.
 
122
 
 
123
Mapping different sections to different stacks is a powerful way to organize
 
124
the options and provide various levels of configuration to the user. This is
 
125
achieved with ``Store`` and ``SectionMatcher`` objects.
 
126
 
 
127
 
 
128
Adding a new store
 
129
------------------
 
130
 
 
131
The following stores are used by ``bzr`` in ways that illustrate various
 
132
uses of sections.
 
133
 
 
134
bazaar.conf
 
135
===========
 
136
 
 
137
``bzr`` itself defines two sections here:
 
138
 
 
139
* ``DEFAULT`` where global options are defined,
 
140
 
 
141
* ``ALIASES`` where command aliases are defined. This section is *not*
 
142
  available via ``GlobalStack``, instead, the ``bzr alias`` command uses it
 
143
  for its own purposes.
 
144
 
 
145
Plugins can define either additional options in the ``DEFAULT`` section or
 
146
new sections for their own needs (this is not especially encouraged
 
147
though). The ``bzr-bookmarks`` plugin defines a ``BOOKMARKS`` section there
 
148
for example.
 
149
 
 
150
pkgimport.conf
 
151
==============
 
152
 
 
153
The Ubuntu package importer defines a store and two stacks involving
 
154
``pkgimport.conf``. A no-name section contains the options common to all
 
155
packages and sections named after their corresponding package can also be
 
156
defined.
 
157
 
 
158
The ``ImporterStack`` uses ``locations.conf`` and the no-name section in
 
159
``pkgimport.conf`` for the importer options.
 
160
 
 
161
The ``PackageStack`` uses only ``pkgimport.conf`` and uses the section name
 
162
after the package followed by the no-name section.
 
163
 
 
164
location.conf
 
165
=============
 
166
 
 
167
``bzr`` defines sections corresponding to URLs there and includes the
 
168
relevant sections in ``LocationStack`` and ``BranchStack``. No no-name
 
169
section is recognized in this file.
 
170
 
 
171
branch.conf
 
172
===========
 
173
 
 
174
This file defines the option for a given branch and uses only the no-name
 
175
section.
 
176
 
 
177
Option
 
178
------
 
179
 
 
180
The Option object is used to define its properties:
 
181
 
 
182
* name: a name: a valid python identifier (even if it's not used as an
 
183
  identifier in python itself). This is also used to register the option.
 
184
 
 
185
* from_unicode: a callable accepting a unicode string and returning a
 
186
  suitable value for the option. If the string cannot be coerced it should
 
187
  return None.
 
188
 
 
189
* override_from_env: a list of environment variables. The first variable set
 
190
  will be used as the option value overriding any other definition of the
 
191
  option.
 
192
 
 
193
* default: the default value that Stack.get() should return if no value can
 
194
  be found for the option. This can also be a callable as long as it returns
 
195
  a unicode string.
 
196
 
 
197
* default_from_env: a list of environment variables. The first variable set
 
198
  will provide a default value overriding 'default' which remains the
 
199
  default value if *no* environment variable is set.
 
200
 
 
201
* help: a doc string describing the option, the first line should be a
 
202
  summary and can be followed by a blank line and a more detailed
 
203
  explanation. This will be displayed to the user with::
 
204
 
 
205
    bzr help <option name>
 
206
 
 
207
* invalid: the action to be taken when an invalid value is encountered in a
 
208
  store (during a Stack.get()).
 
209
 
 
210
The value of an option is a unicode string or ``None`` if it's not
 
211
defined. By using ``from_unicode`` you can turn this string into a more
 
212
appropriate representation.
 
213
 
 
214
If you need a list value, you should use ``ListOption`` instead.
 
215
 
 
216
 
 
217
Sections
 
218
--------
 
219
 
 
220
Options are grouped into sections which share some properties with the well
 
221
known dict objects:
 
222
 
 
223
* the key is the name,
 
224
* you can get, set and remove an option,
 
225
* the value is a unicode string.
 
226
 
 
227
MutableSection is needed to set or remove an option, ReadOnlySection should
 
228
be used otherwise.
 
229
 
 
230
 
 
231
Stores
 
232
------
 
233
 
 
234
Options can be persistent in which case they are saved into Stores.
 
235
 
 
236
``config.Store`` defines the abstract interface that all stores should
 
237
implement.
 
238
 
 
239
This object doesn't provide direct access to the options, it only provides
 
240
access to Sections. This is deliberate to ensure that sections can be
 
241
properly shared by reusing the same underlying objects. Accessing options
 
242
should be done via the ``Section`` objects.
 
243
 
 
244
A ``Store`` can contain one or more sections, each section is uniquely
 
245
identified by a unicode string.
 
246
 
 
247
``config.IniFileStore`` is an implementation that use ``ConfigObj``.
 
248
 
 
249
Depending on the object it is associated with (or not) a ``Store`` also needs
 
250
to implement a locking mechanism. ``LockableIniFileStore`` implements such a
 
251
mechanism for ``IniFileStore`` based stores.
 
252
 
 
253
Classes are provided for the usual Bazaar configuration files and could be
 
254
used as examples to define new ones if needed. The associated tests provides a
 
255
basis for new classes which only need to register themselves in the right
 
256
places to inherit from the existing basic tests and add their own specific
 
257
ones.
 
258
 
 
259
A ``Store`` defines how option values are stored, this includes:
 
260
 
 
261
* defining the sections where the options are grouped,
 
262
 
 
263
* defining how the values are quoted/unquoted for storage purposes. Stacks
 
264
  use the unquoted values internally (default value handling and option
 
265
  expansion are simpler this way) and ``bzr config`` quote them when they
 
266
  need to be displayed.
 
267
 
 
268
 
 
269
Filtering sections
 
270
------------------
 
271
 
 
272
For some contexts, only some sections from a given store will apply. The
 
273
``SectionMatcher`` objects are used to define which sections in a store
 
274
apply to a given context.
 
275
 
 
276
The main constraint here is that a ``SectionMatcher`` should delay the loading
 
277
of the associated store as long as possible. The constructor should collect
 
278
all data needed for the selection and uses it while processing the sections in
 
279
``get_sections``.
 
280
 
 
281
Only ``ReadOnlySection`` objects are manipulated here but a
 
282
``SectionMatcher`` can return dedicated ``Section`` objects to provide
 
283
additional context (the ``LocationSection`` add an ``extra_path`` attribute
 
284
to implement the section local options for example). If no sections match,
 
285
an empty list is returned.
 
286
 
 
287
Options local to a section can be defined for special purposes and be
 
288
handled by ``Section.get()``. One such option is ``relpath`` which is
 
289
defined in ``LocationSection`` as an alternative to the ``appendpath``
 
290
policy.
 
291
 
 
292
For ``appendpath``, the ``LocationSection`` will carry ``extra_path`` as the
 
293
relative path between the section name and the location used. ``relpath``
 
294
will be available as a ``Section`` local option with the same
 
295
value. ``basename`` will carry the location base name and be available as a
 
296
local option with the same name. Note that such options can only be expanded
 
297
inside the section that defines them.
 
298
 
 
299
Specific section matchers can be implemented by overriding ``get_sections``
 
300
or just ``match``.
 
301
 
 
302
``bzrlib`` provides:
 
303
 
 
304
* ``NameMatcher(store, unique_id)``: To select a single section matching
 
305
  ``unique_id``.
 
306
 
 
307
* ``LocationMatcher(store, location)``: To select all sections that match
 
308
  ``location`` sorted by decreasing number of path components.
 
309
 
 
310
* ``StartingPathMatcher(store, location)``: To select all sections that
 
311
  match ``location`` in the order they appear in the ``store``.
 
312
 
 
313
Stacks
 
314
------
 
315
 
 
316
An option can take different values depending on the context it is
 
317
used. This can involve configuration files, options from the command line,
 
318
default values in bzrlib and then some.
 
319
 
 
320
Such a context is implemented by creating a list of ``Section`` stacked upon
 
321
each other. A ``Stack`` can then be asked for an option value and returns the
 
322
first definition found.
 
323
 
 
324
This provides a great flexibility to decide priorities between sections when
 
325
the stack is defined without to worry about them in the code itself.
 
326
 
 
327
A stack also defines a mutable section (which can be None) to handle
 
328
modifications.
 
329
 
 
330
Many sections (or even stores) are aimed at providing default values for an
 
331
option but these sections shouldn't be modified lightly as modifying an option
 
332
used for different contexts will indeed be seen by all these contexts.
 
333
 
 
334
Default values in configuration files are defined by users. Developers
 
335
shouldn't have to modify them, as such, no mechanism nor heuristics are used
 
336
to find which section (or sections) should be modified.
 
337
 
 
338
A ``Stack`` defines a mutable section when there is no ambiguity.  If there
 
339
is one, then the *user* should be able to decide and in this case a new
 
340
``Stack`` can be created cheaply.
 
341
 
 
342
Different stacks can be created for different purposes, the existing
 
343
``GlobalStack``, ``LocationStack`` and ``BranchStack`` can be used as basis
 
344
or examples. These classes are the only ones that should be used in code,
 
345
``Stores`` can be used to build them but shouldn't be used otherwise, ditto
 
346
for sections. Again, the associated tests could and should be used against the
 
347
created stacks.
 
348
 
 
349
Also note that ``MemoryStack`` can be used without any disk resources which
 
350
allows for simpler and faster tests. A common pattern is to accept a
 
351
``config`` parameter related to a given feature and test it with predefined
 
352
configurations without involving the whole
 
353
stack. ``bzrlib.tests.test_commit``, ``bzrlib.tests.test_gpg`` and
 
354
``bzrlib.tests.test_smtp_connection`` are good examples.
 
355