source: trunk/factory/src/backends/__init__.py @ 161

# Officeshots.org - Test your office documents in different applications
# Copyright (C) 2009 Stichting Lone Wolves
# Written by Sander Marechal <s.marechal@jejik.com>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""
The core backend class
"""

import os
import base64
import logging

class BackendException:
        """
        A base Backend exception class. Backends should derive their own
        exceptions from this.

        When the Factory catches this exception and recoverable is False, then
        the backend will be unloaded.
        """
        def __init__(self, message, recoverable = False):
                self.message = message
                self.recoverable = recoverable
        
        def __str__(self):
                if self.recoverable:
                        return self.message + ' (Recoverable)'
                return self.message + ' (Not recoverable)'

class Backend:
        """
        The base backend class. Backends shoudl derive from this
        """
        def __init__(self, options, config, section):
                self.options = options
                self.config = config
                self.section = section

                self.application = config.get(section, 'application')
                self.version = config.get(section, 'version')
                self.doctype = config.get(section, 'doctype')
                self.formats = [s.strip() for s in config.get(section, 'formats').split(',')]
        
        def initialize(self):
                """
                This is called right after instanciating the backend.
                """
                pass    

        def can_process(self, job):
                """
                Return True if this backend is eligable to process this Job, False otherwise
                """
                eligable = (
                        job['application'] == self.application and
                        job['version'] == self.version and
                        job['doctype'] == self.doctype and
                        (job['format'] == '' or job['format'] in self.formats)
                )
                return eligable

        def process(self, job):
                """
                Process a job. Backends must override this method.
                """
                raise NotImplementedError

        def save_document(self, job):
                """
                Save the file in a job to a temporary location and return the full path.
                Note that the job ID is used to form the name rather than the original filename
                to help avoid collisions.
                """
                if not 'job' in job or not 'filename' in job or not 'doctype' in job or not 'document' in job:
                        raise BackendException('Could not save job document to temporary file. Invalid job.', True)

                (root, ext) = os.path.splitext(job['filename'])
                tmp_dir = os.path.normpath(self.config.get('global', 'tmp_files'))
                if not os.path.exists(tmp_dir):
                        logging.info('Temporary storage %s does not exist. Attempting to create', tmp_dir)
                        try:
                                os.makedirs(tmp_dir)
                        except OSError:
                                raise BackendException('Could not create temporary storage location %s' % tmp_dir)
                
                filename = os.path.join(tmp_dir, job['job'] + ext)
                logging.debug('Temporary filename: %s' % filename)
                try:
                        file = open(filename, 'wb')
                        file.write(base64.b64decode(job['document']))
                        file.close()
                except (IOError):
                        raise BackendException('Could not write temporary file %s' % filename)
                except TypeError:
                        raise BackendException('Document is not base64 encoded', True)

                return filename

        def load_document(self, path, encode=True):
                try:
                        file = open(path, 'rb')
                        contents = file.read()
                        file.close()
                except (IOError):
                        raise BackendException('Could not read file %s' % path)

                if encode:
                        contents = base64.b64encode(contents)
                return contents