Package: zc.zodbrecipes
Recipes for working with ZODB.ContentsChanges3.0 (2023-02-07)2.0.0 (2014-02-12)0.6.2 (2012-10-31)0.6.1 (2010-05-25)0.6.0 (2009-12-03)New FeaturesBugs Fixed0.5.0 (2008-11-03)New FeaturesBugs Fixed0.4 (2008-02-18)0.3.1 (2008-01-03)0.3 (2008-01-03)New FeaturesBugs Fixed0.2.1 (2007-04-23)0.2 (2007-04-17)0.1 (2007-04-13)Detailed DocumentationDefining ZEO Storage ServersSpecifying additional eggsUnix Deployment supportLog rotationPacking cron jobshell start scriptsNamesFeedback when you make mistakesDownloadChanges3.0 (2023-02-07)Add support for Python 3.7, 3.8, 3.9, 3.10, 3.11.Drop support for Python < 3.7.2.0.0 (2014-02-12)This release isn’t backward compatibleIt uses ZODB, rather than ZODB3.Added Python 3 supportChanged from ZODB3 to ZODB.0.6.2 (2012-10-31)Bugs FixedMoved ‘zope.testing’ requirement from install to test requirement.0.6.1 (2010-05-25)Bugs FixedPack scripts were incorrectly generated for storages that weren’t
named in their storage configurations.0.6.0 (2009-12-03)New FeaturesGeneration of a logrotate configuration can now be disabled by
providing a logrotate option with a value of “false”.Added documentation of the eggs option and why it generally
shouldn’t be used.Improved error handling.Bugs FixedThe eggs option, when used, wasn’t handled properly.0.5.0 (2008-11-03)New FeaturesYou can now specify a name option in server parts to have installed
files use a different name than the section name.Bugs FixedPack crontab files weren’t removed when parts were removed or renamed.0.4 (2008-02-18)New FeaturesThe server recipe now honors the deployment name option.0.3.1 (2008-01-03)Bugs FixedShell-scripts using su weren’t generated correctly.0.3 (2008-01-03)New FeaturesYou can now specify an email address in a packing crontab file to
control where errors are sent.If you install a general ZEO script, using a zdaemon part:[zdaemon]
recipe = zc.recipe.egg:script
eggs = zdaemonyou can request that shell scripts be generated that use the generic
zdaemon script. This can make updating software for deployed systems
easier since instance-specific scripts don’t depend on paths, like
egg names, that are likely to change.Bugs FixedZODB3 and most of its requirements were spurious dependencies of the
recipes. This caused ZODB3 to be installed using the Python used to
run the buildout, which caused problems in some circumstances.0.2.1 (2007-04-23)Bugs Fixedcrontab and logrotate configuration files were being generates incorrectly.0.2 (2007-04-17)Added handling of %import directives.0.1 (2007-04-13)Initial release.Detailed DocumentationDefining ZEO Storage ServersThe zc.zodbrecipes:server recipe can be used to define ZEO storage
servers. To define a storage server, you define a part for the server
and specify configuration data.>>> write('buildout.cfg',
... '''
... [buildout]
... parts = server
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... ''')Here we specified a minimal configuration using a “foo” storage.  We
can use any kind of storage we want.  Here we used an import statement
to import the schema definition that defined the foo section.  Any
imports are simply copied to the generated configuration file.  When
we run the buildout:>>> print(system(buildout), end='') # doctest: +NORMALIZE_WHITESPACE
Installing server.
zc.zodbrecipes:
A runzeo script couldn't be found at:
<BLANKLINE>
  '/sample-buildout/bin/runzeo'
<BLANKLINE>
You may need to generate a runzeo script using the
zc.recipe.eggs:script recipe and the ZEO egg, or you may need
to specify the location of a script using the runzeo option.
<BLANKLINE>
Generated script '/sample-buildout/bin/server'.We got a warning because the recipe expects there to be a runzeo
script and we haven’t created one.  This is done using the
zc.recipe.egg:script recipe:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... ''')>>> print(system(buildout), end='') # doctest: +ELLIPSIS
Installing zodb...
Generated script '/sample-buildout/bin/runzeo'...
Updating server.We get 2 things.  We get a directory in parts containing ZEO and
zdaemon configuration files:>>> ls('parts', 'server')
-  zdaemon.conf
-  zeo.confLet’s look at the configuration files:>>> cat('parts', 'server', 'zeo.conf')
%import foo
<BLANKLINE>
<zeo>
  address 8100
  monitor-address 8101
  transaction-timeout 300
</zeo>
<BLANKLINE>
<foo>
  path /databases/Data.fs
</foo>
<BLANKLINE>
<eventlog>
  <logfile>
    path STDOUT
  </logfile>
</eventlog>We see the same data we input with the addition of an eventlog section
that directs logging to standard out.  In production, we’ll use
zdaemon’s transacript log to capture this logging output in a file.
If we wish, we can specify a log file ourselves:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
...    <eventlog>
...      <logfile>
...        path /var/log/zeo.log
...      </logfile>
...    </eventlog>
... ''')>>> print(system(buildout), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/bin/server'.>>> cat('parts', 'server', 'zeo.conf')
%import foo
<BLANKLINE>
<zeo>
  address 8100
  monitor-address 8101
  transaction-timeout 300
</zeo>
<BLANKLINE>
<foo>
  path /databases/Data.fs
</foo>
<BLANKLINE>
<eventlog>
  <logfile>
    path /var/log/zeo.log
  </logfile>
</eventlog>But we’ll stick with the default:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... ''')>>> print(system(buildout), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/bin/server'.Let’s look at the zdaemon log file:>>> cat('parts', 'server', 'zdaemon.conf')
<runner>
  daemon on
  directory /sample-buildout/parts/server
  program /sample-buildout/bin/runzeo -C /sample-buildout/parts/server/zeo.conf
  socket-name /sample-buildout/parts/server/zdaemon.sock
  transcript /sample-buildout/parts/server/zeo.log
</runner>
<BLANKLINE>
<eventlog>
  <logfile>
    path /sample-buildout/parts/server/zeo.log
  </logfile>
</eventlog>We run the runzeo script with the zeo.conf file.  Log and run-time
files are places in the server part directory.  We use a transcript
log to provide the ZEO server log.  I like to use the transacriot log
because it captures program output, such as start-up exceptions that
aren’t captured in a program’s logs.And we get a control script generated in our bin directory:>>> cat('bin', 'server')  # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
#!/usr/local/bin/python2.4
<BLANKLINE>
import sys
sys.path[0:0] = [...]
<BLANKLINE>
<BLANKLINE>
import zdaemon.zdctl
<BLANKLINE>
if __name__ == '__main__':
    sys.exit(zdaemon.zdctl.main([
        '-C', '/sample-buildout/parts/server/zdaemon.conf',
        ]+sys.argv[1:]
        ))This is a zdaemon script.  We can use this to control the ZEO server
process.Specifying additional eggsYou can specify additional eggs to be installed for use by the
zdaemon script:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... eggs = zope.event
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... ''')>>> print(system(buildout), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/bin/server'.We can see the zope.event egg present in the control script
generated in our bin directory:>>> cat('bin', 'server')  # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
#!/usr/local/bin/python2.4
<BLANKLINE>
import sys
sys.path[0:0] = [...]
<BLANKLINE>
import zdaemon.zdctl
<BLANKLINE>
if __name__ == '__main__':
    sys.exit(zdaemon.zdctl.main([
        '-C', '/sample-buildout/parts/server/zdaemon.conf',
        ]+sys.argv[1:]
        ))NB: This is a zdaemon script. If your ZEO server needs additional eggs, such asto provide additional storage types or log handlers, they should appear in
[zodb] section in the above example, NOT the [server] section!Unix Deployment supportThe server recipe works with the zc.recipe.deployment.  In particular,
if a deployment option is specified, it names a part or section that
defines the following uptions:crontab-directoryA directory for crontab files.etc-directoryA directory for configuration files.log-directoryA directory for log files.logrotate-directoryA directory for logrotate configuration files.rc-directoryA directory for run-control scripts.run-directoryA directory for run-time files.userThe user the server process should run asLet’s create some directories and add a deployment section to our
buildout:>>> for d in 'cron', 'etc', 'log', 'rotate', 'rc', 'run':
...     mkdir(d)
...     globals()[d] = join(sample_buildout, d)>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
...
... [demo]
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/rc/demo-server'.Now, the parts directory and the control script will be gone:>>> import os
>>> os.path.exists(join('parts', 'server'))
False
>>> os.path.exists(join('bin', 'server'))
FalseInstead, the control script will be in the rc directory:>>> cat('rc', 'demo-server')  # doctest: +NORMALIZE_WHITESPACE +ELLIPSIS
#!/usr/local/bin/python2.4
<BLANKLINE>
import sys
sys.path[0:0] = [...]
<BLANKLINE>
import zdaemon.zdctl
<BLANKLINE>
if __name__ == '__main__':
    sys.exit(zdaemon.zdctl.main([
        '-C', '/sample-buildout/etc/server-zdaemon.conf',
        ]+sys.argv[1:]
        ))The run-control script name now combines the deployment name and the
script name.and the configuration files will be in the etc directory:>>> ls('etc')
-  server-zdaemon.conf
-  server-zeo.confLog rotationIf a deployment is used, we’ll also get a logrotate configuration file:>>> cat('rotate', 'demo-server')
/sample-buildout/log/server-zeo.log {
  rotate 5
  weekly
  postrotate
    /sample-buildout/rc/demo-server -C /sample-buildout/etc/server-zdaemon.conf reopen_transcript
  endscript
}This will rotate the zeo log file once a week.If we look at the zdaemon configuration file, we can see that it reflects
the deployment locations:>>> cat('etc', 'server-zdaemon.conf')
<runner>
  daemon on
  directory /sample-buildout/run
  program /sample-buildout/bin/runzeo -C /sample-buildout/etc/server-zeo.conf
  socket-name /sample-buildout/run/server-zdaemon.sock
  transcript /sample-buildout/log/server-zeo.log
  user bob
</runner>
<BLANKLINE>
<eventlog>
  <logfile>
    path /sample-buildout/log/server-zeo.log
  </logfile>
</eventlog>Note that different file names are used.  Since a deployment may be
(and usually is) shared by multiple parts, files are prefixed with
their part names.  Also note that the deployment user is set in the
zdaemon configuration.If you want to manage your own log rotation, you can place “logrotate = false”
in your deployment section to prevent the logrotate config being generated:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
...
... [demo]
... logrotate = false
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/rc/demo-server'.The logrotate config is not there, but the rc script still is:>>> ls('rotate')
>>> ls('rc')
-  demo-serverIf it’s more convenient, this can be placed in the [server] section instead:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
... logrotate = false
...
... [demo]
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout), end='')
Updating zodb.
Updating server.The logrotate config is not there, but the rc script still is:>>> ls('rotate')
>>> ls('rc')
-  demo-serverPacking cron jobWe can request definition of a cron job to pack the databases by
specifying a pack option.  This option takes 5 to 7 values.  The
first 5 values are the time and date fields defined by Unix crontab
files. The sixth field is the number of days in the past to pack to and
defaults to 1.Let’s add a pack option:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
... pack = 1 1 * * 0 3
...
... [demo]
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout+' -D'), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/rc/demo-server'.Now, we’ll get a crontab file:>>> cat(cron, 'pack-demo-server')
1 1 * * 0 bob /sample-buildout/bin/zeopack -p 8100 -S 1 -d 3In this example, we’ll pack the databases every Sunday at 1:01 to 3
days.We can add an email address to the pack option.  If we do, then a
MAILTO variable will be added to the cron file:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
... pack = 1 1 * * 0 3 jim@zope.com
...
... [demo]
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout+' -D'), end='')
Uninstalling server.
Updating zodb.
Installing server.
Generated script '/sample-buildout/rc/demo-server'.>>> cat(cron, 'pack-demo-server')
MAILTO=jim@zope.com
1 1 * * 0 bob /sample-buildout/bin/zeopack -p 8100 -S 1 -d 3This causes email to be sent to the given address, rather than to the
user specified in the crontab file.shell start scriptsBy default, the startup scripts are generated Python scripts that use
the zdaemon module.  Sometimes, this is inconvenient. In particular,
when deploying software, generated Python scripts may break after a
software update because they contain pasths to software eggs. We can
request shell scripts that invoke a generic zdaemon script.  The shell
script only depends on the path to the zdaemon script, which generally
doesn’t change when updating softawre.To request a shell script, add a shell-script option with a true
value. We also need to cause a zdaemon script to be generated:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb zdaemon server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [zdaemon]
... recipe = zc.recipe.egg:script
... eggs = zdaemon
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
... pack = 1 1 * * 0 3 jim@zope.com
... shell-script = true
...
... [demo]
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout+' -D'), end='')
Uninstalling server.
Updating zodb.
Installing zdaemon.
Generated script '/sample-buildout/bin/zdaemon'.
Installing server.
zc.zodbrecipes: Generated shell script '/sample-buildout/rc/demo-server'.>>> cat('rc', 'demo-server')
#!/bin/sh
su bob -c \
  "/sample-buildout/bin/zdaemon -C '/sample-buildout/etc/server-zdaemon.conf' $*"NamesNames can be specified for deployments and for individual server
parts. These names determine names of files generated.>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb zdaemon server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [zdaemon]
... recipe = zc.recipe.egg:script
... eggs = zdaemon
...
... [server]
... name = Server
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    <zeo>
...       address 8100
...       monitor-address 8101
...       transaction-timeout 300
...    </zeo>
...    %%import foo
...    <foo>
...       path /databases/Data.fs
...    </foo>
... deployment = demo
... pack = 1 1 * * 0 3 jim@zope.com
... shell-script = true
...
... [demo]
... name = Demo
... crontab-directory = %(cron)s
... etc-directory = %(etc)s
... log-directory = %(log)s
... logrotate-directory = %(rotate)s
... rc-directory = %(rc)s
... run-directory = %(run)s
... user = bob
... ''' % globals())>>> print(system(buildout+' -D'), end='')
Uninstalling server.
Updating zodb.
Updating zdaemon.
Installing server.
zc.zodbrecipes: Generated shell script '/sample-buildout/rc/Demo-Server'.>>> ls(cron)
-  pack-Demo-Server>>> ls(etc)
-  Server-zdaemon.conf
-  Server-zeo.conf>>> ls(rotate)
-  Demo-Server>>> ls(rc)
-  Demo-ServerFeedback when you make mistakesIf you make a mistake in your zeo.conf, some errors will result in a
simple, informative message being returned:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf =
...    nothing useful
... ''')>>> print(system(buildout+' -q'), end='')
Couldn't clean up '/sample-buildout/bin/server'.
While:
  Installing server.
Error: No zeo section was defined.If your zeo.conf has a syntax error, you’ll get shown the problematic
text and the message from the error:>>> write('buildout.cfg',
... '''
... [buildout]
... parts = zodb server
...
... [zodb]
... recipe = zc.recipe.egg:script
... eggs = ZEO
...
... [server]
... recipe = zc.zodbrecipes:server
... zeo.conf = <bad
... ''')>>> print(system(buildout+' -q'), end='')
Couldn't clean up '/sample-buildout/bin/server'.
While:
  Installing server.
Error: malformed section start (line 1) in:
<bad
<BLANKLINE>Download