Synnefo » snf-cloudcms

"""

CMS dynamic application clients module

Helper module to automatically retrieve client download links from different

sources (e.g. redmine files page).

"""

import urllib, urllib2, cookielib, urlparse

from datetime import datetime

from lxml import html

from synnefo import settings

CLIENTS_CACHE_TIMEOUT = getattr(settings, 'CLOUDCMS_CLIENTS_CACHE_TIMEOUT', 120)

class VersionSource(object):

    """

    Base class for the different version source handlers.

    """

    def __init__(self, link=None, os="linux", arch="all", regex=".", name=None,

            cache_backend=None, extra_options={}):

        self.os = os

        self.arch = arch

        self.link = link

        self.versions = []

        extra_options.update({'source_type': self.source_type, 'os': os})

        self.extra_version_options = extra_options

        self.cache_backend = cache_backend

        self.cache_key = self.os + self.arch + self.link

        if not name:

            self.name = os

        # generic urllib2 opener

        self.opener = urllib2.build_opener(

                    urllib2.HTTPRedirectHandler(),

                    urllib2.HTTPHandler(debuglevel=0),

                    urllib2.HTTPSHandler(debuglevel=0),

                    urllib2.HTTPCookieProcessor(cookielib.CookieJar()))

    def get_url(self, url):

        """

        Load url content and return the html etree object.

        """

        return html.document_fromstring(self.opener.open(url).read())

    def load(self):

        """

        Fill self.versions attribute with dict objects of the following format

        {'date': datetime.datetime(2012, 3, 16, 14, 29),

         'link': 'http://www.domain.com/clientdownload.exe',

         'name': 'Client download',

         'os': 'windows',

         'version': None}

        """

        raise NotImplemented

    def update(self):

        """

        Load wrapper which handles versions caching if cache_backend is set

        """

        if self.cache_backend:

            self.versions = self.cache_backend.get(self.cache_key)

        if not self.versions:

            self.load()

        if self.cache_backend:

            self.cache_backend.set(self.cache_key, self.versions, CLIENTS_CACHE_TIMEOUT)

    def get_latest(self):

        """

        Return the latest versions

        """

        # update versions

        self.update()

        # check that at least one version is available

        if len(self.versions):

            version = self.versions[0]

            version.update(self.extra_version_options)

            return version

        return None

class RedmineSource(VersionSource):

    """

    Parse a redmine project files page and return the list of existing files.

    """

    source_type = 'redmine_files'

    def load(self):

        """

        Load redmine files url and extract downloads. Also parse date to be

        able to identify latest download.

        """

        spliturl = urlparse.urlsplit(self.link)

        baseurl = spliturl.geturl().replace(spliturl.path, '')

        html = self.get_url(self.link)

        files = html.xpath("//tr[contains(@class, 'file')]")

        # helper lambdas

        def _parse_row(row):

            name = row.xpath("td[@class='filename']/a")[0].text

            link = baseurl + row.xpath("td[@class='filename']/a")[0].attrib.get('href')

            strdate = row.xpath("td[@class='created_on']")[0].text

            date = datetime.strptime(strdate, '%m/%d/%Y %I:%M %p')

            return {'name': name, 'link': link, 'date': date, 'version': None}

        versions = map(_parse_row, files)

        versions.sort(reverse=True, key=lambda r:r['date'])

        self.versions = versions

        return self

class DirectSource(VersionSource):

    """

    Direct link to a version. Dummy VersionSource which always returns one entry

    for the provided link.

    """

    source_type = 'direct'

    def load(self):

        self.versions = [{'name': self.name, 'link': self.link, 'date': None}]

        return self.versions

class LinkSource(DirectSource):

    """

    Used when version exists in some other url (e.g. apple store client)

    """

    source_type = 'link'

class ClientVersions(object):

    """

    Client versions manager. Given a sources dict like::

    {'windows': {'source_type': 'direct', 'args':

    ['http://clients.com/win.exe'], 'kwargs': {}},

     'linux': {'redmine_files': 'direct',

     'args': ['http://redmine.com/projects/client/files'],

     'kwargs': {}}}

    initializes a dict of proper VersionSource objects.

    """

    def __init__(self, sources, cache_backend=None):

        self._sources = sources

        self.sources = {}

        for s in self._sources:

            source_params = self._sources.get(s)

            if source_params['type'] in SOURCE_TYPES:

                kwargs = {'os': s, 'cache_backend': cache_backend}

                args = source_params.get('args', [])

                self.sources[s] = SOURCE_TYPES[source_params['type']](*args, **kwargs)

    def get_latest_versions(self):

        """

        Return the latest version of each version source.

        """

        for os, source in self.sources.iteritems():

            yield source.get_latest()

# SOURCE TYPES CLASS MAP

SOURCE_TYPES = {

    'redmine_files': RedmineSource,

    'direct': DirectSource,

    'link': LinkSource

}