X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=python%2Fovs%2Freconnect.py;h=39dd556da2ce91d2167f48cae7b4a1cdc273efcc;hb=c5cf10598f8c9f4428291e9df3ecd72a05fb1ccf;hp=ac0141665b5176c45384b77e1ae0f3f4c9dd4a96;hpb=0a61b042a59ce62a91db68645c9f6023cb04bccf;p=sliver-openvswitch.git diff --git a/python/ovs/reconnect.py b/python/ovs/reconnect.py index ac0141665..39dd556da 100644 --- a/python/ovs/reconnect.py +++ b/python/ovs/reconnect.py @@ -1,4 +1,4 @@ -# Copyright (c) 2010, 2011 Nicira Networks +# Copyright (c) 2010, 2011, 2012 Nicira, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,15 +12,19 @@ # See the License for the specific language governing permissions and # limitations under the License. -import logging import os +import ovs.vlog +import ovs.util + # Values returned by Reconnect.run() CONNECT = 'connect' DISCONNECT = 'disconnect' PROBE = 'probe' -EOF = -1 +EOF = ovs.util.EOF +vlog = ovs.vlog.Vlog("reconnect") + class Reconnect(object): """A finite-state machine for connecting and reconnecting to a network @@ -90,15 +94,15 @@ class Reconnect(object): @staticmethod def deadline(fsm): if fsm.probe_interval: - base = max(fsm.last_received, fsm.state_entered) + base = max(fsm.last_activity, fsm.state_entered) return base + fsm.probe_interval return None @staticmethod def run(fsm, now): - logging.debug("%s: idle %d ms, sending inactivity probe" - % (fsm.name, - now - max(fsm.last_received, fsm.state_entered))) + vlog.dbg("%s: idle %d ms, sending inactivity probe" + % (fsm.name, + now - max(fsm.last_activity, fsm.state_entered))) fsm._transition(now, Reconnect.Idle) return PROBE @@ -108,13 +112,15 @@ class Reconnect(object): @staticmethod def deadline(fsm): - return fsm.state_entered + fsm.probe_interval + if fsm.probe_interval: + return fsm.state_entered + fsm.probe_interval + return None @staticmethod def run(fsm, now): - logging.error("%s: no response to inactivity probe after %.3g " - "seconds, disconnecting" - % (fsm.name, (now - fsm.state_entered) / 1000.0)) + vlog.err("%s: no response to inactivity probe after %.3g " + "seconds, disconnecting" + % (fsm.name, (now - fsm.state_entered) / 1000.0)) return DISCONNECT class Reconnect(object): @@ -139,12 +145,12 @@ class Reconnect(object): self.max_backoff = 8000 self.probe_interval = 5000 self.passive = False - self.info_level = logging.info + self.info_level = vlog.info self.state = Reconnect.Void self.state_entered = now self.backoff = 0 - self.last_received = now + self.last_activity = now self.last_connected = None self.last_disconnected = None self.max_tries = None @@ -160,16 +166,16 @@ class Reconnect(object): debug level, by default keeping them out of log files. This is appropriate if the connection is one that is expected to be short-lived, so that the log messages are merely distracting. - + If 'quiet' is false, this object logs informational messages at info level. This is the default. - + This setting has no effect on the log level of debugging, warning, or error messages.""" if quiet: - self.info_level = logging.debug + self.info_level = vlog.dbg else: - self.info_level = logging.info + self.info_level = vlog.info def get_name(self): return self.name @@ -177,7 +183,7 @@ class Reconnect(object): def set_name(self, name): """Sets this object's name to 'name'. If 'name' is None, then "void" is used instead. - + The name is used in log messages.""" if name is None: self.name = "void" @@ -198,8 +204,8 @@ class Reconnect(object): """Returns the "probe interval" in milliseconds. If this is zero, it disables the connection keepalive feature. If it is nonzero, then if the interval passes while the FSM is connected and without - self.received() being called, self.run() returns ovs.reconnect.PROBE. - If the interval passes again without self.received() being called, + self.activity() being called, self.run() returns ovs.reconnect.PROBE. + If the interval passes again without self.activity() being called, self.run() returns ovs.reconnect.DISCONNECT.""" return self.probe_interval @@ -235,14 +241,14 @@ class Reconnect(object): if (self.state == Reconnect.Backoff and self.backoff > self.max_backoff): self.backoff = self.max_backoff - + def set_probe_interval(self, probe_interval): """Sets the "probe interval" to 'probe_interval', in milliseconds. If this is zero, it disables the connection keepalive feature. If it is nonzero, then if the interval passes while this FSM is connected and - without self.received() being called, self.run() returns + without self.activity() being called, self.run() returns ovs.reconnect.PROBE. If the interval passes again without - self.received() being called, self.run() returns + self.activity() being called, self.run() returns ovs.reconnect.DISCONNECT. If 'probe_interval' is nonzero, then it will be forced to a value of at @@ -260,7 +266,8 @@ class Reconnect(object): def set_passive(self, passive, now): """Configures this FSM for active or passive mode. In active mode (the default), the FSM is attempting to connect to a remote host. In - passive mode, the FSM is listening for connections from a remote host.""" + passive mode, the FSM is listening for connections from a remote + host.""" if self.passive != passive: self.passive = passive @@ -316,8 +323,8 @@ class Reconnect(object): # Report what happened if self.state in (Reconnect.Active, Reconnect.Idle): if error > 0: - logging.warning("%s: connection dropped (%s)" - % (self.name, os.strerror(error))) + vlog.warn("%s: connection dropped (%s)" + % (self.name, os.strerror(error))) elif error == EOF: self.info_level("%s: connection closed by peer" % self.name) @@ -325,8 +332,8 @@ class Reconnect(object): self.info_level("%s: connection dropped" % self.name) elif self.state == Reconnect.Listening: if error > 0: - logging.warning("%s: error listening for connections (%s)" - % (self.name, os.strerror(error))) + vlog.warn("%s: error listening for connections (%s)" + % (self.name, os.strerror(error))) else: self.info_level("%s: error listening for connections" % self.name) @@ -336,8 +343,8 @@ class Reconnect(object): else: type_ = "connection" if error > 0: - logging.warning("%s: %s attempt failed (%s)" - % (self.name, type_, os.strerror(error))) + vlog.warn("%s: %s attempt failed (%s)" + % (self.name, type_, os.strerror(error))) else: self.info_level("%s: %s attempt timed out" % (self.name, type_)) @@ -347,7 +354,7 @@ class Reconnect(object): # Back off if (self.state in (Reconnect.Active, Reconnect.Idle) and - (self.last_received - self.last_connected >= self.backoff or + (self.last_activity - self.last_connected >= self.backoff or self.passive)): if self.passive: self.backoff = 0 @@ -386,15 +393,15 @@ class Reconnect(object): else: self.info_level("%s: connecting..." % self.name) self._transition(now, Reconnect.ConnectInProgress) - + def listening(self, now): """Tell this FSM that the client is listening for connection attempts. This state last indefinitely until the client reports some change. - + The natural progression from this state is for the client to report that a connection has been accepted or is in progress of being accepted, by calling self.connecting() or self.connected(). - + The client may also report that listening failed (e.g. accept() returned an unexpected error such as ENOMEM) by calling self.listen_error(), in which case the FSM will back off and eventually @@ -407,7 +414,7 @@ class Reconnect(object): def listen_error(self, now, error): """Tell this FSM that the client's attempt to accept a connection failed (e.g. accept() returned an unexpected error such as ENOMEM). - + If the FSM is currently listening (self.listening() was called), it will back off and eventually return ovs.reconnect.CONNECT from self.run() to tell the client to try listening again. If there is an @@ -419,7 +426,7 @@ class Reconnect(object): """Tell this FSM that the connection was successful. The FSM will start the probe interval timer, which is reset by - self.received(). If the timer expires, a probe will be sent (by + self.activity(). If the timer expires, a probe will be sent (by returning ovs.reconnect.PROBE from self.run(). If the timer expires again without being reset, the connection will be aborted (by returning ovs.reconnect.DISCONNECT from self.run().""" @@ -437,12 +444,13 @@ class Reconnect(object): self.connecting(now) self.disconnected(now, error) - def received(self, now): - """Tell this FSM that some data was received. This resets the probe - interval timer, so that the connection is known not to be idle.""" + def activity(self, now): + """Tell this FSM that some activity occurred on the connection. This + resets the probe interval timer, so that the connection is known not to + be idle.""" if self.state != Reconnect.Active: self._transition(now, Reconnect.Active) - self.last_received = now + self.last_activity = now def _transition(self, now, state): if self.state == Reconnect.ConnectInProgress: @@ -456,54 +464,56 @@ class Reconnect(object): if connected_before: self.total_connected_duration += now - self.last_connected self.seqno += 1 - - logging.debug("%s: entering %s" % (self.name, state.name)) + + vlog.dbg("%s: entering %s" % (self.name, state.name)) self.state = state self.state_entered = now def run(self, now): """Assesses whether any action should be taken on this FSM. The return value is one of: - + - None: The client need not take any action. - + - Active client, ovs.reconnect.CONNECT: The client should start a connection attempt and indicate this by calling self.connecting(). If the connection attempt has definitely succeeded, it should call self.connected(). If the connection attempt has definitely failed, it should call self.connect_failed(). - + The FSM is smart enough to back off correctly after successful connections that quickly abort, so it is OK to call self.connected() after a low-level successful connection (e.g. connect()) even if the connection might soon abort due to a failure at a high-level (e.g. SSL negotiation failure). - + - Passive client, ovs.reconnect.CONNECT: The client should try to listen for a connection, if it is not already listening. It should call self.listening() if successful, otherwise self.connecting() or reconnected_connect_failed() if the attempt is in progress or definitely failed, respectively. - + A listening passive client should constantly attempt to accept a new connection and report an accepted connection with self.connected(). - + - ovs.reconnect.DISCONNECT: The client should abort the current connection or connection attempt or listen attempt and call self.disconnected() or self.connect_failed() to indicate it. - + - ovs.reconnect.PROBE: The client should send some kind of request to the peer that will elicit a response, to ensure that the connection is indeed in working order. (This will only be returned if the "probe interval" is nonzero--see self.set_probe_interval()).""" - if now >= self.state.deadline(self): + + deadline = self.state.deadline(self) + if deadline is not None and now >= deadline: return self.state.run(self, now) else: return None - + def wait(self, poller, now): """Causes the next call to poller.block() to wake up when self.run() should be called.""" @@ -513,8 +523,8 @@ class Reconnect(object): def timeout(self, now): """Returns the number of milliseconds after which self.run() should be - called if nothing else notable happens in the meantime, or a negative - number if this is currently unnecessary.""" + called if nothing else notable happens in the meantime, or None if this + is currently unnecessary.""" deadline = self.state.deadline(self) if deadline is not None: remaining = deadline - now @@ -552,7 +562,7 @@ class Reconnect(object): stats.creation_time = self.creation_time stats.last_connected = self.last_connected stats.last_disconnected = self.last_disconnected - stats.last_received = self.last_received + stats.last_activity = self.last_activity stats.backoff = self.backoff stats.seqno = self.seqno stats.is_connected = self.is_connected() @@ -560,7 +570,8 @@ class Reconnect(object): stats.msec_since_disconnect = self.get_last_disconnect_elapsed(now) stats.total_connected_duration = self.total_connected_duration if self.is_connected(): - stats.total_connected_duration += self.get_last_connect_elapsed(now) + stats.total_connected_duration += ( + self.get_last_connect_elapsed(now)) stats.n_attempted_connections = self.n_attempted_connections stats.n_successful_connections = self.n_successful_connections stats.state = self.state.name