Committing tempfile patch to branch.

This tempfile module is r1.27 from the Python MAIN CVS branch.  It fixes two rac
e conditions.

We will place this in lib/python and try to keep it up to date until we ditch Py
thon 1.52, at which time we can rely on the (patched) tempfile.py that ships wit
h the Python 2.X series.

lib/python/tempfile.py

+"""Temporary files and filenames.  This is r1.27 of the Python MAIN CVS
+branch that we're placing in lib/python so it overrides the PYTHONPATH's
+tempfile to fix a tempfile race condition in the Python 1.5.2 tempfile module
+implementation."""
+
+# XXX This tries to be not UNIX specific, but I don't know beans about
+# how to choose a temp directory or filename on MS-DOS or other
+# systems so it may have to be changed...
+import os
+
+# Parameters that the caller may set to override the defaults
+tempdir = None
+template = None
+
+def gettempdir():
+    """Function to calculate the directory to use."""
+    global tempdir
+    if tempdir is not None:
+        return tempdir
+    try:
+        pwd = os.getcwd()
+    except (AttributeError, os.error):
+        pwd = os.curdir
+    attempdirs = ['/var/tmp', '/usr/tmp', '/tmp', pwd]
+    if os.name == 'nt':
+        attempdirs.insert(0, 'C:\\TEMP')
+        attempdirs.insert(0, '\\TEMP')
+    elif os.name == 'mac':
+        import macfs, MACFS
+        try:
+            refnum, dirid = macfs.FindFolder(MACFS.kOnSystemDisk,
+                                             MACFS.kTemporaryFolderType, 1)
+            dirname = macfs.FSSpec((refnum, dirid, '')).as_pathname()
+            attempdirs.insert(0, dirname)
+        except macfs.error:
+            pass
+    for envname in 'TMPDIR', 'TEMP', 'TMP':
+        if os.environ.has_key(envname):
+            attempdirs.insert(0, os.environ[envname])
+    testfile = gettempprefix() + 'test'
+    for dir in attempdirs:
+        try:
+            filename = os.path.join(dir, testfile)
+            if os.name == 'posix':
+                try:
+                    fd = os.open(filename, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0700)
+                except OSError:
+                    pass
+                else:
+                    fp = os.fdopen(fd, 'w')
+                    fp.write('blat')
+                    fp.close()
+                    os.unlink(filename)
+                    del fp, fd
+                    tempdir = dir
+                    break
+            else:
+                fp = open(filename, 'w')
+                fp.write('blat')
+                fp.close()
+                os.unlink(filename)
+                tempdir = dir
+                break
+        except IOError:
+            pass
+    if tempdir is None:
+        msg = "Can't find a usable temporary directory amongst " + `attempdirs`
+        raise IOError, msg
+    return tempdir
+
+
+# template caches the result of gettempprefix, for speed, when possible.
+# XXX unclear why this isn't "_template"; left it "template" for backward
+# compatibility.
+if os.name == "posix":
+    # We don't try to cache the template on posix:  the pid may change on us
+    # between calls due to a fork, and on Linux the pid changes even for
+    # another thread in the same process.  Since any attempt to keep the
+    # cache in synch would have to call os.getpid() anyway in order to make
+    # sure the pid hasn't changed between calls, a cache wouldn't save any
+    # time.  In addition, a cache is difficult to keep correct with the pid
+    # changing willy-nilly, and earlier attempts proved buggy (races).
+    template = None
+
+# Else the pid never changes, so gettempprefix always returns the same
+# string.
+elif os.name == "nt":
+    template = '~' + `os.getpid()` + '-'
+elif os.name == 'mac':
+    template = 'Python-Tmp-'
+else:
+    template = 'tmp' # XXX might choose a better one
+
+def gettempprefix():
+    """Function to calculate a prefix of the filename to use.
+
+    This incorporates the current process id on systems that support such a
+    notion, so that concurrent processes don't generate the same prefix.
+    """
+
+    global template
+    if template is None:
+        return '@' + `os.getpid()` + '.'
+    else:
+        return template
+
+
+def mktemp(suffix=""):
+    """User-callable function to return a unique temporary file name."""
+    dir = gettempdir()
+    pre = gettempprefix()
+    while 1:
+        i = _counter.get_next()
+        file = os.path.join(dir, pre + str(i) + suffix)
+        if not os.path.exists(file):
+            return file
+
+
+class TemporaryFileWrapper:
+    """Temporary file wrapper
+
+    This class provides a wrapper around files opened for temporary use.
+    In particular, it seeks to automatically remove the file when it is
+    no longer needed.
+    """
+    def __init__(self, file, path):
+        self.file = file
+        self.path = path
+
+    def close(self):
+        self.file.close()
+        os.unlink(self.path)
+
+    def __del__(self):
+        try: self.close()
+        except: pass
+
+    def __getattr__(self, name):
+        file = self.__dict__['file']
+        a = getattr(file, name)
+        if type(a) != type(0):
+            setattr(self, name, a)
+        return a
+
+
+def TemporaryFile(mode='w+b', bufsize=-1, suffix=""):
+    """Create and return a temporary file (opened read-write by default)."""
+    name = mktemp(suffix)
+    if os.name == 'posix':
+        # Unix -- be very careful
+        fd = os.open(name, os.O_RDWR|os.O_CREAT|os.O_EXCL, 0700)
+        try:
+            os.unlink(name)
+            return os.fdopen(fd, mode, bufsize)
+        except:
+            os.close(fd)
+            raise
+    else:
+        # Non-unix -- can't unlink file that's still open, use wrapper
+        file = open(name, mode, bufsize)
+        return TemporaryFileWrapper(file, name)
+
+# In order to generate unique names, mktemp() uses _counter.get_next().
+# This returns a unique integer on each call, in a threadsafe way (i.e.,
+# multiple threads will never see the same integer).  The integer will
+# usually be a Python int, but if _counter.get_next() is called often
+# enough, it will become a Python long.
+# Note that the only name that survives this next block of code
+# is "_counter".
+
+class _ThreadSafeCounter:
+    def __init__(self, mutex, initialvalue=0):
+        self.mutex = mutex
+        self.i = initialvalue
+
+    def get_next(self):
+        self.mutex.acquire()
+        result = self.i
+        try:
+            newi = result + 1
+        except OverflowError:
+            newi = long(result) + 1
+        self.i = newi
+        self.mutex.release()
+        return result
+
+try:
+    import thread
+
+except ImportError:
+    class _DummyMutex:
+        def acquire(self):
+            pass
+
+        release = acquire
+
+    _counter = _ThreadSafeCounter(_DummyMutex())
+    del _DummyMutex
+
+else:
+    _counter = _ThreadSafeCounter(thread.allocate_lock())
+    del thread
+
+del _ThreadSafeCounter
+