building: build inotify for sys.platform='linux*'

If Python interpreter was built under Linux 3.x kernel, it reports
sys.platform to be 'linux3' (it is fixed for Python 3, but not for 2.x).
This cancels building inotify extension, which was built only for 'linux2'
platform. Improved test checks if sys.platform begins with 'linux', and together
with test for kernel version to be greater than 2.6 it seems to cover all known
cases.

contrib/setup3k.py

@@ -1,373 +1,373 b''
 #
 # This is an experimental py3k-enabled mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 
 from distutils.command.build_py import build_py_2to3
 from lib2to3.refactor import get_fixers_from_package as getfixers
 
 import sys
 if not hasattr(sys, 'version_info') or sys.version_info < (2, 4, 0, 'final'):
     raise SystemExit("Mercurial requires Python 2.4 or later.")
 
 if sys.version_info[0] >= 3:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s.encode('latin1')
 else:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
     sha = hashlib.sha1()
 except:
     try:
         import sha
     except:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install).")
 
 try:
     import zlib
 except:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install).")
 
 try:
     import bz2
 except:
     raise SystemExit(
         "Couldn't import standard bz2 (incomplete Python install).")
 
 import os, subprocess, time
 import shutil
 import tempfile
 from distutils import log
 from distutils.core import setup, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.spawn import spawn, find_executable
 from distutils.ccompiler import new_compiler
 from distutils.errors import CCompilerError
 
 scripts = ['hg']
 if os.name == 'nt':
     scripts.append('contrib/win32/hg.bat')
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         try:
             fname = os.path.join(tmpdir, 'funcname.c')
             f = open(fname, 'w')
             f.write('int main(void) {\n')
             f.write('    %s();\n' % funcname)
             f.write('}\n')
             f.close()
             # Redirect stderr to /dev/null to hide any error messages
             # from the compiler.
             # This will have to be changed if we ever have to check
             # for a function on Windows.
             devnull = open('/dev/null', 'w')
             oldstderr = os.dup(sys.stderr.fileno())
             os.dup2(devnull.fileno(), sys.stderr.fileno())
             objects = cc.compile([fname], output_dir=tmpdir)
             cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         except:
             return False
         return True
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 # py2exe needs to be installed to work
 try:
     import py2exe
     py2exeloaded = True
 
     # Help py2exe to find win32com.shell
     try:
         import modulefinder
         import win32com
         for p in win32com.__path__[1:]: # Take the path to win32comext
             modulefinder.AddPackagePath("win32com", p)
         pn = "win32com.shell"
         __import__(pn)
         m = sys.modules[pn]
         for p in m.__path__[1:]:
             modulefinder.AddPackagePath(pn, p)
     except ImportError:
         pass
 
 except ImportError:
     py2exeloaded = False
     pass
 
 def runcmd(cmd, env):
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, env=env)
     out, err = p.communicate()
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [e for e in err.splitlines()
            if not e.startswith(b('Not trusting file')) \
               and not e.startswith(b('warning: Not importing'))]
     if err:
         return ''
     return out
 
 version = ''
 
 if os.path.isdir('.hg'):
     # Execute hg out of this directory with a custom environment which
     # includes the pure Python modules in mercurial/pure. We also take
     # care to not use any hgrc files and do no localization.
     pypath = ['mercurial', os.path.join('mercurial', 'pure')]
     env = {'PYTHONPATH': os.pathsep.join(pypath),
            'HGRCPATH': '',
            'LANGUAGE': 'C'}
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # Copy SystemRoot into the custom environment for Python 2.6
         # under Windows. Otherwise, the subprocess will fail with
         # error 0xc0150004. See: http://bugs.python.org/issue3440
         env['SystemRoot'] = os.environ['SystemRoot']
     cmd = [sys.executable, 'hg', 'id', '-i', '-t']
     l = runcmd(cmd, env).split()
     while len(l) > 1 and l[-1][0].isalpha(): # remove non-numbered tags
         l.pop()
     if len(l) > 1: # tag found
         version = l[-1]
         if l[0].endswith('+'): # propagate the dirty status to the tag
             version += '+'
     elif len(l) == 1: # no tag found
         cmd = [sys.executable, 'hg', 'parents', '--template',
                '{latesttag}+{latesttagdistance}-']
         version = runcmd(cmd, env) + l[0]
     if version.endswith('+'):
         version += time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict([[t.strip() for t in l.split(':', 1)]
                for l in open('.hg_archival.txt')])
     if 'tag' in kw:
         version =  kw['tag']
     elif 'latesttag' in kw:
         version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw
     else:
         version = kw.get('node', '')[:12]
 
 if version:
     f = open("mercurial/__version__.py", "w")
     f.write('# this file is autogenerated by setup.py\n')
     f.write('version = "%s"\n' % version)
     f.close()
 
 
 try:
     from mercurial import __version__
     version = __version__.version
 except ImportError:
     version = 'unknown'
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn("could not find msgfmt executable, no translations "
                      "will be built")
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 # Insert hgbuildmo first so that files in mercurial/locale/ are found
 # when build_py is run next.
 build.sub_commands.insert(0, ('build_mo', None))
 # We also need build_ext before build_py. Otherwise, when 2to3 is called (in
 # build_py), it will not find osutil & friends, thinking that those modules are
 # global and, consequently, making a mess, now that all module imports are
 # global.
 build.sub_commands.insert(1, ('build_ext', None))
 
 Distribution.pure = 0
 Distribution.global_options.append(('pure', None, "use pure (slow) Python "
                                     "code instead of C extensions"))
 
 class hgbuildext(build_ext):
 
     def build_extension(self, ext):
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not hasattr(ext, 'optional') or not ext.optional:
                 raise
             log.warn("Failed to build optional extension '%s' (skipping)",
                      ext.name)
 
 class hgbuildpy(build_py_2to3):
     fixer_names = sorted(set(getfixers("lib2to3.fixes") +
                              getfixers("hgfixes")))
 
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             if self.py_modules is None:
                 self.py_modules = []
             for ext in self.distribution.ext_modules:
                 if ext.name.startswith("mercurial."):
                     self.py_modules.append("mercurial.pure.%s" % ext.name[10:])
             self.distribution.ext_modules = []
 
     def find_modules(self):
         modules = build_py.find_modules(self)
         for module in modules:
             if module[0] == "mercurial.pure":
                 if module[1] != "__init__":
                     yield ("mercurial", module[1], module[2])
             else:
                 yield module
 
     def run(self):
         # In the build_py_2to3 class, self.updated_files = [], but I couldn't
         # see when that variable was updated to point to the updated files, as
         # its names suggests. Thus, I decided to just find_all_modules and feed
         # them to 2to3. Unfortunately, subsequent calls to setup3k.py will
         # incur in 2to3 analysis overhead.
         self.updated_files = [i[2] for i in self.find_all_modules()]
 
         # Base class code
         if self.py_modules:
             self.build_modules()
         if self.packages:
             self.build_packages()
             self.build_package_data()
 
         # 2to3
         self.run_2to3(self.updated_files)
 
         # Remaining base class code
         self.byte_compile(self.get_outputs(include_bytecode=0))
 
 cmdclass = {'build_mo': hgbuildmo,
             'build_ext': hgbuildext,
             'build_py': hgbuildpy}
 
 packages = ['mercurial', 'mercurial.hgweb', 'hgext', 'hgext.convert',
             'hgext.highlight', 'hgext.zeroconf']
 
 pymodules = []
 
 extmodules = [
     Extension('mercurial.base85', ['mercurial/base85.c']),
     Extension('mercurial.bdiff', ['mercurial/bdiff.c']),
     Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c']),
     Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
     Extension('mercurial.parsers', ['mercurial/parsers.c']),
     ]
 
 # disable osutil.c under windows + python 2.4 (issue1364)
 if sys.platform == 'win32' and sys.version_info < (2, 5, 0, 'final'):
     pymodules.append('mercurial.pure.osutil')
 else:
     extmodules.append(Extension('mercurial.osutil', ['mercurial/osutil.c']))
 
-if sys.platform == 'linux2' and os.uname()[2] > '2.6':
+if sys.platform.startswith('linux') and os.uname()[2] > '2.6':
     # The inotify extension is only usable with Linux 2.6 kernels.
     # You also need a reasonably recent C library.
     # In any case, if it fails to build the error will be skipped ('optional').
     cc = new_compiler()
     if hasfunction(cc, 'inotify_add_watch'):
         inotify = Extension('hgext.inotify.linux._inotify',
                             ['hgext/inotify/linux/_inotify.c'],
                             ['mercurial'])
         inotify.optional = True
         extmodules.append(inotify)
         packages.extend(['hgext.inotify', 'hgext.inotify.linux'])
 
 packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
                              'help/*.txt']}
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         curdir = curdir.split(os.sep, 1)[1]
         dirs[:] = filter(ordinarypath, dirs)
         for f in filter(ordinarypath, files):
             f = os.path.join(curdir, f)
             packagedata['mercurial'].append(f)
 
 datafiles = []
 setupversion = version
 extra = {}
 
 if py2exeloaded:
     extra['console'] = [
         {'script':'hg',
          'copyright':'Copyright (C) 2005-2010 Matt Mackall and others',
          'product_version':version}]
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = version.split('+', 1)[0]
 
 setup(name='mercurial',
       version=setupversion,
       author='Matt Mackall',
       author_email='[e-mail]',
       url='http://mercurial.selenic.com/',
       description='Scalable distributed SCM',
       license='GNU GPLv2+',
       scripts=scripts,
       packages=packages,
       py_modules=pymodules,
       ext_modules=extmodules,
       data_files=datafiles,
       package_data=packagedata,
       cmdclass=cmdclass,
       options=dict(py2exe=dict(packages=['hgext', 'email']),
                    bdist_mpkg=dict(zipdist=True,
                                    license='COPYING',
                                    readme='contrib/macosx/Readme.html',
                                    welcome='contrib/macosx/Welcome.html')),
       **extra)

hgext/inotify/server.py

@@ -1,492 +1,492 b''
 # server.py - common entry point for inotify status server
 #
 # Copyright 2009 Nicolas Dumazet <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from mercurial.i18n import _
 from mercurial import cmdutil, osutil, util
 import common
 
 import errno
 import os
 import socket
 import stat
 import struct
 import sys
 import tempfile
 
 class AlreadyStartedException(Exception):
     pass
 class TimeoutException(Exception):
     pass
 
 def join(a, b):
     if a:
         if a[-1] == '/':
             return a + b
         return a + '/' + b
     return b
 
 def split(path):
     c = path.rfind('/')
     if c == -1:
         return '', path
     return path[:c], path[c + 1:]
 
 walk_ignored_errors = (errno.ENOENT, errno.ENAMETOOLONG)
 
 def walk(dirstate, absroot, root):
     '''Like os.walk, but only yields regular files.'''
 
     # This function is critical to performance during startup.
 
     def walkit(root, reporoot):
         files, dirs = [], []
 
         try:
             fullpath = join(absroot, root)
             for name, kind in osutil.listdir(fullpath):
                 if kind == stat.S_IFDIR:
                     if name == '.hg':
                         if not reporoot:
                             return
                     else:
                         dirs.append(name)
                         path = join(root, name)
                         if dirstate._ignore(path):
                             continue
                         for result in walkit(path, False):
                             yield result
                 elif kind in (stat.S_IFREG, stat.S_IFLNK):
                     files.append(name)
             yield fullpath, dirs, files
 
         except OSError, err:
             if err.errno == errno.ENOTDIR:
                 # fullpath was a directory, but has since been replaced
                 # by a file.
                 yield fullpath, dirs, files
             elif err.errno not in walk_ignored_errors:
                 raise
 
     return walkit(root, root == '')
 
 class directory(object):
     """
     Representing a directory
 
     * path is the relative path from repo root to this directory
     * files is a dict listing the files in this directory
         - keys are file names
         - values are file status
     * dirs is a dict listing the subdirectories
         - key are subdirectories names
         - values are directory objects
     """
     def __init__(self, relpath=''):
         self.path = relpath
         self.files = {}
         self.dirs = {}
 
     def dir(self, relpath):
         """
         Returns the directory contained at the relative path relpath.
         Creates the intermediate directories if necessary.
         """
         if not relpath:
             return self
         l = relpath.split('/')
         ret = self
         while l:
             next = l.pop(0)
             try:
                 ret = ret.dirs[next]
             except KeyError:
                 d = directory(join(ret.path, next))
                 ret.dirs[next] = d
                 ret = d
         return ret
 
     def walk(self, states, visited=None):
         """
         yield (filename, status) pairs for items in the trees
         that have status in states.
         filenames are relative to the repo root
         """
         for file, st in self.files.iteritems():
             if st in states:
                 yield join(self.path, file), st
         for dir in self.dirs.itervalues():
             if visited is not None:
                 visited.add(dir.path)
             for e in dir.walk(states):
                 yield e
 
     def lookup(self, states, path, visited):
         """
         yield root-relative filenames that match path, and whose
         status are in states:
         * if path is a file, yield path
         * if path is a directory, yield directory files
         * if path is not tracked, yield nothing
         """
         if path[-1] == '/':
             path = path[:-1]
 
         paths = path.split('/')
 
         # we need to check separately for last node
         last = paths.pop()
 
         tree = self
         try:
             for dir in paths:
                 tree = tree.dirs[dir]
         except KeyError:
             # path is not tracked
             visited.add(tree.path)
             return
 
         try:
             # if path is a directory, walk it
             target = tree.dirs[last]
             visited.add(target.path)
             for file, st in target.walk(states, visited):
                 yield file
         except KeyError:
             try:
                 if tree.files[last] in states:
                     # path is a file
                     visited.add(tree.path)
                     yield path
             except KeyError:
                 # path is not tracked
                 pass
 
 class repowatcher(object):
     """
     Watches inotify events
     """
     statuskeys = 'almr!?'
 
     def __init__(self, ui, dirstate, root):
         self.ui = ui
         self.dirstate = dirstate
 
         self.wprefix = join(root, '')
         self.prefixlen = len(self.wprefix)
 
         self.tree = directory()
         self.statcache = {}
         self.statustrees = dict([(s, directory()) for s in self.statuskeys])
 
         self.ds_info = self.dirstate_info()
 
         self.last_event = None
 
 
     def handle_timeout(self):
         pass
 
     def dirstate_info(self):
         try:
             st = os.lstat(self.wprefix + '.hg/dirstate')
             return st.st_mtime, st.st_ino
         except OSError, err:
             if err.errno != errno.ENOENT:
                 raise
             return 0, 0
 
     def filestatus(self, fn, st):
         try:
             type_, mode, size, time = self.dirstate._map[fn][:4]
         except KeyError:
             type_ = '?'
         if type_ == 'n':
             st_mode, st_size, st_mtime = st
             if size == -1:
                 return 'l'
             if size and (size != st_size or (mode ^ st_mode) & 0100):
                 return 'm'
             if time != int(st_mtime):
                 return 'l'
             return 'n'
         if type_ == '?' and self.dirstate._dirignore(fn):
             # we must check not only if the file is ignored, but if any part
             # of its path match an ignore pattern
             return 'i'
         return type_
 
     def updatefile(self, wfn, osstat):
         '''
         update the file entry of an existing file.
 
         osstat: (mode, size, time) tuple, as returned by os.lstat(wfn)
         '''
 
         self._updatestatus(wfn, self.filestatus(wfn, osstat))
 
     def deletefile(self, wfn, oldstatus):
         '''
         update the entry of a file which has been deleted.
 
         oldstatus: char in statuskeys, status of the file before deletion
         '''
         if oldstatus == 'r':
             newstatus = 'r'
         elif oldstatus in 'almn':
             newstatus = '!'
         else:
             newstatus = None
 
         self.statcache.pop(wfn, None)
         self._updatestatus(wfn, newstatus)
 
     def _updatestatus(self, wfn, newstatus):
         '''
         Update the stored status of a file.
 
         newstatus: - char in (statuskeys + 'ni'), new status to apply.
                    - or None, to stop tracking wfn
         '''
         root, fn = split(wfn)
         d = self.tree.dir(root)
 
         oldstatus = d.files.get(fn)
         # oldstatus can be either:
         # - None : fn is new
         # - a char in statuskeys: fn is a (tracked) file
 
         if self.ui.debugflag and oldstatus != newstatus:
             self.ui.note(_('status: %r %s -> %s\n') %
                              (wfn, oldstatus, newstatus))
 
         if oldstatus and oldstatus in self.statuskeys \
             and oldstatus != newstatus:
             del self.statustrees[oldstatus].dir(root).files[fn]
 
         if newstatus in (None, 'i'):
             d.files.pop(fn, None)
         elif oldstatus != newstatus:
             d.files[fn] = newstatus
             if newstatus != 'n':
                 self.statustrees[newstatus].dir(root).files[fn] = newstatus
 
     def check_deleted(self, key):
         # Files that had been deleted but were present in the dirstate
         # may have vanished from the dirstate; we must clean them up.
         nuke = []
         for wfn, ignore in self.statustrees[key].walk(key):
             if wfn not in self.dirstate:
                 nuke.append(wfn)
         for wfn in nuke:
             root, fn = split(wfn)
             del self.statustrees[key].dir(root).files[fn]
             del self.tree.dir(root).files[fn]
 
     def update_hgignore(self):
         # An update of the ignore file can potentially change the
         # states of all unknown and ignored files.
 
         # XXX If the user has other ignore files outside the repo, or
         # changes their list of ignore files at run time, we'll
         # potentially never see changes to them.  We could get the
         # client to report to us what ignore data they're using.
         # But it's easier to do nothing than to open that can of
         # worms.
 
         if '_ignore' in self.dirstate.__dict__:
             delattr(self.dirstate, '_ignore')
             self.ui.note(_('rescanning due to .hgignore change\n'))
             self.handle_timeout()
             self.scan()
 
     def getstat(self, wpath):
         try:
             return self.statcache[wpath]
         except KeyError:
             try:
                 return self.stat(wpath)
             except OSError, err:
                 if err.errno != errno.ENOENT:
                     raise
 
     def stat(self, wpath):
         try:
             st = os.lstat(join(self.wprefix, wpath))
             ret = st.st_mode, st.st_size, st.st_mtime
             self.statcache[wpath] = ret
             return ret
         except OSError:
             self.statcache.pop(wpath, None)
             raise
 
 class socketlistener(object):
     """
     Listens for client queries on unix socket inotify.sock
     """
     def __init__(self, ui, root, repowatcher, timeout):
         self.ui = ui
         self.repowatcher = repowatcher
         self.sock = socket.socket(socket.AF_UNIX)
         self.sockpath = join(root, '.hg/inotify.sock')
 
         self.realsockpath = self.sockpath
         if os.path.islink(self.sockpath):
             if os.path.exists(self.sockpath):
                 self.realsockpath = os.readlink(self.sockpath)
             else:
                 raise util.Abort('inotify-server: cannot start: '
                                 '.hg/inotify.sock is a broken symlink')
         try:
             self.sock.bind(self.realsockpath)
         except socket.error, err:
             if err.args[0] == errno.EADDRINUSE:
                 raise AlreadyStartedException(_('cannot start: socket is '
                                                 'already bound'))
             if err.args[0] == "AF_UNIX path too long":
                 tempdir = tempfile.mkdtemp(prefix="hg-inotify-")
                 self.realsockpath = os.path.join(tempdir, "inotify.sock")
                 try:
                     self.sock.bind(self.realsockpath)
                     os.symlink(self.realsockpath, self.sockpath)
                 except (OSError, socket.error), inst:
                     try:
                         os.unlink(self.realsockpath)
                     except:
                         pass
                     os.rmdir(tempdir)
                     if inst.errno == errno.EEXIST:
                         raise AlreadyStartedException(_('cannot start: tried '
                             'linking .hg/inotify.sock to a temporary socket but'
                             ' .hg/inotify.sock already exists'))
                     raise
             else:
                 raise
         self.sock.listen(5)
         self.fileno = self.sock.fileno
 
     def answer_stat_query(self, cs):
         names = cs.read().split('\0')
 
         states = names.pop()
 
         self.ui.note(_('answering query for %r\n') % states)
 
         visited = set()
         if not names:
             def genresult(states, tree):
                 for fn, state in tree.walk(states):
                     yield fn
         else:
             def genresult(states, tree):
                 for fn in names:
                     for f in tree.lookup(states, fn, visited):
                         yield f
 
         return ['\0'.join(r) for r in [
             genresult('l', self.repowatcher.statustrees['l']),
             genresult('m', self.repowatcher.statustrees['m']),
             genresult('a', self.repowatcher.statustrees['a']),
             genresult('r', self.repowatcher.statustrees['r']),
             genresult('!', self.repowatcher.statustrees['!']),
             '?' in states
                 and genresult('?', self.repowatcher.statustrees['?'])
                 or [],
             [],
             'c' in states and genresult('n', self.repowatcher.tree) or [],
             visited
             ]]
 
     def answer_dbug_query(self):
         return ['\0'.join(self.repowatcher.debug())]
 
     def accept_connection(self):
         sock, addr = self.sock.accept()
 
         cs = common.recvcs(sock)
         version = ord(cs.read(1))
 
         if version != common.version:
             self.ui.warn(_('received query from incompatible client '
                            'version %d\n') % version)
             try:
                 # try to send back our version to the client
                 # this way, the client too is informed of the mismatch
                 sock.sendall(chr(common.version))
             except:
                 pass
             return
 
         type = cs.read(4)
 
         if type == 'STAT':
             results = self.answer_stat_query(cs)
         elif type == 'DBUG':
             results = self.answer_dbug_query()
         else:
             self.ui.warn(_('unrecognized query type: %s\n') % type)
             return
 
         try:
             try:
                 v = chr(common.version)
 
                 sock.sendall(v + type + struct.pack(common.resphdrfmts[type],
                                             *map(len, results)))
                 sock.sendall(''.join(results))
             finally:
                 sock.shutdown(socket.SHUT_WR)
         except socket.error, err:
             if err.args[0] != errno.EPIPE:
                 raise
 
-if sys.platform == 'linux2':
+if sys.platform.startswith('linux'):
     import linuxserver as _server
 else:
     raise ImportError
 
 master = _server.master
 
 def start(ui, dirstate, root, opts):
     timeout = opts.get('idle_timeout')
     if timeout:
         timeout = float(timeout) * 60000
     else:
         timeout = None
 
     class service(object):
         def init(self):
             try:
                 self.master = master(ui, dirstate, root, timeout)
             except AlreadyStartedException, inst:
                 raise util.Abort("inotify-server: %s" % inst)
 
         def run(self):
             try:
                 try:
                     self.master.run()
                 except TimeoutException:
                     pass
             finally:
                 self.master.shutdown()
 
     if 'inserve' not in sys.argv:
         runargs = util.hgcmd() + ['inserve', '-R', root]
     else:
         runargs = util.hgcmd() + sys.argv[1:]
 
     pidfile = ui.config('inotify', 'pidfile')
     if opts['daemon'] and pidfile is not None and 'pid-file' not in runargs:
         runargs.append("--pid-file=%s" % pidfile)
 
     service = service()
     logfile = ui.config('inotify', 'log')
 
     appendpid = ui.configbool('inotify', 'appendpid', False)
 
     ui.debug('starting inotify server: %s\n' % ' '.join(runargs))
     cmdutil.service(opts, initfn=service.init, runfn=service.run,
                     logfile=logfile, runargs=runargs, appendpid=appendpid)

setup.py

@@ -1,441 +1,441 b''
 #
 # This is the mercurial setup script.
 #
 # 'python setup.py install', or
 # 'python setup.py --help' for more options
 
 import sys, platform
 if not hasattr(sys, 'version_info') or sys.version_info < (2, 4, 0, 'final'):
     raise SystemExit("Mercurial requires Python 2.4 or later.")
 
 if sys.version_info[0] >= 3:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s.encode('latin1')
 else:
     def b(s):
         '''A helper function to emulate 2.6+ bytes literals using string
         literals.'''
         return s
 
 # Solaris Python packaging brain damage
 try:
     import hashlib
     sha = hashlib.sha1()
 except:
     try:
         import sha
     except:
         raise SystemExit(
             "Couldn't import standard hashlib (incomplete Python install).")
 
 try:
     import zlib
 except:
     raise SystemExit(
         "Couldn't import standard zlib (incomplete Python install).")
 
 # The base IronPython distribution (as of 2.7.1) doesn't support bz2
 isironpython = False
 try:
     isironpython = platform.python_implementation().lower().find("ironpython") != -1
 except:
     pass
 
 if isironpython:
     print "warning: IronPython detected (no bz2 support)"
 else:
     try:
         import bz2
     except:
         raise SystemExit(
             "Couldn't import standard bz2 (incomplete Python install).")
 
 import os, subprocess, time
 import shutil
 import tempfile
 from distutils import log
 from distutils.core import setup, Command, Extension
 from distutils.dist import Distribution
 from distutils.command.build import build
 from distutils.command.build_ext import build_ext
 from distutils.command.build_py import build_py
 from distutils.command.install_scripts import install_scripts
 from distutils.spawn import spawn, find_executable
 from distutils.ccompiler import new_compiler
 from distutils.errors import CCompilerError, DistutilsExecError
 from distutils.sysconfig import get_python_inc
 from distutils.version import StrictVersion
 
 scripts = ['hg']
 if os.name == 'nt':
     scripts.append('contrib/win32/hg.bat')
 
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
     tmpdir = tempfile.mkdtemp(prefix='hg-install-')
     devnull = oldstderr = None
     try:
         try:
             fname = os.path.join(tmpdir, 'funcname.c')
             f = open(fname, 'w')
             f.write('int main(void) {\n')
             f.write('    %s();\n' % funcname)
             f.write('}\n')
             f.close()
             # Redirect stderr to /dev/null to hide any error messages
             # from the compiler.
             # This will have to be changed if we ever have to check
             # for a function on Windows.
             devnull = open('/dev/null', 'w')
             oldstderr = os.dup(sys.stderr.fileno())
             os.dup2(devnull.fileno(), sys.stderr.fileno())
             objects = cc.compile([fname], output_dir=tmpdir)
             cc.link_executable(objects, os.path.join(tmpdir, "a.out"))
         except:
             return False
         return True
     finally:
         if oldstderr is not None:
             os.dup2(oldstderr, sys.stderr.fileno())
         if devnull is not None:
             devnull.close()
         shutil.rmtree(tmpdir)
 
 # py2exe needs to be installed to work
 try:
     import py2exe
     py2exeloaded = True
 except ImportError:
     py2exeloaded = False
 
 def runcmd(cmd, env):
     p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                          stderr=subprocess.PIPE, env=env)
     out, err = p.communicate()
     return out, err
 
 def runhg(cmd, env):
     out, err = runcmd(cmd, env)
     # If root is executing setup.py, but the repository is owned by
     # another user (as in "sudo python setup.py install") we will get
     # trust warnings since the .hg/hgrc file is untrusted. That is
     # fine, we don't want to load it anyway.  Python may warn about
     # a missing __init__.py in mercurial/locale, we also ignore that.
     err = [e for e in err.splitlines()
            if not e.startswith(b('Not trusting file')) \
               and not e.startswith(b('warning: Not importing'))]
     if err:
         return ''
     return out
 
 version = ''
 
 if os.path.isdir('.hg'):
     # Execute hg out of this directory with a custom environment which
     # includes the pure Python modules in mercurial/pure. We also take
     # care to not use any hgrc files and do no localization.
     pypath = ['mercurial', os.path.join('mercurial', 'pure')]
     env = {'PYTHONPATH': os.pathsep.join(pypath),
            'HGRCPATH': '',
            'LANGUAGE': 'C'}
     if 'LD_LIBRARY_PATH' in os.environ:
         env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
     if 'SystemRoot' in os.environ:
         # Copy SystemRoot into the custom environment for Python 2.6
         # under Windows. Otherwise, the subprocess will fail with
         # error 0xc0150004. See: http://bugs.python.org/issue3440
         env['SystemRoot'] = os.environ['SystemRoot']
     cmd = [sys.executable, 'hg', 'id', '-i', '-t']
     l = runhg(cmd, env).split()
     while len(l) > 1 and l[-1][0].isalpha(): # remove non-numbered tags
         l.pop()
     if len(l) > 1: # tag found
         version = l[-1]
         if l[0].endswith('+'): # propagate the dirty status to the tag
             version += '+'
     elif len(l) == 1: # no tag found
         cmd = [sys.executable, 'hg', 'parents', '--template',
                '{latesttag}+{latesttagdistance}-']
         version = runhg(cmd, env) + l[0]
     if version.endswith('+'):
         version += time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
     kw = dict([[t.strip() for t in l.split(':', 1)]
                for l in open('.hg_archival.txt')])
     if 'tag' in kw:
         version =  kw['tag']
     elif 'latesttag' in kw:
         version = '%(latesttag)s+%(latesttagdistance)s-%(node).12s' % kw
     else:
         version = kw.get('node', '')[:12]
 
 if version:
     f = open("mercurial/__version__.py", "w")
     f.write('# this file is autogenerated by setup.py\n')
     f.write('version = "%s"\n' % version)
     f.close()
 
 
 try:
     from mercurial import __version__
     version = __version__.version
 except ImportError:
     version = 'unknown'
 
 class hgbuildmo(build):
 
     description = "build translations (.mo files)"
 
     def run(self):
         if not find_executable('msgfmt'):
             self.warn("could not find msgfmt executable, no translations "
                      "will be built")
             return
 
         podir = 'i18n'
         if not os.path.isdir(podir):
             self.warn("could not find %s/ directory" % podir)
             return
 
         join = os.path.join
         for po in os.listdir(podir):
             if not po.endswith('.po'):
                 continue
             pofile = join(podir, po)
             modir = join('locale', po[:-3], 'LC_MESSAGES')
             mofile = join(modir, 'hg.mo')
             mobuildfile = join('mercurial', mofile)
             cmd = ['msgfmt', '-v', '-o', mobuildfile, pofile]
             if sys.platform != 'sunos5':
                 # msgfmt on Solaris does not know about -c
                 cmd.append('-c')
             self.mkpath(join('mercurial', modir))
             self.make_file([pofile], mobuildfile, spawn, (cmd,))
 
 
 # Insert hgbuildmo first so that files in mercurial/locale/ are found
 # when build_py is run next.
 build.sub_commands.insert(0, ('build_mo', None))
 
 Distribution.pure = 0
 Distribution.global_options.append(('pure', None, "use pure (slow) Python "
                                     "code instead of C extensions"))
 
 class hgbuildext(build_ext):
 
     def build_extension(self, ext):
         try:
             build_ext.build_extension(self, ext)
         except CCompilerError:
             if not getattr(ext, 'optional', False):
                 raise
             log.warn("Failed to build optional extension '%s' (skipping)",
                      ext.name)
 
 class hgbuildpy(build_py):
 
     def finalize_options(self):
         build_py.finalize_options(self)
 
         if self.distribution.pure:
             if self.py_modules is None:
                 self.py_modules = []
             for ext in self.distribution.ext_modules:
                 if ext.name.startswith("mercurial."):
                     self.py_modules.append("mercurial.pure.%s" % ext.name[10:])
             self.distribution.ext_modules = []
         else:
             if not os.path.exists(os.path.join(get_python_inc(), 'Python.h')):
                 raise SystemExit("Python headers are required to build Mercurial")
 
     def find_modules(self):
         modules = build_py.find_modules(self)
         for module in modules:
             if module[0] == "mercurial.pure":
                 if module[1] != "__init__":
                     yield ("mercurial", module[1], module[2])
             else:
                 yield module
 
 class buildhgextindex(Command):
     description = 'generate prebuilt index of hgext (for frozen package)'
     user_options = []
     _indexfilename = 'hgext/__index__.py'
 
     def initialize_options(self):
         pass
 
     def finalize_options(self):
         pass
 
     def run(self):
         if os.path.exists(self._indexfilename):
             os.unlink(self._indexfilename)
 
         # here no extension enabled, disabled() lists up everything
         code = ('import pprint; from mercurial import extensions; '
                 'pprint.pprint(extensions.disabled())')
         out, err = runcmd([sys.executable, '-c', code], env)
         if err:
             raise DistutilsExecError(err)
 
         f = open(self._indexfilename, 'w')
         f.write('# this file is autogenerated by setup.py\n')
         f.write('docs = ')
         f.write(out)
         f.close()
 
 class hginstallscripts(install_scripts):
     '''
     This is a specialization of install_scripts that replaces the @LIBDIR@ with
     the configured directory for modules. If possible, the path is made relative
     to the directory for scripts.
     '''
 
     def initialize_options(self):
         install_scripts.initialize_options(self)
 
         self.install_lib = None
 
     def finalize_options(self):
         install_scripts.finalize_options(self)
         self.set_undefined_options('install',
                                    ('install_lib', 'install_lib'))
 
     def run(self):
         install_scripts.run(self)
 
         if (os.path.splitdrive(self.install_dir)[0] !=
             os.path.splitdrive(self.install_lib)[0]):
             # can't make relative paths from one drive to another, so use an
             # absolute path instead
             libdir = self.install_lib
         else:
             common = os.path.commonprefix((self.install_dir, self.install_lib))
             rest = self.install_dir[len(common):]
             uplevel = len([n for n in os.path.split(rest) if n])
 
             libdir =  uplevel * ('..' + os.sep) + self.install_lib[len(common):]
 
         for outfile in self.outfiles:
             fp = open(outfile, 'rb')
             data = fp.read()
             fp.close()
 
             # skip binary files
             if '\0' in data:
                 continue
 
             data = data.replace('@LIBDIR@', libdir.encode('string_escape'))
             fp = open(outfile, 'wb')
             fp.write(data)
             fp.close()
 
 cmdclass = {'build_mo': hgbuildmo,
             'build_ext': hgbuildext,
             'build_py': hgbuildpy,
             'build_hgextindex': buildhgextindex,
             'install_scripts': hginstallscripts}
 
 packages = ['mercurial', 'mercurial.hgweb',
             'mercurial.httpclient', 'mercurial.httpclient.tests',
             'hgext', 'hgext.convert', 'hgext.highlight', 'hgext.zeroconf']
 
 pymodules = []
 
 extmodules = [
     Extension('mercurial.base85', ['mercurial/base85.c']),
     Extension('mercurial.bdiff', ['mercurial/bdiff.c']),
     Extension('mercurial.diffhelpers', ['mercurial/diffhelpers.c']),
     Extension('mercurial.mpatch', ['mercurial/mpatch.c']),
     Extension('mercurial.parsers', ['mercurial/parsers.c']),
     ]
 
 osutil_ldflags = []
 
 if sys.platform == 'darwin':
     osutil_ldflags += ['-framework', 'ApplicationServices']
 
 # disable osutil.c under windows + python 2.4 (issue1364)
 if sys.platform == 'win32' and sys.version_info < (2, 5, 0, 'final'):
     pymodules.append('mercurial.pure.osutil')
 else:
     extmodules.append(Extension('mercurial.osutil', ['mercurial/osutil.c'],
                                 extra_link_args=osutil_ldflags))
 
-if sys.platform == 'linux2' and os.uname()[2] > '2.6':
+if sys.platform.startswith('linux') and os.uname()[2] > '2.6':
     # The inotify extension is only usable with Linux 2.6 kernels.
     # You also need a reasonably recent C library.
     # In any case, if it fails to build the error will be skipped ('optional').
     cc = new_compiler()
     if hasfunction(cc, 'inotify_add_watch'):
         inotify = Extension('hgext.inotify.linux._inotify',
                             ['hgext/inotify/linux/_inotify.c'],
                             ['mercurial'])
         inotify.optional = True
         extmodules.append(inotify)
         packages.extend(['hgext.inotify', 'hgext.inotify.linux'])
 
 packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
                              'help/*.txt']}
 
 def ordinarypath(p):
     return p and p[0] != '.' and p[-1] != '~'
 
 for root in ('templates',):
     for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
         curdir = curdir.split(os.sep, 1)[1]
         dirs[:] = filter(ordinarypath, dirs)
         for f in filter(ordinarypath, files):
             f = os.path.join(curdir, f)
             packagedata['mercurial'].append(f)
 
 datafiles = []
 setupversion = version
 extra = {}
 
 if py2exeloaded:
     extra['console'] = [
         {'script':'hg',
          'copyright':'Copyright (C) 2005-2010 Matt Mackall and others',
          'product_version':version}]
     # sub command of 'build' because 'py2exe' does not handle sub_commands
     build.sub_commands.insert(0, ('build_hgextindex', None))
 
 if os.name == 'nt':
     # Windows binary file versions for exe/dll files must have the
     # form W.X.Y.Z, where W,X,Y,Z are numbers in the range 0..65535
     setupversion = version.split('+', 1)[0]
 
 if sys.platform == 'darwin' and os.path.exists('/usr/bin/xcodebuild'):
     # XCode 4.0 dropped support for ppc architecture, which is hardcoded in
     # distutils.sysconfig
     version = runcmd(['/usr/bin/xcodebuild', '-version'], {})[0].splitlines()[0]
     # Also parse only first digit, because 3.2.1 can't be parsed nicely
     if (version.startswith('Xcode') and
         StrictVersion(version.split()[1]) >= StrictVersion('4.0')):
         os.environ['ARCHFLAGS'] = ''
 
 setup(name='mercurial',
       version=setupversion,
       author='Matt Mackall',
       author_email='[e-mail]',
       url='http://mercurial.selenic.com/',
       description='Scalable distributed SCM',
       license='GNU GPLv2+',
       scripts=scripts,
       packages=packages,
       py_modules=pymodules,
       ext_modules=extmodules,
       data_files=datafiles,
       package_data=packagedata,
       cmdclass=cmdclass,
       options=dict(py2exe=dict(packages=['hgext', 'email']),
                    bdist_mpkg=dict(zipdist=True,
                                    license='COPYING',
                                    readme='contrib/macosx/Readme.html',
                                    welcome='contrib/macosx/Welcome.html')),
       **extra)