Python platform.isWindows函数代码示例

    def __init__(self, server_key, config):
        self._subtype = config["subtype"].lower()
        self._server_key = server_key
        self._config = config

        #setup logging
        self.logdata = []
        self.lastlogtime = time.time()
        self.loggingport = 0

        self._dediids = {'tf': 232250, 'dod': 232290, 'css': 232330}

        #setup rcon
        self.rcon = SourceRcon.SourceRcon(self._config["ip"], int(self._config["port"]), self._config["rcon_password"])

        if self._subtype == "":
            self._subtype = None

        log.debug("server_key:", server_key, "self._subtype:", self._subtype)
        if self._subtype is None:
            if platform.isWindows():
                self._server = SRCDSServerProcessWin32(server_key, config)
            else:
                self._server = SRCDSServerBase(server_key, config)

        elif self._subtype == "svc":
            if platform.isWindows():
                self._server = SRCDSServerServiceWin32(server_key, config)
            else:
                self._server = SRCDSServerBase(server_key, config)

        elif self._subtype == "gs":
            self._server = SRCDSServerGS(server_key, config)

 def setUp(self):
     """
     Clear the SIGCHLD handler, if there is one, to ensure an environment
     like the one which exists prior to a call to L{reactor.run}.
     """
     if not platform.isWindows():
         self.originalHandler = signal.signal(signal.SIGCHLD, signal.SIG_DFL)

    def child(self, path):
        """
        Create and return a new L{FilePath} representing a path contained by
        C{self}.

        @param path: The base name of the new L{FilePath}.  If this contains
            directory separators or parent references it will be rejected.
        @type path: L{bytes}

        @raise InsecurePath: If the result of combining this path with C{path}
            would result in a path which is not a direct child of this path.

        @return: The child path.
        @rtype: L{FilePath}
        """
        if platform.isWindows() and path.count(b":"):
            # Catch paths like C:blah that don't have a slash
            raise InsecurePath("%r contains a colon." % (path,))
        norm = normpath(path)
        if self.sep in norm:
            raise InsecurePath("%r contains one or more directory separators" % (path,))
        newpath = abspath(joinpath(self.path, norm))
        if not newpath.startswith(self.path):
            raise InsecurePath("%r is not a child of %s" % (newpath, self.path))
        return self.clonePath(newpath)

 def checkProtocol(stdioOb):
     from twisted.python.runtime import platform
     if platform.isWindows():
         self.assertIsInstance(stdioOb.proto, basic.LineReceiver)
     else:
         self.assertIsInstance(stdioOb.protocol, basic.LineReceiver)
     stdioOb.loseConnection()

 def _sendSignal(self, signal):
     if platform.isWindows():
         raise usage.UsageError("You can't send signals on Windows (XXX TODO)")
     dbdir = self.parent.getStoreDirectory()
     serverpid = int(file(os.path.join(dbdir, 'run', 'axiomatic.pid')).read())
     os.kill(serverpid, signal)
     return serverpid

    def _parseWorker(reactor, name, executable=None):
        """
        Constructs a process endpoint for a spreadflow worker process.

        Args:
            reactor: The reactor passed to ``clientFromString``.
            name (str): The partition name this worker should operate on.
            executable (Optional[str]). Path to the spreadflow-twistd command.

        Returns:
            A client process endpoint
        """
        if executable is None:
            executable = sys.argv[0]

        logger = 'spreadflow_core.scripts.spreadflow_twistd.StderrLogger'
        args = [executable, '-n', '--logger', logger, '--multiprocess',
                '--partition', name]

        if not platform.isWindows():
            args.extend(['--pidfile', ''])

        fds = {0: "w", 1: "r", 2: 2}

        return ProcessEndpoint(reactor, executable, args=args,
                               env=os.environ.copy(), childFDs=fds)

    def getArguments(self, store, args):
        run = store.dbdir.child("run")
        logs = run.child("logs")
        handleLogfile = True
        handlePidfile = True

        for arg in args:
            if arg.startswith("--logfile=") or arg in (
                "-l", "--logfile", "-n", "--nodaemon"
            ):
                handleLogfile = False
            elif arg.startswith("--pidfile=") or arg == "--pidfile":
                handlePidfile = False

        if handleLogfile:
            if not logs.exists():
                logs.makedirs()
            args.extend(["--logfile", logs.child("axiomatic.log").path])

        if not platform.isWindows() and handlePidfile:
            args.extend(["--pidfile", run.child("axiomatic.pid").path])
        args.extend(["axiomatic-start", "--dbdir", store.dbdir.path])
        if store.journalMode is not None:
            args.extend(['--journal-mode', store.journalMode.encode('ascii')])
        return args

    def test_disconnectWhileProducing(self):
        """
        If C{loseConnection} is called while a producer is registered with the
        transport, the connection is closed after the producer is unregistered.
        """
        reactor = self.buildReactor()

        # For some reason, pyobject/pygtk will not deliver the close
        # notification that should happen after the unregisterProducer call in
        # this test.  The selectable is in the write notification set, but no
        # notification ever arrives.  Probably for the same reason #5233 led
        # win32eventreactor to be broken.
        skippedReactors = ["Glib2Reactor", "Gtk2Reactor"]
        reactorClassName = reactor.__class__.__name__
        if reactorClassName in skippedReactors and platform.isWindows():
            raise SkipTest("A pygobject/pygtk bug disables this functionality " "on Windows.")

        class Producer:
            def resumeProducing(self):
                log.msg("Producer.resumeProducing")

        self.listen(reactor, ServerFactory.forProtocol(Protocol))

        finished = Deferred()
        finished.addErrback(log.err)
        finished.addCallback(lambda ign: reactor.stop())

        class ClientProtocol(Protocol):
            """
            Protocol to connect, register a producer, try to lose the
            connection, unregister the producer, and wait for the connection to
            actually be lost.
            """

            def connectionMade(self):
                log.msg("ClientProtocol.connectionMade")
                self.transport.registerProducer(Producer(), False)
                self.transport.loseConnection()
                # Let the reactor tick over, in case synchronously calling
                # loseConnection and then unregisterProducer is the same as
                # synchronously calling unregisterProducer and then
                # loseConnection (as it is in several reactors).
                reactor.callLater(0, reactor.callLater, 0, self.unregister)

            def unregister(self):
                log.msg("ClientProtocol unregister")
                self.transport.unregisterProducer()
                # This should all be pretty quick.  Fail the test
                # if we don't get a connectionLost event really
                # soon.
                reactor.callLater(1.0, finished.errback, Failure(Exception("Connection was not lost")))

            def connectionLost(self, reason):
                log.msg("ClientProtocol.connectionLost")
                finished.callback(None)

        clientFactory = ClientFactory()
        clientFactory.protocol = ClientProtocol
        self.connect(reactor, clientFactory)
        self.runReactor(reactor)

    def test_parseOptionsHelp(self):
        """
        L{Start.parseOptions} writes usage information to stdout if C{"--help"}
        is in the argument list it is passed and L{twistd.run} is not called.
        """
        start = axiomatic.Start()
        start.run = None
        original = sys.stdout
        sys.stdout = stdout = StringIO.StringIO()
        try:
            self.assertRaises(SystemExit, start.parseOptions, ["--help"])
        finally:
            sys.stdout = original

        # Some random options that should be present.  This is a bad test
        # because we don't control what C{opt_help} actually does and we don't
        # even really care as long as it's the same as what I{twistd --help}
        # does.  We could try running them both and comparing, but then we'd
        # still want to do some sanity check against one of them in case we end
        # up getting the twistd version incorrectly somehow... -exarkun
        self.assertIn("--reactor", stdout.getvalue())
        if not platform.isWindows():
            # This isn't an option on Windows, so it shouldn't be there.
            self.assertIn("--uid", stdout.getvalue())

        # Also, we don't want to see twistd plugins here.
        self.assertNotIn("axiomatic-start", stdout.getvalue())

 def stopped(ignored):
     # Should still be possible to recv on portSocket.  If
     # it was shutdown, the exception would be EINVAL instead.
     exc = self.assertRaises(socket.error, portSocket.recvfrom, 1)
     if platform.isWindows() and _PY3:
         self.assertEqual(exc.args[0], errno.WSAEWOULDBLOCK)
     else:
         self.assertEqual(exc.args[0], errno.EAGAIN)

 def setContent(self, content, ext=".new"):
     sib = self.siblingExtension(ext)
     f = sib.open("w")
     f.write(content)
     f.close()
     if platform.isWindows() and exists(self.path):
         os.unlink(self.path)
     os.rename(sib.path, self.path)

    def setContent(self, content, ext='.new'):
        """
        Replace the file at this path with a new file that contains the given
        bytes, trying to avoid data-loss in the meanwhile.

        On UNIX-like platforms, this method does its best to ensure that by the
        time this method returns, either the old contents I{or} the new contents
        of the file will be present at this path for subsequent readers
        regardless of premature device removal, program crash, or power loss,
        making the following assumptions:

            - your filesystem is journaled (i.e. your filesystem will not
              I{itself} lose data due to power loss)

            - your filesystem's C{rename()} is atomic

            - your filesystem will not discard new data while preserving new
              metadata (see U{http://mjg59.livejournal.com/108257.html} for more
              detail)

        On most versions of Windows there is no atomic C{rename()} (see
        U{http://bit.ly/win32-overwrite} for more information), so this method
        is slightly less helpful.  There is a small window where the file at
        this path may be deleted before the new file is moved to replace it:
        however, the new file will be fully written and flushed beforehand so in
        the unlikely event that there is a crash at that point, it should be
        possible for the user to manually recover the new version of their data.
        In the future, Twisted will support atomic file moves on those versions
        of Windows which I{do} support them: see U{Twisted ticket
        3004<http://twistedmatrix.com/trac/ticket/3004>}.

        This method should be safe for use by multiple concurrent processes, but
        note that it is not easy to predict which process's contents will
        ultimately end up on disk if they invoke this method at close to the
        same time.

        @param content: The desired contents of the file at this path.

        @type content: L{str}

        @param ext: An extension to append to the temporary filename used to
            store the bytes while they are being written.  This can be used to
            make sure that temporary files can be identified by their suffix,
            for cleanup in case of crashes.

        @type ext: C{str}
        """
        sib = self.temporarySibling(ext)
        f = sib.open('w')
        try:
            f.write(content)
        finally:
            f.close()
        if platform.isWindows() and exists(self.path):
            os.unlink(self.path)
        os.rename(sib.path, self.path)

 def test_getProgramsMenuPath(self):
     """
     L{getProgramsMenuPath} guesses the programs menu path on non-win32
     platforms. On non-win32 it will try to figure out the path by
     examining the registry.
     """
     if not platform.isWindows():
         self.assertEqual(win32.getProgramsMenuPath(),
             "C:\\Windows\\Start Menu\\Programs")
     else:
         self.assertIsInstance(win32.getProgramsMenuPath(), str)

 def getArguments(self, store, args):
     run = store.dbdir.child("run")
     logs = run.child("logs")
     if "--logfile" not in args and "-l" not in args and "--nodaemon" not in args and "-n" not in args:
         if not logs.exists():
             logs.makedirs()
         args.extend(["--logfile", logs.child("axiomatic.log").path])
     if not platform.isWindows() and "--pidfile" not in args:
         args.extend(["--pidfile", run.child("axiomatic.pid").path])
     args.extend(["axiomatic-start", "--dbdir", store.dbdir.path])
     return args

    def test_gid(self):
        """
        Should be the current user by default
        """
        if platform.isWindows():
            raise SkipTest('Windows-only test')

        r = _spawnDefaultArgs('exec')
        self.assertEqual(r['gid'], os.getegid())
        
        r = _spawnDefaultArgs('exec', gid='foo')
        self.assertEqual(r['gid'], 'foo')