# 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/>.
-from collections import OrderedDict
+# Use an ordered dict if we can. If not, we'll just use a normal dict
+# later.
+try:
+ from collections import OrderedDict
+except:
+ OrderedDict = None
+
import logging
import os
+import six
+
from mediagoblin import mg_globals as mgg
from mediagoblin.db.util import atomic_update
from mediagoblin.db.models import MediaEntry
def __call__(self, progress):
if progress:
- self.entry.transcoding_progress = progress
+ if 100 - (self.entry.transcoding_progress + progress) < 0.01:
+ self.entry.transcoding_progress = 100
+ else:
+ self.entry.transcoding_progress += progress
self.entry.save()
def create_pub_filepath(entry, filename):
return mgg.public_store.get_unique_filepath(
['media_entries',
- unicode(entry.id),
+ six.text_type(entry.id),
filename])
"""
def __init__(self):
# Dict of all MediaProcessors of this media type
- self.processors = OrderedDict()
+ if OrderedDict is not None:
+ self.processors = OrderedDict()
+ else:
+ self.processors = {}
def add_processor(self, processor):
"""
try:
processor = self.processors[key]
except KeyError:
- import pdb
- pdb.set_trace()
raise ProcessorDoesNotExist(
"'%s' processor does not exist for this media type" % key)
return processor
+ def workflow(self, entry, feed_url, reprocess_action, reprocess_info=None):
+ """
+ Returns the Celery command needed to proceed with media processing
+ """
+ return None
+
def request_from_args(args, which_args):
"""
store extra information that can be useful for users telling them
why their media failed to process.
- Args:
- - entry_id: The id of the media entry
+ :param entry_id: The id of the media entry
+ :param exc: An instance of BaseProcessingFail
"""
# Was this a BaseProcessingFail? In other words, was this a
atomic_update(mgg.database.MediaEntry,
{'id': entry_id},
{u'state': u'failed',
- u'fail_error': unicode(exc.exception_path),
+ u'fail_error': six.text_type(exc.exception_path),
u'fail_metadata': exc.metadata})
else:
_log.warn("No idea what happened here, but it failed: %r", exc)
- # Looks like no, so just mark it as failed and don't record a
- # failure_error (we'll assume it wasn't handled) and don't record
- # metadata (in fact overwrite it if somehow it had previous info
- # here)
+ # Looks like no, let's record it so that admin could ask us about the
+ # reason
atomic_update(mgg.database.MediaEntry,
{'id': entry_id},
{u'state': u'failed',
- u'fail_error': None,
+ u'fail_error': u'Unhandled exception: {0}'.format(
+ six.text_type(exc)),
u'fail_metadata': {}})
entry.media_files[keyname], target_filepath)
if delete_if_exists:
mgg.public_store.delete_file(entry.media_files[keyname])
-
try:
mgg.public_store.copy_local_to_storage(local_file, target_filepath)
- except:
+ except Exception as e:
+ _log.error(u'Exception happened: {0}'.format(e))
raise PublicStoreFail(keyname=keyname)
-
# raise an error if the file failed to copy
- copied_filepath = mgg.public_store.get_local_path(target_filepath)
- if not os.path.exists(copied_filepath):
+ if not mgg.public_store.file_exists(target_filepath):
raise PublicStoreFail(keyname=keyname)
entry.media_files[keyname] = target_filepath
return u"%s:%s" % (
self.__class__.__module__, self.__class__.__name__)
- def __init__(self, **metadata):
- self.metadata = metadata or {}
+ def __init__(self, message=None, **metadata):
+ if message is not None:
+ super(BaseProcessingFail, self).__init__(message)
+ metadata['message'] = message
+ self.metadata = metadata
class BadMediaFail(BaseProcessingFail):
"""