aexpect: Use time.monotonic() for time-diff operations

to avoid problems with NTP (or iffy clock sources) let's use
time.monotonic() for time difference operations.

Signed-off-by: Lukáš Doktor <ldoktor@redhat.com>

Author: ldoktor

aexpect/client.py

@@ -253,8 +253,8 @@ def _get_aexpect_helper(self, helper_cmd, pass_fds, echo, command):
         # Wait for the server to complete its initialization
         full_output = ""
         pattern = f"Server {self.a_id} ready"
-        end_time = time.time() + 60
-        while time.time() < end_time:
+        end_time = time.monotonic() + 60
+        while time.monotonic() < end_time:
             output = sub.stdout.readline().decode(self.encoding, "ignore")
             if pattern in output:
                 break
@@ -834,7 +834,7 @@ def _read_nonblocking(self, internal_timeout=None, timeout=None):
             internal_timeout *= 1000
         end_time = None
         if timeout:
-            end_time = time.time() + timeout
+            end_time = time.monotonic() + timeout
         expect_pipe = self._get_fd("expect")
         poller = select.poll()
         poller.register(expect_pipe, select.POLLIN)
@@ -853,7 +853,7 @@ def _read_nonblocking(self, internal_timeout=None, timeout=None):
                 data += raw_data.decode(self.encoding, "ignore")
             else:
                 return read, data
-            if end_time and time.time() > end_time:
+            if end_time and time.monotonic() > end_time:
                 return read, data
 
     def read_nonblocking(self, internal_timeout=None, timeout=None):
@@ -941,10 +941,10 @@ def read_until_output_matches(self, patterns, filter_func=lambda x: x,
         poller = select.poll()
         poller.register(expect_pipe, select.POLLIN)
         output = ""
-        end_time = time.time() + timeout
+        end_time = time.monotonic() + timeout
         while True:
             try:
-                max_ms = int((end_time - time.time()) * 1000)
+                max_ms = int((end_time - time.monotonic()) * 1000)
                 poll_timeout_ms = max(0, max_ms)
                 poll_status = poller.poll(poll_timeout_ms)
             except select.error:
@@ -953,7 +953,7 @@ def read_until_output_matches(self, patterns, filter_func=lambda x: x,
                 raise ExpectTimeoutError(patterns, output)
             # Read data from child
             read, data = self._read_nonblocking(internal_timeout,
-                                                end_time - time.time())
+                                                end_time - time.monotonic())
             if not read:
                 break
             if not data:
@@ -1187,10 +1187,10 @@ def is_responsive(self, timeout=5.0):
         # Send a newline
         self.sendline()
         # Wait up to timeout seconds for some output from the child
-        end_time = time.time() + timeout
-        while time.time() < end_time:
+        end_time = time.monotonic() + timeout
+        while time.monotonic() < end_time:
             time.sleep(0.5)
-            if self.read_nonblocking(0, end_time - time.time()).strip():
+            if self.read_nonblocking(0, end_time - time.monotonic()).strip():
                 return True
         # No output -- report unresponsive
         return False
@@ -1299,8 +1299,8 @@ def cmd_output_safe(self, cmd, timeout=60, strip_console_codes=False):
         self.sendline(cmd)
         out = ""
         success = False
-        start_time = time.time()
-        while (time.time() - start_time) < timeout:
+        start_time = time.monotonic()
+        while (time.monotonic() - start_time) < timeout:
             try:
                 out += self.read_up_to_prompt(0.5)
                 success = True
@@ -1567,8 +1567,8 @@ def run_tail(command, termination_func=None, output_func=None,
                       pass_fds=pass_fds,
                       encoding=encoding)
 
-    end_time = time.time() + timeout
-    while time.time() < end_time and bg_process.is_alive():
+    end_time = time.monotonic() + timeout
+    while time.monotonic() < end_time and bg_process.is_alive():
         time.sleep(0.1)
 
     return bg_process
@@ -1610,8 +1610,8 @@ def run_bg(command, termination_func=None, output_func=None, output_prefix="",
                         pass_fds=pass_fds,
                         encoding=encoding)
 
-    end_time = time.time() + timeout
-    while time.time() < end_time and bg_process.is_alive():
+    end_time = time.monotonic() + timeout
+    while time.monotonic() < end_time and bg_process.is_alive():
         time.sleep(0.1)
 
     return bg_process

aexpect/remote.py

@@ -464,9 +464,9 @@ def wait_for_login(client, host, port, username, password, prompt,
     """
     LOG.debug("Attempting to log into %s:%s using %s (timeout %ds)",
               host, port, client, timeout)
-    end_time = time.time() + timeout
+    end_time = time.monotonic() + timeout
     verbose = False
-    while time.time() < end_time:
+    while time.monotonic() < end_time:
         try:
             return remote_login(client, host, port, username, password, prompt,
                                 linesep, log_filename, log_function,
@@ -1100,9 +1100,9 @@ def transfer(*args, **kwargs):
             msg = f"Copy file from {args[0]}:{args[5]} to {args[6]}, "
         else:
             msg = f"Copy file from {args[5]} to {args[0]}:{args[6]}, "
-        start_time = time.time()
+        start_time = time.monotonic()
         ret = func(*args, **kwargs)
-        elapsed_time = time.time() - start_time
+        elapsed_time = time.monotonic() - start_time
         if kwargs.get("filesize", None) is not None:
             throughput = kwargs["filesize"] / elapsed_time
             msg += f"estimated throughput: {throughput:.2f} MB/s"

aexpect/rss_client.py

@@ -142,7 +142,7 @@ def __init__(self, address, port, log_func=None, timeout=20):
                                            "receive magic number") from timeout_error
         self._send(struct.pack("=i", CHUNKSIZE))
         self._log_func = log_func
-        self._last_time = time.time()
+        self._last_time = time.monotonic()
         self._last_transferred = 0
         self.transferred = 0
 
@@ -170,10 +170,10 @@ def _send(self, data, timeout=60):
 
     def _receive(self, size, timeout=60):
         strs = []
-        end_time = time.time() + timeout
+        end_time = time.monotonic() + timeout
         try:
             while size > 0:
-                timeout = end_time - time.time()
+                timeout = end_time - time.monotonic()
                 if timeout <= 0:
                     raise socket.timeout
                 self._socket.settimeout(timeout)
@@ -195,14 +195,14 @@ def _receive(self, size, timeout=60):
 
     def _report_stats(self, data):
         if self._log_func:
-            delta = time.time() - self._last_time
+            delta = time.monotonic() - self._last_time
             if delta >= 1:
                 transferred = self.transferred / 1048576.
                 speed = (self.transferred - self._last_transferred) / delta
                 speed /= 1048576.
                 self._log_func(f"{data} {transferred:.3f} MB ({speed:.3f}"
                                " MB/sec)")
-                self._last_time = time.time()
+                self._last_time = time.monotonic()
                 self._last_transferred = self.transferred
 
     def _send_packet(self, data, timeout=60):
@@ -224,10 +224,10 @@ def _send_file_chunks(self, filename, timeout=60):
             self._log_func(f"Sending file {filename}")
         with open(filename, "rb") as file_handle:
             try:
-                end_time = time.time() + timeout
+                end_time = time.monotonic() + timeout
                 while True:
                     data = file_handle.read(CHUNKSIZE)
-                    self._send_packet(data, int(end_time - time.time()))
+                    self._send_packet(data, int(end_time - time.monotonic()))
                     if len(data) < CHUNKSIZE:
                         break
             except FileTransferError as error:
@@ -239,9 +239,9 @@ def _receive_file_chunks(self, filename, timeout=60):
             self._log_func(f"Receiving file {filename}")
         with open(filename, "wb") as file_handle:
             try:
-                end_time = time.time() + timeout
+                end_time = time.monotonic() + timeout
                 while True:
-                    data = self._receive_packet(int(end_time - time.time()))
+                    data = self._receive_packet(int(end_time - time.monotonic()))
                     file_handle.write(data)
                     if len(data) < CHUNKSIZE:
                         break
@@ -299,7 +299,7 @@ def _upload_file(self, path, end_time):
         if os.path.isfile(path):
             self._send_msg(RSS_CREATE_FILE)
             self._send_packet(os.path.basename(path).encode())
-            self._send_file_chunks(path, end_time - time.time())
+            self._send_file_chunks(path, end_time - time.monotonic())
         elif os.path.isdir(path):
             self._send_msg(RSS_CREATE_DIR)
             self._send_packet(os.path.basename(path).encode())
@@ -342,7 +342,7 @@ def upload(self, src_pattern, dst_path, timeout=600):
                                         message to the client
         :note: Other exceptions can be raised.
         """
-        end_time = time.time() + timeout
+        end_time = time.monotonic() + timeout
         try:
             try:
                 self._send_msg(RSS_SET_PATH)
@@ -362,7 +362,7 @@ def upload(self, src_pattern, dst_path, timeout=600):
                                                     "does not match any files "
                                                     "or directories")
                 # Look for RSS_OK or RSS_ERROR
-                msg = self._receive_msg(int(end_time - time.time()))
+                msg = self._receive_msg(int(end_time - time.monotonic()))
                 if msg == RSS_OK:
                     return
                 if msg == RSS_ERROR:
@@ -438,7 +438,7 @@ def download(self, src_pattern, dst_path, timeout=600):
         :note: Other exceptions can be raised.
         """
         dst_path = os.path.abspath(dst_path)
-        end_time = time.time() + timeout
+        end_time = time.monotonic() + timeout
         file_count = 0
         dir_count = 0
         try:
@@ -454,7 +454,7 @@ def download(self, src_pattern, dst_path, timeout=600):
                     filename = self._receive_packet().decode()
                     if os.path.isdir(dst_path):
                         dst_path = os.path.join(dst_path, filename)
-                    self._receive_file_chunks(dst_path, int(end_time - time.time()))
+                    self._receive_file_chunks(dst_path, int(end_time - time.monotonic()))
                     dst_path = os.path.dirname(dst_path)
                     file_count += 1
                 elif msg == RSS_CREATE_DIR:

aexpect/shared.py

@@ -29,13 +29,13 @@ def get_lock_fd(filename, timeout=-1):
     lock_flags = fcntl.LOCK_EX
     if timeout > 0:
         lock_flags |= fcntl.LOCK_NB
-    end_time = time.time() + timeout if timeout > 0 else -1
+    end_time = time.monotonic() + timeout if timeout > 0 else -1
     while True:
         try:
             fcntl.flock(lock_fd, lock_flags)
             break
         except IOError:
-            if time.time() > end_time:
+            if time.monotonic() > end_time:
                 os.close(lock_fd)
                 raise
     return lock_fd

aexpect/utils/wait.py

@@ -30,14 +30,14 @@ def wait_for(func, timeout, first=0.0, step=1.0, text=None):
     :param step: Time to sleep between attempts in seconds
     :param text: Text to print while waiting, for debug purposes
     """
-    start_time = time.time()
-    end_time = time.time() + timeout
+    start_time = time.monotonic()
+    end_time = time.monotonic() + timeout
 
     time.sleep(first)
 
-    while time.time() < end_time:
+    while time.monotonic() < end_time:
         if text:
-            _LOG.debug("%s (%f secs)", text, (time.time() - start_time))
+            _LOG.debug("%s (%f secs)", text, (time.monotonic() - start_time))
 
         output = func()
         if output: