Changeset 491:bbb12d16377f

Timestamp:

2006-02-18 21:32:10 (4 years ago)

Author:

Stefan Schwarzer <sschwarzer@…>

Branch:

default

convert_revision:

svn:778c30c8-61e0-0310-89d4-fe2f97a467b2/trunk@510

Message:

Reworked keep-alive functionality regarding writable files. If you read
the code, you will see that it's potentially brittle, and I may remove
the keep-alive code completely before the final 2.1 release.

In `ftp_file.py`, renamed `_binmode` and `_readmode` to `_bin_mode` and
`_read_mode`, respectively.

Files:

• _test_real_ftp.py (modified) (3 diffs)
• ftp_error.py (modified) (1 diff)
• ftp_file.py (modified) (8 diffs)
• ftputil.py (modified) (2 diffs)

_test_real_ftp.py

@@ -337 +337 @@
                 print "Keeping host alive (%d of %d) " % (i+1, intervals)
                 host.keep_alive(ignore_errors=True)
+                self.assertRaises(ftp_error.KeepAliveError, host.keep_alive)
+                # open written files can't be "kept alive",
+                #  so cause some activity
+                written_file.write("x")
+                written_file.flush()
                 time.sleep(interval_length)
             # do some tests; order of statements is important
@@ -342 +347 @@
             #   files get reused)
             self.assertEqual(read_file.read(2), "Te")
-            written_file.write("xyz")
             # - try to reuse the stale files
             written_file2 = host.file("_test_file3_", "w")
@@ -354 +358 @@
         finally:
             # clean up
-            print 2, host.listdir(".")
-#             host.remove("_test_file_")
-#             host.remove("_test_file2_")
-#             host.remove("_test_file3_")
+            host.remove("_test_file_")
+            host.remove("_test_file2_")
+            host.remove("_test_file3_")
 
 

ftp_error.py

@@ -61 +61 @@
 class TimeShiftError(InternalError): pass
 class ParserError(InternalError): pass
+class KeepAliveError(InternalError): pass
 
 class FTPOSError(FTPError, OSError): pass

ftp_file.py

@@ -99 +99 @@
             raise ftp_error.FTPIOError("invalid mode '%s'" % mode)
         # remember convenience variables instead of mode
-        self._binmode = 'b' in mode
-        self._readmode = 'r' in mode
+        self._bin_mode = 'b' in mode
+        self._read_mode = 'r' in mode
         # select ASCII or binary mode
-        transfer_type = ('A', 'I')[self._binmode]
+        transfer_type = ('A', 'I')[self._bin_mode]
         command = 'TYPE %s' % transfer_type
         ftp_error._try_with_ioerror(self._session.voidcmd, command)
         # make transfer command
-        command_type = ('STOR', 'RETR')[self._readmode]
+        command_type = ('STOR', 'RETR')[self._read_mode]
         command = '%s %s' % (command_type, path)
         # ensure we can process the raw line separators;
@@ -131 +131 @@
         """Return read bytes, normalized if in text transfer mode."""
         data = self._fo.read(*args)
-        if self._binmode:
+        if self._bin_mode:
             return data
         data = _crlf_to_python_linesep(data)
@@ -164 +164 @@
         """Return one read line, normalized if in text transfer mode."""
         data = self._fo.readline(*args)
-        if self._binmode:
+        if self._bin_mode:
             return data
         # if necessary, complete begun newline
@@ -174 +174 @@
         """Return read lines, normalized if in text transfer mode."""
         lines = self._fo.readlines(*args)
-        if self._binmode:
+        if self._bin_mode:
             return lines
         # more memory-friendly than `return [... for line in lines]`
@@ -186 +186 @@
         separator conversion support.
         """
-        if self._binmode:
+        if self._bin_mode:
             return self._fo.xreadlines()
         return _XReadlines(self)
@@ -192 +192 @@
     def write(self, data):
         """Write data to file. Do linesep conversion for text mode."""
-        if not self._binmode:
+        if not self._bin_mode:
             data = _python_to_crlf_linesep(data)
         self._fo.write(data)
@@ -198 +198 @@
     def writelines(self, lines):
         """Write lines to file. Do linesep conversion for text mode."""
-        if self._binmode:
+        if self._bin_mode:
             self._fo.writelines(lines)
             return
@@ -221 +221 @@
               "'FTPFile' object has no attribute '%s'" % attr_name)
 
-    def keep_alive(self):
+    def keep_alive(self, ignore_errors=False):
         """
         Keep the connection busy to prevent lost connections
         because of server timeouts.
-        """
-        if self._readmode:
+
+        Since this doesn't seem to work for writable files,
+        `ignore_errors` must be set to a true value to avoid that a
+        `KeepAliveError` is raised. By default, `ignore_errors` is a
+        false value, so errors can't pass silently.
+        """
+        if self.closed:
+            self._host.getcwd()
+        elif self._read_mode:
             self.read(0)
         else:
-            self.write("")
+            # I thought about putting `self.flush()` here; this will
+            #  work if the client wrote at least a byte in the file
+            #  since the last flush. However, using `flush()` here
+            #  could lead to subtle failures in ftputil client code.
+            #  Post on the ftputil mailing list if you think the
+            #  `flush` call is appropriate here.
+            if not ignore_errors:
+                raise ftp_error.KeepAliveError(
+                      "keep-alive doesn't work for writable files")
 
     def close(self):

ftputil.py

@@ -249 +249 @@
         return self.file(path, mode)
 
-    def keep_alive(self, also_files=True):
+    def keep_alive(self, also_files=True, ignore_errors=False):
         """
         Do something without side effects to keep the connection to
@@ -260 +260 @@
         may want to set `also_files` to `False` and call the
         `keep_alive` method of the file-like objects individually.
-        """
-        # just prevent loss of the connection, so discard the result
+
+        If `ignore_errors` is set to a false value (the default),
+        keep-alive attempts on writable files will raise a
+        `KeepAliveError` (because there doesn't seem to be a way to
+        implement this functionality). Set `ignore_errors` to a true
+        value to mask such errors.
+        """
+        # discard result
         self.getcwd()
         # refresh also connections of associated file-like objects
         if also_files:
             for host in self._children:
-                host._file.keep_alive()
+                host._file.keep_alive(ignore_errors=ignore_errors)
 
     def close(self):