Skip to content
ZODB blob support integration for Plone
Python Shell
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.


ZODB 3.8 blob support for Plone


This package aims to be an add-on for Plone 3.x integrating ZODB 3.8's blob
support, which allows large binary data to be managed by the ZODB, but
separately from your usual ``FileStorage`` database, i.e. ``Data.fs``.  This
has several advantages, most importantly a much smaller ``Data.fs`` and better
performance both cpu- as well as memory-wise.


At the moment the integration is in a working state, but needs more field
testing.  The provided blob-based content type should be more or less safely
usable as a drop-in replacement for ``ATFile``. As such it has been
successfully tested against all ``CMFPlone`` and ``ATContentTypes`` tests.
Instructions for replicating the necessary test setup and running these tests
yourself can be found at

More detailed an up-to-date information about the integration and the current
status can be found in the corresponding `plone enhancement ticket`_.

  .. _`plone enhancement ticket`:
  .. |--| unicode:: U+2013   .. en dash
  .. |---| unicode:: U+2014  .. em dash


Plone 3.0 or newer is required. The package has been tested with all versions
from 3.0 up to and including 3.0.4. However, as all versions before 3.0.4
require a workaround described in the `Troubleshooting`_ section below, it is
recommended to use `Plone 3.0.4`_.

  .. _`Plone 3.0.4`:


The easiest way to get ZODB blob support in Plone 3 using this package is to
work with installations based on `zc.buildout`_.  Other types of installations
should also be possible, but might turn out to be somewhat tricky |---| please
see the `FAQ`_ section below.

To get started you will simply need to add the package to your "eggs" and
"zcml" sections, run buildout, restart your Plone instance and install the
"" package using the quick-installer or via the "Add-on
Products" section in "Site Setup".

  .. _`zc.buildout`:

A sample buildout configuration file, i.e. ``buildout.cfg``, could look like

  parts = plone zope2 instance
  find-links =
  eggs = elementtree

  recipe = plone.recipe.plone

  recipe = plone.recipe.zope2install
  url = ${plone:zope2-url}

  recipe = plone.recipe.zope2instance
  zope2-location = ${zope2:location}
  blob-storage = var/blobstorage
  user = admin:admin
  products = ${plone:products}
  eggs =
  zcml =

You can also use this buildout configuration to create a fresh Plone
installation. To do so you would store it as ``buildout.cfg`` |---| preferably
in an empty directory, download `
into the same directory and issue the following commands::

  $ python
  $ ./bin/buildout
  $ ./bin/instance fg

After that you create a "Plone Site" via the `ZMI`_ as usual and either
select the "" extension profile at creation time or again
install the "" package using one of the above mentioned methods.

  .. _`ZMI`: http://localhost:8080/manage

For your convenience a working buildout configuration, including
```` and ``buildout.cfg``, is provided as a subversion checkout at

  .. __:

A sample ZEO buildout configuration could look like this::

  parts = plone zope2 zeo client1 client2
  find-links =
  eggs = elementtree

  recipe = plone.recipe.plone

  recipe = plone.recipe.zope2install
  url = ${plone:zope2-url}

  recipe = plone.recipe.zope2zeoserver
  zope2-location = ${zope2:location}
  zeo-address =
  zeo-var = ${buildout:directory}/var
  blob-storage = ${zeo:zeo-var}/blobstorage 
  eggs =

  recipe = plone.recipe.zope2instance
  zope2-location = ${zope2:location}
  zeo-address = ${zeo:zeo-address}
  blob-storage = ${zeo:blob-storage}
  zeo-client = on
  shared-blob = on
  user = admin:admin
  products = ${plone:products}
  eggs =
  zcml =

  recipe = plone.recipe.zope2instance
  http-address = 8081
  zope2-location = ${client1:zope2-location}
  zeo-client = ${client1:zeo-client}
  zeo-address = ${client1:zeo-address}
  blob-storage = ${client1:blob-storage}
  shared-blob = ${client1:shared-blob}
  user = ${client1:user}
  products = ${client1:products}
  eggs = ${client1:eggs}
  zcml = ${client1:zcml}

More detailed instructions on how to set things up as well as some background
information on blobs |---| or in other words the story of an "early adopter"
|---| can be found in `Ken Manheimer's wiki`__.  This is a highly useful
resource and recommended read for people trying to give blobs a spin.  Please
note however, that most of the recipe changes described in these instructions
have already been incorporated in the particular recipes by now.

  .. __:

In addition, more information on how to use buildout is available in the
`accompanying README.txt`__ as well as in `Martin's`_ excellent `buildout
tutorial`_ on ``_.

  .. __:
  .. _`Martin's`:
  .. _`buildout tutorial`:
  .. _``:

Migrating existing content

In-place content migration is provided for existing ``ATFile`` content. The
`Products.contentmigration`_ package is required for this to work. To install
this package you will again need to add its name to the "eggs" and "zcml"
section of your ``buildout.cfg``, so that it reads like::

  eggs =
  zcml =

You can also refer to the above mentioned `sample buildout.cfg`_ for details.

  .. _`Products.contentmigration`:
  .. _`sample buildout.cfg`:

In order to then migrate your existing file content to blobs you can use the
migration interface provided at http://localhost:8080/plone/@@blob-migration,
where "plone" should be replaced with the id of your "Plone Site" object.  The
page will show you the number of available ``ATFile`` instances and lets you
convert them to the provided blob content type by clicking a button.

If you encounter errors during migration |---| especially after applying the
"ATFile replacement" profile (or quick-installing " ATFile
replacement" for that matter) |---| please refer to the next section.


The following are some known issues, that will hopefully be resolved soon
enough.  In the meantime here are the recommended workarounds:

**"Invalid plugin id" Exception**

    When trying to create a "Plone Site" you're getting an error like::

      Error Type: KeyError
      Error Value: 'Invalid plugin id: credentials_basic_auth'
    Your version of ``Products.PluggableAuthService`` is too old |---| you need
    1.5.2 or newer (please see for more
    information about this).
    Please use the `provided buildout`_, add the `1.5 branch`_ as an
    `svn:external`_ to the ``products/`` directory of your buildout or
    upgrade to `Plone 3.0.4`_ by re-running buildout.

  .. _`provided buildout`:
  .. _`1.5 branch`:
  .. _`svn:external`:

**"unknown type name: 'blobstorage'"**

    When running buildout you're getting an error like::

      Error: unknown type name: 'blobstorage'
      (line 36 in file:///.../parts/instance/etc/zope.conf)
    Your version of the `plone.recipe.zope2instance`_ recipe is too old
    |---| you need to have at least version `1.0`_.
    Make sure you're running buildout with neither "``-N``" nor "``-o``" and
    you also don't have::

      newest = false

    in your ``~/.buildout/default.cfg``.  Alternatively, running buildout
    with option "``-n``" should update the recipe to the latest version.

  .. _`plone.recipe.zope2instance`:    
  .. _`1.0`:

**missing distribution for required "zdaemon" and "ZConfig" eggs**

    When running buildout you're getting errors like::

      Getting distribution for 'zdaemon>=1.4a2,<1.4.999'.
        Installing instance.
        Getting distribution for 'zdaemon>=1.4a2,<1.4.999'.
      Error: Couldn't find a distribution for 'zdaemon>=1.4a2,<1.4.999'.


      Getting distribution for 'ZConfig>=2.4a2,<2.4.999'.
        Installing instance.
        Getting distribution for 'ZConfig>=2.4a2,<2.4.999'.
      Error: Couldn't find a distribution for 'ZConfig>=2.4a2,<2.4.999'.
    ``zdaemon`` and ``ZConfig`` eggs have only been released to the
    `Cheeseshop`_ starting from more recent versions, i.e. 2.0 and 2.5
    respectively.  Older distributions in egg format are only available
    Add the above link to the ``find-links`` setting of the ``[buildout]``
    section in your ``buildout.cfg``, like::

      find-links =


  .. _`Cheeseshop`:

**"ZRPCError: bad handshake 'Z303'"**

    With a ZEO setup you are getting errors like::

      ZRPCError: bad handshake 'Z303'
    You probably haven't added ```` to the ``eggs`` setting in
    your ``[zeo]`` buildout part.  Without it the ZEO server will not use
    the required version 3.8 of ZODB and hence not support blobs.
    Add the string ```` to the ``eggs`` setting in the ``[zeo]``
    section (i.e. the one using the ``plone.recipe.zope2zeoserver`` recipe)
    in your ``buildout.cfg``, like::

      eggs =

**"AttributeError: 'NoneType' object has no attribute 'product'" during migration**

    After installing "" via the quick-installer or applying
    the " ATFile replacement" profile you are seeing migration
    errors like::
      Traceback (innermost last):
        Module ZPublisher.Publish, line 119, in publish
        Module ZPublisher.mapply, line 88, in mapply
        Module ZPublisher.Publish, line 42, in call_object
        Module, line 24, in __call__
        Module, line 42, in migrateATFiles
        Module Products.contentmigration.basemigrator.walker, line 126, in go
        Module Products.contentmigration.basemigrator.walker, line 205, in migrate
      MigrationError: MigrationError for obj at /... (File -> Blob):
      Traceback (most recent call last):
        File ".../Products/contentmigration/basemigrator/", line 174, in migrate
        File ".../Products/contentmigration/basemigrator/", line 185, in migrate
        File ".../Products/contentmigration/", line 111, in beforeChange_schema
          archetype = getType(self.dst_meta_type, fti.product)
      AttributeError: 'NoneType' object has no attribute 'product'
    The current migration code has been written to convert existing "File"
    content to the "Blob" content type provided by the base ""
    profile.  However, that type isn't known when just installing the "ATFile
    replacement" profile.  The latter is probably what you want to install,
    though, as former "File" content will keep the same portal type, i.e.
    "File" after being migrated.  This way no apparent changes are visible,
    which might help with avoiding confusion.
    For now you might work around this by either applying the ""
    profile via the ZMI in ``/portal_setup``.  This will install the above
    mentioned "Blob" content type.  After that migration will work, but your
    former "File" content will have the "Blob" content type.

    If that's not what you want, simply change line line 17 in
    ``plone/app/blob/`` (which is probably contained in an egg
    directory located somewhere like ``eggs/``
    relative to your buildout/installation) from::

       dst_portal_type = 'Blob'


       dst_portal_type = 'File'

    After that migration should use the new "File" type, based on ZODB blobs.
    Once you've migrated you might remove or disable the "Blob" type from
    ``/portal_types`` again.  A future version of "" will try
    auto-detect the correct target type for the migration (or at least allow
    to specify it) to make this more convenient.

    If you have already migrated to "Blob" content, but would rather like to
    have "File" items, you can change the two previous lines to::

       src_portal_type = 'Blob'
       src_meta_type = 'ATBlob'

    and re-run the blob migration.  This will convert your "Blob"s to show up
    as "File"s again.  You should probably pack your ZODB afterwards to avoid
    having its blob storage occupy twice as much disk space as actually
    needed (the extra migration will create new blobs).


Is it possible to use "" in installations not based on `zc.buildout`_?

  Yes, but that would require some additional steps, since it depends on ZODB 
  3.8, but Plone currently ships with Zope 2.10, which still comes with
  ZODB 3.7.  So, to make things work you could either install the `required
  versions`__ of all additionally needed packages into your ``lib/python/`` 
  directory or use the respective eggs and make sure they get preferred over      
  their older versions on ``import``, for example by setting up 

  .. __:

  Alternatively it should also be possible to install the package using 
  `easy_install`_, which would automatically install its dependencies 
  including ZODB 3.8, too.  Again you would need to set up your ``PYTHONPATH``
  to make sure the desired versions are used.  However, installing the package 
  like this is likely to have side effects on other Zope/Plone instances on
  your system, so you probably want to use `virtualenv`_ here at least.

  .. _`easy_install`:
  .. _`virtualenv`:

  Overall, to get started without too much pain, a buildout-based
  installation is recommended |---| for example the `provided buildout`_.

Will this be available for Plone 2.5.x?

  Yes, support for the 2.5 series is planned and next on the agenda.

What about image support, i.e. a drop-in for ``ATImage`` content?

  While just replacing the primary field in ``ATImage``'s schemata should
  probably already work quite well, proper image support is planned for a
  later release.  "proper" here means using a sub-typing approach as
  `presented by Rocky Burt`__ in Naples, which will have several advantages
  including a cleaner and better structured code, but will also take a little 
  longer to implement.

  .. __:

Strange messages like ``Exception exceptions.OSError: (2, 'No such file or
directory', '.../tmpZvxjZB') in <bound method _TemporaryFileWrapper.__del__ of
<closed file '<fdopen>', mode 'w+b' at 0x7317650>> ignored`` get written to
the logs whenever a file is uploaded. Is that an error or something to worry

  No, that's fine, it's just a small annoyance, that should be fixed
  eventually. In case you care, the problem is that the zope publisher creates
  a temporary file for each upload it receives.  Once the upload has finished
  that temporary file is passed to the blob machinery, which moves it into
  its blob storage.  However, at the end of the request the wrapper class for
  temporary files tries to remove the file as well, since well, it's supposed
  to be temporary.  At that time the file is already gone though, and the
  above warning is issued.

.. TODO: answer the following...
.. [4:59pm] <jonstahl> Given the overall clutter and confusion in the
..   broader file system storage product space, it might be helpful to expand
..   the Overview paragraph a bit. The things I'm wondering are: how does
..   Blob differ from FSS? Is it different from other blob implementations?
..   Are there things naive people might expect of that it
..   *doesn't* do? (e.g. massive increase the speed of serving large files.
..   This doesn't really fully replace tramline, right?
..  [4:59pm] <jonstahl> A bit of information on how you can use
.. in your custom content types might helpful too.


Any kind of feedback like bug reports, suggestions, feature requests and most
preferably success stories is most welcome and much appreciated. Especially,
it would be interesting to hear about success or problems with migration of
existing content and installations on platforms other than OSX.

So please feel free to post comments to the above mentioned `plone enhancement
ticket`_, file tickets in the `issue tracker`_ or contact me on `#plone`_,
through the `plone developer mailing list`_ or directly via `email`_.

  .. _`issue tracker`:
  .. _`#plone`: irc://
  .. _`plone developer mailing list`:
  .. _`email`: mailto:az_at_zitc_dot_de
Something went wrong with that request. Please try again.