from mediagoblin import mg_globals
from mediagoblin.db.models import MediaEntry
from mediagoblin.gmg_commands import util as commands_util
+from mediagoblin.submit.lib import run_process_media
from mediagoblin.tools.translate import lazy_pass_to_ugettext as _
from mediagoblin.tools.pluginapi import hook_handle
-from mediagoblin.processing import ProcessorDoesNotExist, ProcessorNotEligible
+from mediagoblin.processing import (
+ ProcessorDoesNotExist, ProcessorNotEligible,
+ get_entry_and_manager, get_manager_for_type)
def reprocess_parser_setup(subparser):
args[0].state = 'processed'
-class MediaEntryNotFound(Exception): pass
-
-def extract_entry_and_type(media_id):
- """
- Fetch a media entry, as well as its media type
- """
- entry = MediaEntry.query.filter_by(id=media_id).first()
- if entry is None:
- raise MediaEntryNotFound("Can't find media with id '%s'" % media_id)
-
- return entry.media_type, entry
-
-
def available(args):
# Get the media type, either by looking up media id, or by specific type
try:
- media_id = int(args.id_or_type)
- media_type, media_entry = extract_entry_and_type(media_id)
+ media_entry, manager = get_entry_and_manager(args.id_or_type)
+ media_type = media_entry.type
except ValueError:
media_type = args.id_or_type
media_entry = None
+ manager = get_manager_for_type(media_type)
- manager_class = hook_handle(('reprocess_manager', media_type))
- manager = manager_class()
-
if media_entry is None:
processors = manager.list_all_processors()
else:
def run(args):
- media_type, media_entry = extract_entry_and_type(args.media_id)
-
- manager_class = hook_handle(('reprocess_manager', media_type))
- manager = manager_class()
+ media_entry, manager = get_entry_and_manager(args.media_id)
# TODO: (maybe?) This could probably be handled entirely by the
# processor class...
reprocess_parser = processor_class.generate_parser()
reprocess_args = reprocess_parser.parse_args(args.reprocess_args)
reprocess_request = processor_class.args_to_request(reprocess_args)
- processor = processor_class(manager, media_entry)
- processor.process(**reprocess_request)
+ run_process_media(
+ media_entry,
+ reprocess_action=args.reprocess_command,
+ reprocess_info=reprocess_request)
+ manager.process(media_entry, args.reprocess_command, **reprocess_request)
def reprocess(args):
import logging
import os
-from mediagoblin.db.util import atomic_update
from mediagoblin import mg_globals as mgg
-
+from mediagoblin.db.util import atomic_update
+from mediagoblin.db.models import MediaEntry
+from mediagoblin.tools.pluginapi import hook_handle
from mediagoblin.tools.translate import lazy_pass_to_ugettext as _
_log = logging.getLogger(__name__)
return processor
- def process(self, entry, directive, request):
+ def process_from_args(self, entry, reprocess_command, request):
"""
Process a media entry.
"""
return request
+class MediaEntryNotFound(Exception): pass
+
+
+def get_manager_for_type(media_type):
+ """
+ Get the appropriate media manager for this type
+ """
+ manager_class = hook_handle(('reprocess_manager', media_type))
+ manager = manager_class()
+
+ return manager
+
+
+def get_entry_and_manager(media_id):
+ """
+ Get a MediaEntry, its media type, and its manager all in one go.
+
+ Returns a tuple of: `(entry, media_type, media_manager)`
+ """
+ entry = MediaEntry.query.filter_by(id=media_id).first()
+ if entry is None:
+ raise MediaEntryNotFound("Can't find media with id '%s'" % media_id)
+
+ manager = get_manager_for_type(entry.media_type)
+
+ return entry, manager
+
+
+################################################
+# TODO: This ProcessingState is OUTDATED,
+# and needs to be refactored into other tools!
+################################################
+
class ProcessingState(object):
"""
The first and only argument to the "processor" of a media type
from celery import registry, task
from mediagoblin import mg_globals as mgg
-from mediagoblin.db.models import MediaEntry
-from . import mark_entry_failed, BaseProcessingFail, ProcessingState
+from . import mark_entry_failed, BaseProcessingFail
from mediagoblin.tools.processing import json_processing_callback
+from mediagoblin.processing import get_entry_and_manager
_log = logging.getLogger(__name__)
logging.basicConfig()
"""
Pass this entry off for processing.
"""
- def run(self, media_id, feed_url, reprocess_info=None):
+ def run(self, media_id, feed_url, reprocess_action, reprocess_info=None):
"""
Pass the media entry off to the appropriate processing function
(for now just process_image...)
:param reprocess: A dict containing all of the necessary reprocessing
info for the media_type.
"""
- entry = MediaEntry.query.get(media_id)
+ reprocess_info = reprocess_info or {}
+ entry, manager = get_entry_and_manager(media_id)
# Try to process, and handle expected errors.
try:
+ processor_class = manager.get_processor(reprocess_action, entry)
+
entry.state = u'processing'
entry.save()
_log.debug('Processing {0}'.format(entry))
- proc_state = ProcessingState(entry)
- with mgg.workbench_manager.create() as workbench:
-
- proc_state.set_workbench(workbench)
- processor = entry.media_manager.processor(proc_state)
-
- # If we have reprocess_info, let's reprocess
- if reprocess_info:
- processor.reprocess(reprocess_info)
-
- # Run initial processing
- else:
- processor.initial_processing()
+ with processor_class(manager, entry) as processor:
+ processor.process(**reprocess_info)
# We set the state to processed and save the entry here so there's
# no need to save at the end of the processing stage, probably ;)
return queue_file
-def run_process_media(entry, feed_url=None, reprocess_info=None):
+def run_process_media(entry, feed_url=None,
+ reprocess_action="inital", reprocess_info=None):
"""Process the media asynchronously
:param entry: MediaEntry() instance to be processed.
should be notified of. This will be sth like: `request.urlgen(
'mediagoblin.user_pages.atom_feed',qualified=True,
user=request.user.username)`
- :param reprocess: A dict containing all of the necessary reprocessing
+ :param reprocess_action: What particular action should be run.
+ :param reprocess_info: A dict containing all of the necessary reprocessing
info for the given media_type"""
try:
process_media.apply_async(
- [entry.id, feed_url, reprocess_info], {},
+ [entry.id, feed_url, reprocess_action, reprocess_info], {},
task_id=entry.queued_task_id)
except BaseException as exc:
# The purpose of this section is because when running in "lazy"
projects / mediagoblin.git / commitdiff