/ - Diff - ganeti-local - Greek Research and Technology Network's projects

     from ganeti import errors
     from ganeti import serializer
     from ganeti import objects
     from ganeti import locking
     from ganeti import impexpd
     from ganeti import netutils
-...
           poller.register(fd, select.POLLIN)
         if options.connect_timeout and mode == constants.IEM_IMPORT:
           listen_timeout = locking.RunningTimeout(options.connect_timeout, True)
           listen_timeout = utils.RunningTimeout(options.connect_timeout, True)
         else:
           listen_timeout = None
-...
               logging.info("Child process didn't establish connection in time")
               child.Kill(signal.SIGTERM)
               exit_timeout = \
                 locking.RunningTimeout(CHILD_LINGER_TIMEOUT, True)
                 utils.RunningTimeout(CHILD_LINGER_TIMEOUT, True)
               # Next block will calculate timeout
             else:
               # Not yet connected, check again in a second
-...
             notify_status = child_io_proc.NotifyDd()
             if notify_status:
               # Schedule next notification
               dd_stats_timeout = locking.RunningTimeout(DD_STATISTICS_INTERVAL,
                                                         True)
               dd_stats_timeout = utils.RunningTimeout(DD_STATISTICS_INTERVAL, True)
             else:
               # Try again soon (dd isn't ready yet)
               dd_stats_timeout = locking.RunningTimeout(1.0, True)
               dd_stats_timeout = utils.RunningTimeout(1.0, True)
           if dd_stats_timeout:
             dd_timeout = max(0, dd_stats_timeout.Remaining() * 1000)
-...
                       logging.info("Giving child process %0.2f seconds to exit",
                                    CHILD_LINGER_TIMEOUT)
                       exit_timeout = \
                         locking.RunningTimeout(CHILD_LINGER_TIMEOUT, True)
                         utils.RunningTimeout(CHILD_LINGER_TIMEOUT, True)
               else:
                 poller.unregister(fd)
                 del fdmap[fd]

     import os
     import select
     import threading
     import time
     import errno
     import weakref
     import logging
-...
       return wrap
     class RunningTimeout(object):
       """Class to calculate remaining timeout when doing several operations.
       """
       __slots__ = [
         "_allow_negative",
         "_start_time",
         "_time_fn",
         "_timeout",
+        ]
       def __init__(self, timeout, allow_negative, _time_fn=time.time):
         """Initializes this class.
         @type timeout: float
         @param timeout: Timeout duration
         @type allow_negative: bool
         @param allow_negative: Whether to return values below zero
         @param _time_fn: Time function for unittests
         """
         object.__init__(self)
         if timeout is not None and timeout < 0.0:
           raise ValueError("Timeout must not be negative")
         self._timeout = timeout
         self._allow_negative = allow_negative
         self._time_fn = _time_fn
         self._start_time = None
       def Remaining(self):
         """Returns the remaining timeout.
         """
         if self._timeout is None:
           return None
         # Get start time on first calculation
         if self._start_time is None:
           self._start_time = self._time_fn()
         # Calculate remaining time
         remaining_timeout = self._start_time + self._timeout - self._time_fn()
         if not self._allow_negative:
           # Ensure timeout is always >= 0
           return max(0.0, remaining_timeout)
         return remaining_timeout
     class _SingleNotifyPipeConditionWaiter(object):
       """Helper class for SingleNotifyPipeCondition
-...
         @param timeout: Timeout for waiting (can be None)
         """
         running_timeout = RunningTimeout(timeout, True)
         running_timeout = utils.RunningTimeout(timeout, True)
         while True:
           remaining_time = running_timeout.Remaining()
-...
         # We need to keep track of how long we spent waiting for a lock. The
         # timeout passed to this function is over all lock acquires.
         running_timeout = RunningTimeout(timeout, False)
         running_timeout = utils.RunningTimeout(timeout, False)
         try:
           if names is not None:

     from ganeti import rpc
     from ganeti import cmdlib
     from ganeti import locking
     from ganeti import utils
     class LockAcquireTimeout(Exception):
-...
         if timeout is None:
           calc_timeout = lambda: None
         else:
           calc_timeout = locking.RunningTimeout(timeout, False).Remaining
           calc_timeout = utils.RunningTimeout(timeout, False).Remaining
         self._cbs = cbs
         try:

         """
         return [val for val in items if not self.Matches(val)]
     class RunningTimeout(object):
       """Class to calculate remaining timeout when doing several operations.
       """
       __slots__ = [
         "_allow_negative",
         "_start_time",
         "_time_fn",
         "_timeout",
+        ]
       def __init__(self, timeout, allow_negative, _time_fn=time.time):
         """Initializes this class.
         @type timeout: float
         @param timeout: Timeout duration
         @type allow_negative: bool
         @param allow_negative: Whether to return values below zero
         @param _time_fn: Time function for unittests
         """
         object.__init__(self)
         if timeout is not None and timeout < 0.0:
           raise ValueError("Timeout must not be negative")
         self._timeout = timeout
         self._allow_negative = allow_negative
         self._time_fn = _time_fn
         self._start_time = None
       def Remaining(self):
         """Returns the remaining timeout.
         """
         if self._timeout is None:
           return None
         # Get start time on first calculation
         if self._start_time is None:
           self._start_time = self._time_fn()
         # Calculate remaining time
         remaining_timeout = self._start_time + self._timeout - self._time_fn()
         if not self._allow_negative:
           # Ensure timeout is always >= 0
           return max(0.0, remaining_timeout)
         return remaining_timeout

Synnefo » snf-ganeti » ganeti-local

Revision 557838c1