mediagoblin/submit/views.py

   1 # GNU MediaGoblin -- federated, autonomous media hosting
   2 # Copyright (C) 2011, 2012 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 mediagoblin.mg_globals as mg_globals
  18 import uuid
  19 from os.path import splitext
  20 from cgi import FieldStorage
  21
  22 from celery import registry
  23 import urllib,urllib2
  24 import logging
  25
  26 _log = logging.getLogger(__name__)
  27
  28 from werkzeug.utils import secure_filename
  29
  30 from mediagoblin.db.util import ObjectId
  31 from mediagoblin.tools.text import cleaned_markdown_conversion, convert_to_tag_list_of_dicts
  32 from mediagoblin.tools.translate import pass_to_ugettext as _
  33 from mediagoblin.tools.response import render_to_response, redirect
  34 from mediagoblin.decorators import require_active_login
  35 from mediagoblin.submit import forms as submit_forms, security
  36 from mediagoblin.processing import mark_entry_failed, ProcessMedia
  37 from mediagoblin.messages import add_message, SUCCESS
  38 from mediagoblin.media_types import get_media_type_and_manager, \
  39     InvalidFileType, FileTypeNotSupported
  40
  41
  42 @require_active_login
  43 def submit_start(request):
  44     """
  45     First view for submitting a file.
  46     """
  47     submit_form = submit_forms.SubmitStartForm(request.POST)
  48
  49     if request.method == 'POST' and submit_form.validate():
  50         if not ('file' in request.POST
  51                 and isinstance(request.POST['file'], FieldStorage)
  52                 and request.POST['file'].file):
  53             submit_form.file.errors.append(
  54                 _(u'You must provide a file.'))
  55         else:
  56             try:
  57                 filename = request.POST['file'].filename
  58                 media_type, media_manager = get_media_type_and_manager(filename)
  59
  60                 # create entry and save in database
  61                 entry = request.db.MediaEntry()
  62                 entry['_id'] = ObjectId()
  63                 entry.media_type = unicode(media_type)
  64                 entry.title = (
  65                     unicode(request.POST['title'])
  66                     or unicode(splitext(filename)[0]))
  67
  68                 entry.description = unicode(request.POST.get('description'))
  69                 entry.description_html = cleaned_markdown_conversion(
  70                     entry.description)
  71
  72                 entry.license = unicode(request.POST.get('license', "")) or None
  73
  74                 entry.uploader = request.user._id
  75
  76                 # Process the user's folksonomy "tags"
  77                 entry.tags = convert_to_tag_list_of_dicts(
  78                     request.POST.get('tags'))
  79
  80                 # Generate a slug from the title
  81                 entry.generate_slug()
  82
  83
  84                 # Now store generate the queueing related filename
  85                 queue_filepath = request.app.queue_store.get_unique_filepath(
  86                     ['media_entries',
  87                      unicode(entry._id),
  88                      secure_filename(filename)])
  89
  90                 # queue appropriately
  91                 queue_file = request.app.queue_store.get_file(
  92                     queue_filepath, 'wb')
  93
  94                 with queue_file:
  95                     queue_file.write(request.POST['file'].file.read())
  96
  97                 # Add queued filename to the entry
  98                 entry.queued_media_file = queue_filepath
  99
 100                 # We generate this ourselves so we know what the taks id is for
 101                 # retrieval later.
 102
 103                 # (If we got it off the task's auto-generation, there'd be
 104                 # a risk of a race condition when we'd save after sending
 105                 # off the task)
 106                 task_id = unicode(uuid.uuid4())
 107                 entry['queued_task_id'] = task_id
 108
 109                 # Save now so we have this data before kicking off processing
 110                 entry.save(validate=True)
 111
 112                 # Pass off to processing
 113                 #
 114                 # (... don't change entry after this point to avoid race
 115                 # conditions with changes to the document via processing code)
 116                 process_media = registry.tasks[ProcessMedia.name]
 117                 try:
 118                     process_media.apply_async(
 119                         [unicode(entry._id)], {},
 120                         task_id=task_id)
 121                 except BaseException as exc:
 122                     # The purpose of this section is because when running in "lazy"
 123                     # or always-eager-with-exceptions-propagated celery mode that
 124                     # the failure handling won't happen on Celery end.  Since we
 125                     # expect a lot of users to run things in this way we have to
 126                     # capture stuff here.
 127                     #
 128                     # ... not completely the diaper pattern because the
 129                     # exception is re-raised :)
 130                     mark_entry_failed(entry._id, exc)
 131                     # re-raise the exception
 132                     raise
 133
 134                 if mg_globals.app_config["push_urls"]:
 135                     feed_url=request.urlgen(
 136                                        'mediagoblin.user_pages.atom_feed',
 137                                        qualified=True,user=request.user.username)
 138                     hubparameters = {
 139                         'hub.mode': 'publish',
 140                         'hub.url': feed_url}
 141                     hubdata = urllib.urlencode(hubparameters)
 142                     hubheaders = {
 143                         "Content-type": "application/x-www-form-urlencoded",
 144                         "Connection": "close"}
 145                     for huburl in mg_globals.app_config["push_urls"]:
 146                         hubrequest = urllib2.Request(huburl, hubdata, hubheaders)
 147                         try:
 148                             hubresponse = urllib2.urlopen(hubrequest)
 149                         except urllib2.HTTPError as exc:
 150                             # This is not a big issue, the item will be fetched
 151                             # by the PuSH server next time we hit it
 152                             _log.warning(
 153                                 "push url %r gave error %r", huburl, exc.code)
 154                         except urllib2.URLError as exc:
 155                             _log.warning(
 156                                 "push url %r is unreachable %r", huburl, exc.reason)
 157
 158                 add_message(request, SUCCESS, _('Woohoo! Submitted!'))
 159
 160                 return redirect(request, "mediagoblin.user_pages.user_home",
 161                                 user=request.user.username)
 162             except Exception as e:
 163                 '''
 164                 This section is intended to catch exceptions raised in
 165                 mediagobling.media_types
 166                 '''
 167
 168                 if isinstance(e, InvalidFileType) or \
 169                         isinstance(e, FileTypeNotSupported):
 170                     submit_form.file.errors.append(
 171                         e)
 172                 else:
 173                     raise
 174
 175     return render_to_response(
 176         request,
 177         'mediagoblin/submit/start.html',
 178         {'submit_form': submit_form,
 179          'app_config': mg_globals.app_config})