mediagoblin/media_types/image/processing.py

   1 # GNU MediaGoblin -- federated, autonomous media hosting
   2 # Copyright (C) 2011 MediaGoblin contributors.  See AUTHORS.
   3 #
   4 # This program is free software: you can redistribute it and/or modify
   5 # it under the terms of the GNU Affero General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU Affero General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 import Image
  18
  19 from celery.task import Task
  20 from celery import registry
  21
  22 from mediagoblin.db.util import ObjectId
  23 from mediagoblin import mg_globals as mgg
  24
  25 from mediagoblin.util import lazy_pass_to_ugettext as _
  26
  27 from mediagoblin.process_media.errors import *
  28
  29 THUMB_SIZE = 180, 180
  30 MEDIUM_SIZE = 640, 640
  31
  32
  33 def create_pub_filepath(entry, filename):
  34     return mgg.public_store.get_unique_filepath(
  35             ['media_entries',
  36              unicode(entry['_id']),
  37              filename])
  38
  39 ################################
  40 # Media processing initial steps
  41 ################################
  42
  43 class ProcessMedia(Task):
  44     """
  45     Pass this entry off for processing.
  46     """
  47     def run(self, media_id):
  48         """
  49         Pass the media entry off to the appropriate processing function
  50         (for now just process_image...)
  51         """
  52         entry = mgg.database.MediaEntry.one(
  53             {'_id': ObjectId(media_id)})
  54
  55         # Try to process, and handle expected errors.
  56         try:
  57             process_image(entry)
  58         except BaseProcessingFail, exc:
  59             mark_entry_failed(entry[u'_id'], exc)
  60             return
  61
  62         entry['state'] = u'processed'
  63         entry.save()
  64
  65     def on_failure(self, exc, task_id, args, kwargs, einfo):
  66         """
  67         If the processing failed we should mark that in the database.
  68
  69         Assuming that the exception raised is a subclass of BaseProcessingFail,
  70         we can use that to get more information about the failure and store that
  71         for conveying information to users about the failure, etc.
  72         """
  73         entry_id = args[0]
  74         mark_entry_failed(entry_id, exc)
  75
  76
  77 process_media = registry.tasks[ProcessMedia.name]
  78
  79
  80 def mark_entry_failed(entry_id, exc):
  81     """
  82     Mark a media entry as having failed in its conversion.
  83
  84     Uses the exception that was raised to mark more information.  If the
  85     exception is a derivative of BaseProcessingFail then we can store extra
  86     information that can be useful for users telling them why their media failed
  87     to process.
  88
  89     Args:
  90      - entry_id: The id of the media entry
  91
  92     """
  93     # Was this a BaseProcessingFail?  In other words, was this a
  94     # type of error that we know how to handle?
  95     if isinstance(exc, BaseProcessingFail):
  96         # Looks like yes, so record information about that failure and any
  97         # metadata the user might have supplied.
  98         mgg.database['media_entries'].update(
  99             {'_id': entry_id},
 100             {'$set': {u'state': u'failed',
 101                       u'fail_error': exc.exception_path,
 102                       u'fail_metadata': exc.metadata}})
 103     else:
 104         # Looks like no, so just mark it as failed and don't record a
 105         # failure_error (we'll assume it wasn't handled) and don't record
 106         # metadata (in fact overwrite it if somehow it had previous info
 107         # here)
 108         mgg.database['media_entries'].update(
 109             {'_id': entry_id},
 110             {'$set': {u'state': u'failed',
 111                       u'fail_error': None,
 112                       u'fail_metadata': {}}})
 113
 114
 115 def process_image(entry):
 116     """
 117     Code to process an image
 118     """
 119     workbench = mgg.workbench_manager.create_workbench()
 120
 121     queued_filepath = entry['queued_media_file']
 122     queued_filename = workbench.localized_file(
 123         mgg.queue_store, queued_filepath,
 124         'source')
 125
 126     try:
 127         thumb = Image.open(queued_filename)
 128     except IOError:
 129         raise BadMediaFail()
 130
 131     thumb.thumbnail(THUMB_SIZE, Image.ANTIALIAS)
 132     # ensure color mode is compatible with jpg
 133     if thumb.mode != "RGB":
 134         thumb = thumb.convert("RGB")
 135
 136     thumb_filepath = create_pub_filepath(entry, 'thumbnail.jpg')
 137     thumb_file = mgg.public_store.get_file(thumb_filepath, 'w')
 138
 139     with thumb_file:
 140         thumb.save(thumb_file, "JPEG", quality=90)
 141
 142     # If the size of the original file exceeds the specified size of a `medium`
 143     # file, a `medium.jpg` files is created and later associated with the media
 144     # entry.
 145     medium = Image.open(queued_filename)
 146     medium_processed = False
 147
 148     if medium.size[0] > MEDIUM_SIZE[0] or medium.size[1] > MEDIUM_SIZE[1]:
 149         medium.thumbnail(MEDIUM_SIZE, Image.ANTIALIAS)
 150
 151         if medium.mode != "RGB":
 152             medium = medium.convert("RGB")
 153
 154         medium_filepath = create_pub_filepath(entry, 'medium.jpg')
 155         medium_file = mgg.public_store.get_file(medium_filepath, 'w')
 156
 157         with medium_file:
 158             medium.save(medium_file, "JPEG", quality=90)
 159             medium_processed = True
 160
 161     # we have to re-read because unlike PIL, not everything reads
 162     # things in string representation :)
 163     queued_file = file(queued_filename, 'rb')
 164
 165     with queued_file:
 166         original_filepath = create_pub_filepath(entry, queued_filepath[-1])
 167
 168         with mgg.public_store.get_file(original_filepath, 'wb') as original_file:
 169             original_file.write(queued_file.read())
 170
 171     mgg.queue_store.delete_file(queued_filepath)
 172     entry['queued_media_file'] = []
 173     media_files_dict = entry.setdefault('media_files', {})
 174     media_files_dict['thumb'] = thumb_filepath
 175     media_files_dict['original'] = original_filepath
 176     if medium_processed:
 177         media_files_dict['medium'] = medium_filepath
 178
 179     # clean up workbench
 180     workbench.destroy_self()