autocat3/CloudStorage.py

#!/usr/bin/env python
#  -*- mode: python; indent-tabs-mode: nil; -*- coding: utf-8 -*-

"""
CloudStorage.py

Copyright 2013-15 by Marcello Perathoner

Distributable under the GNU General Public License Version 3 or newer.

Base classes for uploads to file hosting services.

"""

from __future__ import unicode_literals

from contextlib import closing
from six.moves import urllib
import logging
import re
import os

import cherrypy
import routes
import requests
import requests_oauthlib

from requests import RequestException
from oauthlib.oauth2.rfc6749.errors import OAuth2Error

from i18n_tool import ugettext as _
import BaseSearcher

# pylint: disable=R0921

http_adapter  = requests.adapters.HTTPAdapter ()
https_adapter = requests.adapters.HTTPAdapter ()

# Google Drive `bug´ see:
# https://github.com/idan/oauthlib/commit/ca4811b3087f9d34754d3debf839e247593b8a39
os.environ['OAUTHLIB_RELAX_TOKEN_SCOPE'] = '1'

config = cherrypy.config

urlgen = routes.URLGenerator (cherrypy.routes_mapper, {
    'HTTP_HOST': config['file_host'],
    'HTTPS': config['host_https']
})

def log (msg):
    """ Log an informational  message. """
    cherrypy.log (msg, context = 'CLOUDSTORAGE', severity = logging.INFO)


def error_log (msg):
    """ Log an error message. """
    cherrypy.log ('Error: ' + msg, context = 'CLOUDSTORAGE', severity = logging.ERROR)


class CloudOAuth2Session (requests_oauthlib.OAuth2Session): # pylint: disable=R0904
    """ An OAuth2 session. """

    name_prefix           = None
    oauth2_auth_endpoint  = None
    oauth2_token_endpoint = None
    oauth2_scope          = None


    def __init__ (self, **kwargs):
        """ Initialize session from cherrypy config. """

        prefix = self.name_prefix

        client_id     = config[prefix + '_client_id']
        redirect_uri  = urlgen (prefix + '_callback', host = config['file_host'])

        super (CloudOAuth2Session, self).__init__ (
            client_id = client_id,
            scope = self.oauth2_scope,
            redirect_uri = redirect_uri,
            **kwargs
        )
        self.client_secret = config[prefix + '_client_secret']
        self.ebook = None

        self.mount ("http://",  http_adapter)
        self.mount ("https://", https_adapter)


    def oauth_dance (self, kwargs):
        """ Do the OAuth2 dance. """

        #
        # OAuth 2.0 flow see:
        # http://tools.ietf.org/html/rfc6749
        #

        if not self.token:
            if 'code' not in kwargs:
                # oauth step 1:
                # redirect the user to the Authorization Endpoint
                log ('Building auth url ...')
                auth_url, dummy_state = self.authorization_url (
                    self.oauth2_auth_endpoint)
                log ('Redirecting user to auth endpoint ...')
                raise cherrypy.HTTPRedirect (auth_url)

            else:
                # oauth step 2
                # the user's browser just came back with an authorization code
                # get the access_token from the Token Endpoint
                log ('Fetching access token ...')
                self.fetch_token (self.oauth2_token_endpoint,
                                  client_secret = self.client_secret,
                                  code = kwargs['code'])
                log ('Got access token.')


    def unauthorized (self, msg = 'Unauthorized'):
        """ Called on OAuth2 failure. """
        pass



class CloudStorage (object):
    """ Base class for uploads to cloud storage providers.

    :param name: The name of the cloud service, eg. 'Dropbox'.
    :param session_class: The class to use for the oauth session.
    :param user_agent: The user agent to make requests to www.gutenberg.org.

    """

    name            = None
    session_class   = CloudOAuth2Session
    user_agent      = None
    upload_endpoint = None
    re_filename     = re.compile (r'[/\<>:"|?* ]')


    def __init__ (self):
        self.host = cherrypy.config['host']
        self.urlgen = urlgen

    def index (self, **kwargs):
        """ Output the page. """

        #
        # OAuth 2.0 flow see:
        # http://tools.ietf.org/html/rfc6749
        #

        session = self.get_or_create_session ()
        if 'id' in kwargs:
            session.ebook = EbookMetaData (kwargs)
        if session.ebook is None:
            raise cherrypy.HTTPError (400, "No ebook selected. Are your cookies enabled?")

        name = self.name

        if 'not_approved' in kwargs or 'error' in kwargs:
            self._dialog (
                _('Sorry. The file could not be sent to {name}.').format (name = name),
                _('Error'))
            self.redirect_done (session)

        try:
            session.oauth_dance (kwargs)
            log ("Sending file %s to %s" % (
                session.ebook.get_source_url (), name))

            with closing (self.request_ebook (session)) as r:
                r.raise_for_status ()
                self.upload_file (session, r)

            log ("File %s sent to %s" % (
                session.ebook.get_source_url (), name))
            self._dialog (
                _('The file has been sent to {name}.').format (name = name),
                _('Sent to {name}').format (name = name))
            self.redirect_done (session)

        except (OAuth2Error, ) as what:
            session.unauthorized (what)
            self.unauthorized ('OAuthError: ' + str (what.urlencoded))

        except (RequestException, IOError, ValueError) as what:
            session.unauthorized (what)
            self.unauthorized ('RequestError: ' + str (what))
            raise cherrypy.HTTPError (500, str (what))


    def upload_file (self, oauth_session, response):
        """ Upload the file. """

        raise NotImplementedError


    def get_or_create_session (self):
        """ Retrieve an ongoing cloud session or create a new one. """

        session_name = self.session_class.name_prefix + '_session'
        session = cherrypy.session.get (session_name, self.session_class ())
        cherrypy.session[session_name] = session
        return session


    def delete_session (self):
        """ Delete cloud session. """

        session_name = self.session_class.name_prefix + '_session'
        # cherrypy.session[session_name].close ()
        del cherrypy.session[session_name]


    def request_ebook (self, session):
        """ Return an open request object for the ebook file. """

        url = session.ebook.get_source_url ()
        # Caveat: use requests.get, not session.get, because it is an insecure
        # transport. session.get would raise InsecureTransportError
        # turn off server encoding since we're going to re-stream the bytes
        return requests.get (
            url,
            headers = {'user-agent': self.user_agent, 'accept-encoding': ''},
            stream = True
        )


    def fix_filename (self, filename):
        """ Replace characters unsupported by many OSs.  """
        return self.re_filename.sub ('_', filename)


    def redirect_done (self, session):
        """ Redirect user back to bibrec page. """
        raise cherrypy.HTTPRedirect (self.urlgen (
            'bibrec', id = session.ebook.id, host = self.host))


    def unauthorized (self, msg = 'Unauthorized'):
        """ Call on OAuth failure. """
        msg = str (msg) # msg may be exception class
        error_log (msg)
        self.delete_session ()
        raise cherrypy.HTTPError (401, msg)


    @staticmethod
    def _dialog (message, title):
        """ Open a user-visible dialog on the next page. """
        cherrypy.session['user_dialog'] = (message, title)


class EbookMetaData (object):
    """ Helper class that holds ebook metadata. """

    accepted_filetypes = (
        'epub.images',
        'epub.noimages',
        'kindle.images',
        'kindle.noimages',
        'pdf')


    def __init__ (self, kwargs):
        self.id = None
        self.filetype = None

        try :
            self.id = int (kwargs['id'])
            self.filetype = kwargs['filetype']
            if self.filetype not in self.accepted_filetypes:
                self.filetype = None
                raise ValueError
        except (KeyError, ValueError):
            raise cherrypy.HTTPError (400, 'Bad Request. Invalid parameters')


    def get_dc (self):
        """ Get a DublinCore struct for the ebook. """
        dc = BaseSearcher.DC (cherrypy.engine.pool)
        dc.load_from_database (self.id)
        # dc.translate ()
        return dc


    def get_extension (self):
        """ Get the ebook filename extension. """
        ext = self.filetype.split ('.', 1)[0]
        if ext == 'kindle':
            ext = 'mobi'
        return ext


    def get_filename (self):
        """ Get a suitable filename to store the ebook. """
        filename = self.get_dc ().make_pretty_title () + '.' + self.get_extension ()
        return filename.replace (':', '_')


    def get_source_url (self):
        """ Return the url of the ebook file on gutenberg.org. """
        protocol = 'https://' if cherrypy.config['host_https'] else 'http://'
        if self.id == 99999:
            # test filename
            return urllib.parse.urljoin (
                protocol + str(cherrypy.config['file_host']) , 'test.pdf')
        if self.filetype == 'pdf':
            return urllib.parse.urljoin (
                protocol + cherrypy.config['file_host'],
                'files/%d/%d-pdf.pdf' % (self.id, self.id))
        else:
            return urllib.parse.urljoin (
                protocol + cherrypy.config['file_host'],
                'ebooks/%d.%s' % (self.id, self.filetype))