~didrocks/unity/altf10

__metaclass__ = type

import httplib

import simplejson

from urlparse import urlunparse

from urllib import (

    quote,

    urlencode,

)

from grackle.error import (

    ArchiveIdExists,

    MessageIdNotFound,

    UnparsableDateRange,

    UnsupportedDisplayType,

    UnsupportedOrder,

    )

class GrackleClient:

    """Class for accessing Grackle web service."""

    def __init__(self, host, port):

        """Constructor.

        :param host: The name of the server.

        :param port: The port providing Grackle service.

        """

        self.host = host

        self.port = port

        self.netloc = '%s:%d' % (host, port)

    def archive_url(self, path, query):

        """Return the URL for an archive

        :param path: The path to generate the URL for.

            Maybe be '', 'archive_id', or 'archive_id/message_id'

        :param query: The query to use in the URL, as a dict.

        """

        path = '/archive/%s' % quote(path)

        query_string = urlencode(query)

        return urlunparse(('http', self.netloc, path, '', query_string, ''))

    def _get_connection(self):

        return httplib.HTTPConnection(self.host, self.port)

    def _method_archive(self, method, path, query, body=None):

        """Perform an HTTP method on an archive's URL."""

        url = self.archive_url(path, query)

        connection = self._get_connection()

        connection.request(method, url, body)

        return connection.getresponse()

    def put_archive(self, archive_id, mbox=None):

        """Create an archive.

        :param archive_id: The archive id.

        :param mbox: An optional mbox with messages to add to the new archive.

        """

        response = self._method_archive(

            'PUT', archive_id, {}, None)

        response.read()

        if response.status == httplib.BAD_REQUEST:

            if response.reason == ArchiveIdExists.__doc__:

                raise ArchiveIdExists

            raise Exception('wtf')

        elif response.status == httplib.CREATED:

            return

        else:

            raise Exception('!!')

    def put_message(self, archive_id, key, file_obj):

        """Put a message into an archive.

        :param archive_id: The archive to put the message into.

        :param key: An arbitrary identifier that can later be used to retrieve

            the message.

        :param file_obj: The raw text of the message, as a file.

        """

        path = '%s/%s' % (archive_id, key)

        response = self._method_archive(

            'PUT', path, {}, file_obj.read())

        response.read()

        if response.status == httplib.BAD_REQUEST:

            if response.reason == ArchiveIdExists.__doc__:

                raise ArchiveIdExists

            raise Exception('wtf')

        elif response.status == httplib.CREATED:

            return

        else:

            raise Exception('!!')

    def get_messages(self, archive_id, message_ids=None, date_range=None,

                     limit=None, memo=None, order=None, headers=None,

                     include_hidden=False, max_body_length=None,

                     display_type='all'):

        """Retrieve specified messages.

        :param archive_id: The archive to retrieve messages from.

        :param message_ids: (optional) Retrieve only messages with these ids.

        :param date_range: Retrieve the messages from or between a range of

            dates. Example: 2012-01-01..2012-01-31 retrieve all the messages

            between the 01 and 31 of January, including message from 01

            and 31.

        :param limit: The maximum number of messages to return.  The server

            may, at its discretion, return fewer.

        :param memo: (optional) Opaque identifier describing the position in

            the list of messages to return.  The combination of a memo and a

            limit describes a batch of results.  If not specified, the start

            is used.

        :param order: The order to return results in.  Supported orders are

            determined by the server.  See test_client.SUPPORTED_ORDERS for an

            example.

        :param headers: The headers to include in the message.  Only headers

            actually present in the message will be provided.  If unspecified,

            most headers will be included.

        :param max_body_length: The maximum length for a message's body.  When

            multiple messages are nested (as with a thread), this applies to

            each message's body, not the aggregate length of all messages'

            bodies.

        :param include_hidden: If true, include messages that have been

            flagged "hidden" in the results.

        :param display_type: Adjust the message content to meet the needs of

            the intended display. Valid values are:

            all: (the default) include all message content.

            text-only: include only plain/text parts; exclude all other parts.

            headers-only: include only the message headers.

        """

        parameters = {}

        if message_ids is not None:

            parameters['message_ids'] = message_ids

        if date_range is not None:

            parameters['date_range'] = date_range

        if limit is not None:

            parameters['limit'] = limit

        if memo is not None:

            parameters['memo'] = memo

        if order is not None:

            parameters['order'] = order

        if headers is not None:

            parameters['headers'] = headers

        if max_body_length is not None:

            parameters['max_body_length'] = max_body_length

        parameters['display_type'] = display_type

        parameters['include_hidden'] = include_hidden

        query = {'parameters': simplejson.dumps(parameters)}

        response = self._method_archive('GET', archive_id, query)

        if response.status == httplib.BAD_REQUEST:

            if response.reason == UnsupportedOrder.__doc__:

                raise UnsupportedOrder

            elif response.reason == UnsupportedDisplayType.__doc__:

                raise UnsupportedDisplayType

            elif response.reason == UnparsableDateRange.__doc__:

                raise UnparsableDateRange

            else:

                raise ValueError('Bad request')

        data = response.read()

        return simplejson.loads(data)

    def hide_message(self, archive_id, message_id, hidden):

        parameters = {

            'hidden': hidden,

            }

        query = {'parameters': simplejson.dumps(parameters)}

        path = '%s/%s' % (archive_id, message_id)

        response = self._method_archive('POST', path, query)

        if response.status == httplib.BAD_REQUEST:

            if response.reason == MessageIdNotFound.__doc__:

                raise MessageIdNotFound

        data = response.read()

        return simplejson.loads(data)