~didrocks/unity/altf10 : revision 62

6

urlencode,

7

)

8

9

10

class UnsupportedDisplayType(Exception):

11

"""Raised when an Unsupported display_type is requested."""

12

13

14

class UnsupportedOrder(Exception):

15

"""Raised when an Unsupported order is requested."""

16

17

18

SUPPORTED_DISPLAY_TYPES = (

19

'all',

20

'text-only',

21

'headers-only',

9

from grackle.error import (

10

ArchiveIdExists,

11

MessageIdNotFound,

12

UnparsableDateRange,

13

UnsupportedDisplayType,

14

UnsupportedOrder,

22

15

)

23

16

24

17

35

28

self.port = port

36

29

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

37

30

38

def archive_url(self, archive_id, query):

31

def archive_url(self, path, query):

39

32

"""Return the URL for an archive

40

33

41

:param archive_id: The id of the archive to generate the URL for.

34

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

35

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

42

36

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

43

37

"""

44

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

38

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

45

39

query_string = urlencode(query)

46

40

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

47

41

48

42

def _get_connection(self):

49

43

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

50

44

51

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

45

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

52

46

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

53

url = self.archive_url(archive_id, query)

47

url = self.archive_url(path, query)

54

48

connection = self._get_connection()

55

49

connection.request(method, url, body)

56

50

return connection.getresponse()

57

51

52

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

53

"""Create an archive.

54

55

:param archive_id: The archive id.

56

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

57

"""

58

response = self._method_archive(

59

'PUT', archive_id, {}, None)

60

response.read()

61

if response.status == httplib.BAD_REQUEST:

62

if response.reason == ArchiveIdExists.__doc__:

63

raise ArchiveIdExists

64

raise Exception('wtf')

65

elif response.status == httplib.CREATED:

66

return

67

else:

68

raise Exception('!!')

69

58

70

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

59

71

"""Put a message into an archive.

60

72

63

75

the message.

64

76

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

65

77

"""

78

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

66

79

response = self._method_archive(

67

'POST', archive_id, {'key': key}, file_obj.read())

80

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

68

81

response.read()

69

82

if response.status == httplib.BAD_REQUEST:

83

if response.reason == ArchiveIdExists.__doc__:

84

raise ArchiveIdExists

70

85

raise Exception('wtf')

71

86

elif response.status == httplib.CREATED:

72

87

return

73

88

else:

74

89

raise Exception('!!')

75

90

76

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

77

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

78

max_body_length=None, include_hidden=False,

91

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

92

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

93

include_hidden=False, max_body_length=None,

79

94

display_type='all'):

80

95

"""Retrieve specified messages.

81

96

82

97

:param archive_id: The archive to retrieve messages from.

83

98

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

99

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

100

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

101

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

102

and 31.

84

103

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

85

104

may, at its discretion, return fewer.

86

105

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

108

127

parameters = {}

109

128

if message_ids is not None:

110

129

parameters['message_ids'] = message_ids

130

if date_range is not None:

131

parameters['date_range'] = date_range

111

132

if limit is not None:

112

133

parameters['limit'] = limit

113

134

if memo is not None:

127

148

raise UnsupportedOrder

128

149

elif response.reason == UnsupportedDisplayType.__doc__:

129

150

raise UnsupportedDisplayType

151

elif response.reason == UnparsableDateRange.__doc__:

152

raise UnparsableDateRange

130

153

else:

131

154

raise ValueError('Bad request')

132

155

data = response.read()

133

156

return simplejson.loads(data)

157

158

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

159

parameters = {

160

'hidden': hidden,

161

}

162

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

163

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

164

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

165

if response.status == httplib.BAD_REQUEST:

166

if response.reason == MessageIdNotFound.__doc__:

167

raise MessageIdNotFound

168

data = response.read()

169

return simplejson.loads(data)