Merge branch 'bug_617_default_favlist_handling_fix'
[vuplus_dvbapp] / e2reactor.py
1 # enigma2 reactor: based on pollreactor, which is
2 # Copyright (c) 2001-2004 Twisted Matrix Laboratories.
3 # See LICENSE for details.
4
5
6 """
7 Maintainer: U{Felix Domke<mailto:tmbinc@elitedvb.net>}
8 """
9
10 # System imports
11 import select, errno, sys
12
13 # Twisted imports
14 from twisted.python import log, failure
15 from twisted.internet import main, posixbase, error
16 #from twisted.internet.pollreactor import PollReactor, poller
17
18 from enigma import getApplication
19
20 # globals
21 reads = {}
22 writes = {}
23 selectables = {}
24
25 POLL_DISCONNECTED = (select.POLLHUP | select.POLLERR | select.POLLNVAL)
26
27 class E2SharedPoll:
28         def __init__(self):
29                 self.dict = { }
30                 self.eApp = getApplication()
31
32         def register(self, fd, eventmask = select.POLLIN | select.POLLERR | select.POLLOUT):
33                 self.dict[fd] = eventmask
34         
35         def unregister(self, fd):
36                 del self.dict[fd]
37         
38         def poll(self, timeout = None):
39                 try:
40                         r = self.eApp.poll(timeout, self.dict)
41                 except KeyboardInterrupt:
42                         return None
43                 return r
44
45 poller = E2SharedPoll()
46
47 class PollReactor(posixbase.PosixReactorBase):
48         """A reactor that uses poll(2)."""
49
50         def _updateRegistration(self, fd):
51                 """Register/unregister an fd with the poller."""
52                 try:
53                         poller.unregister(fd)
54                 except KeyError:
55                         pass
56
57                 mask = 0
58                 if reads.has_key(fd): mask = mask | select.POLLIN
59                 if writes.has_key(fd): mask = mask | select.POLLOUT
60                 if mask != 0:
61                         poller.register(fd, mask)
62                 else:
63                         if selectables.has_key(fd): del selectables[fd]
64                 
65                 
66                 poller.eApp.interruptPoll()
67
68         def _dictRemove(self, selectable, mdict):
69                 try:
70                         # the easy way
71                         fd = selectable.fileno()
72                         # make sure the fd is actually real.  In some situations we can get
73                         # -1 here.
74                         mdict[fd]
75                 except:
76                         # the hard way: necessary because fileno() may disappear at any
77                         # moment, thanks to python's underlying sockets impl
78                         for fd, fdes in selectables.items():
79                                 if selectable is fdes:
80                                         break
81                         else:
82                                 # Hmm, maybe not the right course of action?  This method can't
83                                 # fail, because it happens inside error detection...
84                                 return
85                 if mdict.has_key(fd):
86                         del mdict[fd]
87                         self._updateRegistration(fd)
88
89         def addReader(self, reader):
90                 """Add a FileDescriptor for notification of data available to read.
91                 """
92                 fd = reader.fileno()
93                 if not reads.has_key(fd):
94                         selectables[fd] = reader
95                         reads[fd] =  1
96                         self._updateRegistration(fd)
97
98         def addWriter(self, writer, writes=writes, selectables=selectables):
99                 """Add a FileDescriptor for notification of data available to write.
100                 """
101                 fd = writer.fileno()
102                 if not writes.has_key(fd):
103                         selectables[fd] = writer
104                         writes[fd] =  1
105                         self._updateRegistration(fd)
106
107         def removeReader(self, reader, reads=reads):
108                 """Remove a Selectable for notification of data available to read.
109                 """
110                 return self._dictRemove(reader, reads)
111
112         def removeWriter(self, writer, writes=writes):
113                 """Remove a Selectable for notification of data available to write.
114                 """
115                 return self._dictRemove(writer, writes)
116
117         def removeAll(self, reads=reads, writes=writes, selectables=selectables):
118                 """Remove all selectables, and return a list of them."""
119                 if self.waker is not None:
120                         self.removeReader(self.waker)
121                 result = selectables.values()
122                 fds = selectables.keys()
123                 reads.clear()
124                 writes.clear()
125                 selectables.clear()
126                 for fd in fds:
127                         poller.unregister(fd)
128                         
129                 if self.waker is not None:
130                         self.addReader(self.waker)
131                 return result
132
133         def doPoll(self, timeout,
134                            reads=reads,
135                            writes=writes,
136                            selectables=selectables,
137                            select=select,
138                            log=log,
139                            POLLIN=select.POLLIN,
140                            POLLOUT=select.POLLOUT):
141                 """Poll the poller for new events."""
142                 
143                 if timeout is not None:
144                         timeout = int(timeout * 1000) # convert seconds to milliseconds
145
146                 try:
147                         l = poller.poll(timeout)
148                         if l is None:
149                                 if self.running:
150                                         self.stop()
151                                 l = [ ]
152                 except select.error, e:
153                         if e[0] == errno.EINTR:
154                                 return
155                         else:
156                                 raise
157                 _drdw = self._doReadOrWrite
158                 for fd, event in l:
159                         try:
160                                 selectable = selectables[fd]
161                         except KeyError:
162                                 # Handles the infrequent case where one selectable's
163                                 # handler disconnects another.
164                                 continue
165                         log.callWithLogger(selectable, _drdw, selectable, fd, event, POLLIN, POLLOUT, log)
166
167         doIteration = doPoll
168
169         def _doReadOrWrite(self, selectable, fd, event, POLLIN, POLLOUT, log, 
170                 faildict={
171                         error.ConnectionDone: failure.Failure(error.ConnectionDone()),
172                         error.ConnectionLost: failure.Failure(error.ConnectionLost())
173                 }):
174                 why = None
175                 inRead = False
176                 if event & POLL_DISCONNECTED and not (event & POLLIN):
177                         why = main.CONNECTION_LOST
178                 else:
179                         try:
180                                 if event & POLLIN:
181                                         why = selectable.doRead()
182                                         inRead = True
183                                 if not why and event & POLLOUT:
184                                         why = selectable.doWrite()
185                                         inRead = False
186                                 if not selectable.fileno() == fd:
187                                         why = error.ConnectionFdescWentAway('Filedescriptor went away')
188                                         inRead = False
189                         except:
190                                 log.deferr()
191                                 why = sys.exc_info()[1]
192                 if why:
193                         self._disconnectSelectable(selectable, why, inRead)
194
195         def callLater(self, *args, **kwargs):
196                 poller.eApp.interruptPoll()
197                 return posixbase.PosixReactorBase.callLater(self, *args, **kwargs)
198
199 def install():
200         """Install the poll() reactor."""
201         
202         p = PollReactor()
203         main.installReactor(p)
204
205 __all__ = ["PollReactor", "install"]