tunneling: Reduce priority of multicast tunnels.
[openvswitch] / python / ovs / poller.py
1 # Copyright (c) 2010 Nicira Networks
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at:
6 #
7 #     http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14
15 import errno
16 import select
17 import ovs.timeval
18 import ovs.vlog
19
20 vlog = ovs.vlog.Vlog("poller")
21
22
23 class Poller(object):
24     """High-level wrapper around the "poll" system call.
25
26     Intended usage is for the program's main loop to go about its business
27     servicing whatever events it needs to.  Then, when it runs out of immediate
28     tasks, it calls each subordinate module or object's "wait" function, which
29     in turn calls one (or more) of the functions Poller.fd_wait(),
30     Poller.immediate_wake(), and Poller.timer_wait() to register to be awakened
31     when the appropriate event occurs.  Then the main loop calls
32     Poller.block(), which blocks until one of the registered events happens."""
33
34     def __init__(self):
35         self.__reset()
36
37     def fd_wait(self, fd, events):
38         """Registers 'fd' as waiting for the specified 'events' (which should
39         be select.POLLIN or select.POLLOUT or their bitwise-OR).  The following
40         call to self.block() will wake up when 'fd' becomes ready for one or
41         more of the requested events.
42
43         The event registration is one-shot: only the following call to
44         self.block() is affected.  The event will need to be re-registered
45         after self.block() is called if it is to persist.
46
47         'fd' may be an integer file descriptor or an object with a fileno()
48         method that returns an integer file descriptor."""
49         self.poll.register(fd, events)
50
51     def __timer_wait(self, msec):
52         if self.timeout < 0 or msec < self.timeout:
53             self.timeout = msec
54
55     def timer_wait(self, msec):
56         """Causes the following call to self.block() to block for no more than
57         'msec' milliseconds.  If 'msec' is nonpositive, the following call to
58         self.block() will not block at all.
59
60         The timer registration is one-shot: only the following call to
61         self.block() is affected.  The timer will need to be re-registered
62         after self.block() is called if it is to persist."""
63         if msec <= 0:
64             self.immediate_wake()
65         else:
66             self.__timer_wait(msec)
67
68     def timer_wait_until(self, msec):
69         """Causes the following call to self.block() to wake up when the
70         current time, as returned by ovs.timeval.msec(), reaches 'msec' or
71         later.  If 'msec' is earlier than the current time, the following call
72         to self.block() will not block at all.
73
74         The timer registration is one-shot: only the following call to
75         self.block() is affected.  The timer will need to be re-registered
76         after self.block() is called if it is to persist."""
77         now = ovs.timeval.msec()
78         if msec <= now:
79             self.immediate_wake()
80         else:
81             self.__timer_wait(msec - now)
82
83     def immediate_wake(self):
84         """Causes the following call to self.block() to wake up immediately,
85         without blocking."""
86         self.timeout = 0
87
88     def block(self):
89         """Blocks until one or more of the events registered with
90         self.fd_wait() occurs, or until the minimum duration registered with
91         self.timer_wait() elapses, or not at all if self.immediate_wake() has
92         been called."""
93         try:
94             try:
95                 events = self.poll.poll(self.timeout)
96                 self.__log_wakeup(events)
97             except select.error, e:
98                 # XXX rate-limit
99                 error, msg = e
100                 if error != errno.EINTR:
101                     vlog.err("poll: %s" % e[1])
102         finally:
103             self.__reset()
104
105     def __log_wakeup(self, events):
106         if not events:
107             vlog.dbg("%d-ms timeout" % self.timeout)
108         else:
109             for fd, revents in events:
110                 if revents != 0:
111                     s = ""
112                     if revents & select.POLLIN:
113                         s += "[POLLIN]"
114                     if revents & select.POLLOUT:
115                         s += "[POLLOUT]"
116                     if revents & select.POLLERR:
117                         s += "[POLLERR]"
118                     if revents & select.POLLHUP:
119                         s += "[POLLHUP]"
120                     if revents & select.POLLNVAL:
121                         s += "[POLLNVAL]"
122                     vlog.dbg("%s on fd %d" % (s, fd))
123
124     def __reset(self):
125         self.poll = select.poll()
126         self.timeout = -1