# folders haven't yet been added, or this account is once-only; drop signal
return
elif self.folders:
- for folder in self.folders:
+ for foldernr in range(len(self.folders)):
# requeue folder
- self.folders[folder] = True
+ self.folders[foldernr][1] = True
self.quick = False
return
# else folders have already been cleared, put signal...
def addfolders(self, remotefolders, autorefreshes, quick):
self.folderlock.acquire()
try:
- self.folders = {}
+ self.folders = []
self.quick = quick
self.autorefreshes = autorefreshes
for folder in remotefolders:
# new folders are queued
- self.folders[folder] = True
+ self.folders.append([folder, True])
finally:
self.folderlock.release()
def clearfolders(self):
self.folderlock.acquire()
try:
- for folder in self.folders:
- if self.folders[folder]:
+ for folder, queued in self.folders:
+ if queued:
# some folders still in queue
return False
- self.folders.clear()
+ self.folders[:] = []
return True
finally:
self.folderlock.release()
dirty = True
while dirty:
dirty = False
- for folder in self.folders:
- if self.folders[folder]:
+ for foldernr, (folder, queued) in enumerate(self.folders):
+ if queued:
# mark folder as no longer queued
- self.folders[folder] = False
+ self.folders[foldernr][1] = False
dirty = True
quick = self.quick
self.folderlock.release()
self.localeval = config.getlocaleval()
self.ui = UIBase.getglobalui()
self.refreshperiod = self.getconffloat('autorefresh', 0.0)
+ self.quickrefreshcount = self.getconfint('quick', 0)
self.quicknum = 0
if self.refreshperiod == 0.0:
self.refreshperiod = None
for item in kaobjs:
item.startkeepalive()
-
- refreshperiod = int(self.refreshperiod * 60)
+
+ sleeptime = int(self.refreshperiod * 60)
+ if (self.quickrefreshcount > 0):
+ sleeptime = int(sleeptime / self.quickrefreshcount)
+
# try:
# sleepresult = siglistener.get_nowait()
# # retrieved signal before sleep started
# # catching signal 1 here means folders were cleared before signal was posted
# pass
# except Empty:
-# sleepresult = self.ui.sleep(refreshperiod, siglistener)
- sleepresult = self.ui.sleep(refreshperiod, siglistener)
+# sleepresult = self.ui.sleep(sleeptime, siglistener)
+ sleepresult = self.ui.sleep(sleeptime, siglistener)
if sleepresult == 1:
self.quicknum = 0
-#!/usr/bin/env python2.5
+#!/usr/bin/env python
"""Threaded IMAP4 client.
__all__ = ("IMAP4", "IMAP4_SSL", "IMAP4_stream",
"Internaldate2Time", "ParseFlags", "Time2Internaldate")
-__version__ = "2.6"
+__version__ = "2.11"
__release__ = "2"
-__revision__ = "6"
+__revision__ = "11"
__credits__ = """
Authentication code contributed by Donn Cave <donn@u.washington.edu> June 1998.
String method conversion by ESR, February 2001.
PROXYAUTH contributed by Rick Holbert <holbert.13@osu.edu> November 2002.
IDLE via threads suggested by Philippe Normand <phil@respyre.org> January 2005.
GET/SETANNOTATION contributed by Tomas Lindroos <skitta@abo.fi> June 2005.
-New socket open code from http://www.python.org/doc/lib/socket-example.html."""
+COMPRESS/DEFLATE contributed by Bron Gondwana <brong@brong.net> May 2009."""
__author__ = "Piers Lauder <piers@janeelix.com>"
-# Source URL: http://www.cs.usyd.edu.au/~piers/python/imaplib2
+__URL__ = "http://janeelix.com/piers/python/imaplib2"
-import binascii, os, Queue, random, re, select, socket, sys, time, threading
+import binascii, os, Queue, random, re, select, socket, sys, time, threading, zlib
select_module = select
'CAPABILITY': ((NONAUTH, AUTH, SELECTED), True),
'CHECK': ((SELECTED,), True),
'CLOSE': ((SELECTED,), False),
+ 'COMPRESS': ((AUTH,), False),
'COPY': ((SELECTED,), True),
'CREATE': ((AUTH, SELECTED), True),
'DELETE': ((AUTH, SELECTED), True),
self._accumulated_data = [] # Message data accumulated so far
self._literal_expected = None # Message data descriptor
+ self.compressor = None # COMPRESS/DEFLATE if not None
+ self.decompressor = None
+
# Create unique tag for this session,
# and compile tagged response matcher.
def open_socket(self):
- """Open socket choosing first address family available."""
+ """open_socket()
+ Open socket choosing first address family available."""
msg = (-1, 'could not open socket')
for res in socket.getaddrinfo(self.host, self.port, socket.AF_UNSPEC, socket.SOCK_STREAM):
return s
+ def start_compressing(self):
+ """start_compressing()
+ Enable deflate compression on the socket (RFC 4978)."""
+
+ # rfc 1951 - pure DEFLATE, so use -15 for both windows
+ self.decompressor = zlib.decompressobj(-15)
+ self.compressor = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION, zlib.DEFLATED, -15)
+
+
def read(self, size):
"""data = read(size)
Read at most 'size' bytes from remote."""
- return self.sock.recv(size)
+ if self.decompressor is None:
+ return self.sock.recv(size)
+
+ if self.decompressor.unconsumed_tail:
+ data = self.decompressor.unconsumed_tail
+ else:
+ data = self.sock.recv(8192)
+
+ return self.decompressor.decompress(data, size)
def send(self, data):
"""send(data)
Send 'data' to remote."""
+ if self.compressor is not None:
+ data = self.compressor.compress(data)
+ data += self.compressor.flush(zlib.Z_SYNC_FLUSH)
+
self.sock.sendall(data)
# Utility methods
+ def enable_compression(self):
+ """enable_compression()
+ Ask the server to start compressing the connection.
+ Should be called from user of this class after instantiation, as in:
+ if 'COMPRESS=DEFLATE' in imapobj.capabilities:
+ imapobj.enable_compression()"""
+
+ try:
+ typ, dat = self._simple_command('COMPRESS', 'DEFLATE')
+ if typ == 'OK':
+ self.start_compressing()
+ if __debug__: self._log(1, 'Enabled COMPRESS=DEFLATE')
+ finally:
+ self.state_change_pending.release()
+
+
def recent(self, **kw):
"""(typ, [data]) = recent()
Return most recent 'RECENT' responses if any exist,
typ, dat = self._untagged_response(code, [None], code.upper())
return self._deliver_dat(typ, dat, kw)
-
+
List mailbox names in directory matching pattern.
'data' is list of LIST responses.
- NB: for 'pattern':
- % matches all except separator ( so LIST "" "%" returns names at root)
- * matches all (so LIST "" "*" returns whole directory tree from root)"""
+ NB: for 'pattern':
+ % matches all except separator ( so LIST "" "%" returns names at root)
+ * matches all (so LIST "" "*" returns whole directory tree from root)"""
name = 'LIST'
kw['untagged_response'] = name
self.state = AUTH
if __debug__: self._log(1, 'state => AUTH')
if typ == 'BAD':
- self._deliver_exc(self.error, '%s command error: %s %s' % (name, typ, dat), kw)
+ self._deliver_exc(self.error, '%s command error: %s %s. Data: %.100s' % (name, typ, dat, mailbox), kw)
return self._deliver_dat(typ, dat, kw)
self.state = SELECTED
if __debug__: self._log(1, 'state => SELECTED')
literal = self.literal
if literal is not None:
self.literal = None
- if isinstance(literal, str):
+ if isinstance(literal, basestring):
literator = None
data = '%s {%s}' % (data, len(literal))
else:
literator = literal
+ if __debug__: self._log(4, 'data=%s' % data)
+
rqb.data = '%s%s' % (data, CRLF)
- self.ouq.put(rqb)
if literal is None:
+ self.ouq.put(rqb)
return rqb
+ # Must setup continuation expectancy *before* ouq.put
crqb = self._request_push(tag='continuation')
+ self.ouq.put(rqb)
+
while True:
# Wait for continuation response
if literal is None:
break
+ if literator is not None:
+ # Need new request for next continuation response
+ crqb = self._request_push(tag='continuation')
+
if __debug__: self._log(4, 'write literal size %s' % len(literal))
crqb.data = '%s%s' % (literal, CRLF)
self.ouq.put(crqb)
if literator is None:
break
- self.commands_lock.acquire()
- self.tagged_commands['continuation'] = crqb
- self.commands_lock.release()
-
return rqb
self._check_bye()
if typ == 'BAD':
if __debug__: self._print_log()
- raise self.error('%s command error: %s %s' % (rqb.name, typ, dat))
+ raise self.error('%s command error: %s %s. Data: %.100s' % (rqb.name, typ, dat, rqb.data))
if 'untagged_response' in kw:
return self._untagged_response(typ, dat, kw['untagged_response'])
return typ, dat
typ, dat = response
if typ == 'BAD':
if __debug__: self._print_log()
- rqb.abort(self.error, '%s command error: %s %s' % (rqb.name, typ, dat))
+ rqb.abort(self.error, '%s command error: %s %s. Data: %.100s' % (rqb.name, typ, dat, rqb.data))
return
if 'untagged_response' in kw:
- rqb.deliver(self._untagged_response(typ, dat, kw['untagged_response']))
- else:
- rqb.deliver(response)
+ response = self._untagged_response(typ, dat, kw['untagged_response'])
+ rqb.deliver(response)
def _deliver_dat(self, typ, dat, kw):
def _end_idle(self):
irqb = self.idle_rqb
- if irqb is not None:
- self.idle_rqb = None
- self.idle_timeout = None
- irqb.data = 'DONE%s' % CRLF
- self.ouq.put(irqb)
- if __debug__: self._log(2, 'server IDLE finished')
+ if irqb is None:
+ return
+ self.idle_rqb = None
+ self.idle_timeout = None
+ irqb.data = 'DONE%s' % CRLF
+ self.ouq.put(irqb)
+ if __debug__: self._log(2, 'server IDLE finished')
def _match(self, cre, s):
threading.currentThread().setName('hdlr')
- time.sleep(0.1) # Don't start handling before main thread ready
+ time.sleep(0.1) # Don't start handling before main thread ready
if __debug__: self._log(1, 'starting')
if line is None:
break
- if not isinstance(line, str):
+ if not isinstance(line, basestring):
typ, val = line
break
self.host = host is not None and host or ''
self.port = port is not None and port or IMAP4_SSL_PORT
self.sock = self.open_socket()
- self.sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
+
+ try:
+ import ssl
+ self.sslobj = ssl.wrap_socket(self.sock, self.keyfile, self.certfile)
+ except ImportError:
+ self.sslobj = socket.ssl(self.sock, self.keyfile, self.certfile)
self.read_fd = self.sock.fileno()
"""data = read(size)
Read at most 'size' bytes from remote."""
- return self.sslobj.read(size)
+ if self.decompressor is None:
+ return self.sslobj.read(size)
+
+ if self.decompressor.unconsumed_tail:
+ data = self.decompressor.unconsumed_tail
+ else:
+ data = self.sslobj.read(8192)
+
+ return self.decompressor.decompress(data, size)
def send(self, data):
"""send(data)
Send 'data' to remote."""
+ if self.compressor is not None:
+ data = self.compressor.compress(data)
+ data += self.compressor.flush(zlib.Z_SYNC_FLUSH)
+
# NB: socket.ssl needs a "sendall" method to match socket objects.
bytes = len(data)
while bytes > 0:
def read(self, size):
"""Read 'size' bytes from remote."""
- return os.read(self.read_fd, size)
+ if self.decompressor is None:
+ return os.read(self.read_fd, size)
+
+ if self.decompressor.unconsumed_tail:
+ data = self.decompressor.unconsumed_tail
+ else:
+ data = os.read(self.read_fd, 8192)
+
+ return self.decompressor.decompress(data, size)
def send(self, data):
"""Send data to remote."""
+ if self.compressor is not None:
+ data = self.compressor.compress(data)
+ data += self.compressor.flush(zlib.Z_SYNC_FLUSH)
+
self.writefile.write(data)
self.writefile.flush()
import getopt, getpass
try:
- optlist, args = getopt.getopt(sys.argv[1:], 'd:l:s:p:')
+ optlist, args = getopt.getopt(sys.argv[1:], 'd:l:s:p:v')
except getopt.error, val:
optlist, args = (), ()
elif opt == '-s':
stream_command = val
if not args: args = (stream_command,)
+ elif opt == '-v':
+ print __version__
+ sys.exit(0)
if not args: args = ('',)
if not port: port = (keyfile is not None) and IMAP4_SSL_PORT or IMAP4_PORT
USER = getpass.getuser()
test_mesg = 'From: %(user)s@localhost%(lf)sSubject: IMAP4 test%(lf)s%(lf)s%(data)s' \
- % {'user':USER, 'lf':'\n', 'data':open(__file__).read()}
+ % {'user':USER, 'lf':'\n', 'data':open(__file__).read()}
test_seq1 = [
('list', ('""', '%')),
('create', ('/tmp/imaplib2_test.0',)),
test_seq1.insert(0, ('login', (USER, PASSWD)))
M._mesg('PROTOCOL_VERSION = %s' % M.PROTOCOL_VERSION)
M._mesg('CAPABILITIES = %r' % (M.capabilities,))
+ if 'COMPRESS=DEFLATE' in M.capabilities:
+ M.enable_compression()
for cmd,args in test_seq1:
run(cmd, args, cb=1)