连接时服务器引导（警告：LONG）

问题：我需要防止启动服务器的多个副本 。我通过使用文件锁定（fcntl.lockf（））来做到这一点。但是， 并非每次代码成功阻止服务器启动时间超过一次。以下是相关代码： ----客户代码链接开始---- 来自fooConsts导入* 导入套接字，fcntl，os，sys，time，logging FOO_CLIENT_DEBUG = 1 POLL_SERVER_INTVL = 0.5 如果FOO_CLIENT_DEBUG： myPID = os.getpid（） logger = logging.getLogger（''FOO Client''） hdlr = logging.FileHandler（TMP_PATH +''fooClient.log''） formatter = logging.Formatter（''％（asctime）s％（message）s''） hdlr.setFormatter（格式化程序） logger.addHandler（hdlr） logger.setLevel（logging.INFO） > def log（info）： logger.info（''％d：％s''％（myPID，info）） class FooClient： def __init __（self，startServer = True）： """连接到FooServer（如果存在），否则启动它并 连接到它" self.connected = True if self .connect（）：返回 elif不是startServer： 如果FOO_CLIENT_DEBUG：log（''连接失败1''） self.connected = False 返回 ＃尝试获取启动服务器的权限;如果我们不能， 别人 ＃必须这样做 - 尝试重新连接 试试： 如果FOO_CLIENT_DEBUG：log（''尝试正确开始 服务器''） serverStartLock = open（TMP_PATH +''serverStart.lock''，'' w''） fcntl.lockf（serverStartLock.fileno（），fcntl.LOCK_EX | fcntl.LOCK_NB） 除外： 如果FOO_CLIENT_DEBUG ：log（''别人正在做;等待 2''） 而1： time.sleep（POLL_SERVER_INTVL） 如果self.connect（）：返回 ＃安全启动服务器并连接到它 如果FOO_CLIENT_DEBUG：log（ ''启动服务器''） exitCode = os.system（''python -OO"％sfooServer.py"&''％FOO_PATH） if exitCode == 0： 如果FOO_CLIENT_DEBUG：log（''服务器正在启动;等待 3''） 而1： time.sleep（POLL_SERVER_INTVL） if self.connec t（）：返回 否则： 如果FOO_CLIENT_DEBUG：log（''sever bootstrapping failed''） self.connected = False 加注无法启动FOOServer def connect（self）： """尝试连接到FOOServer从PORT_MIN到 PORT_MAX""" 如果FOO_CLIENT_DEBUG：log（''连接尝试''） port = PORT_MIN 端口< = PORT_MAX： 试试： self.socket = socket.socket（socket.AF_INET， socket.SOCK_STREAM） self.socket.connect（（''''，port）） break 除了： self.socket.close（） port + = 1 如果端口> PORT_MAX： 如果FOO_CLIENT_DEBUG ：log（''连接失败2''） 返回False 如果FOO_CLIENT_DEBUG：log（''连接在端口成功 ％d ''％port） 返回True .... Foo客户端（） ----客户端代码链接结束---- 从日志中（出现问题时）我甚至看到* AFTER *服务器是 启动和接受的连接（几个连接来了又开始了 愉快），一个连接进来并点击连接失败1 日志行。这不应该发生在FooClient的初始值为 startServer .__ init __（）为True。在同样的事件中，FooServer启动了两次，但在日志中没有任何痕迹 的两个启动服务器行，但只有连接失败1，在日志的最后一行 。 我发现这是一个相当复杂的问题，请求帮助，但我是 真的在智慧结束。随意跳过详细说明， 只是给我一些一般提示和提示。非常感谢你！Here is the situation: I want my server started up upon connection.When the first connection comes in, the server is not running. Theclient realizes the fact, and then starts up the server and tries toconnect again. This of course all happens on the same machine (localconnection only).The connections can come in as fast as 30+/sec, so the server isthreaded (using SocketServer.ThreadingTCPServer). Further, the serverinitialization is threaded into two: one is to do the real, lengthysetup, the other is start lisenting ASAP.The problem: I need to prevent multiple copies of the server beingstarted. I did this by using file locking (fcntl.lockf()). However,not every time the code successfully prevented the server beingstarted up more than one time. Here is the relevant code:---- CLIENT CODE SNIPPET STARTS ----from fooConsts import *import socket,fcntl,os,sys,time,loggingFOO_CLIENT_DEBUG=1POLL_SERVER_INTVL=0.5if FOO_CLIENT_DEBUG:myPID=os.getpid()logger = logging.getLogger(''FOO Client'')hdlr = logging.FileHandler(TMP_PATH+''fooClient.log'')formatter = logging.Formatter(''%(asctime)s %(message)s'')hdlr.setFormatter(formatter)logger.addHandler(hdlr)logger.setLevel(logging.INFO)def log (info):logger.info(''%d: %s''%(myPID,info))class FooClient:def __init__ (self, startServer=True):"""Connects to FooServer if it exists, otherwise starts it andconnects to it"""self.connected=Trueif self.connect(): returnelif not startServer:if FOO_CLIENT_DEBUG: log(''connection failed 1'')self.connected=Falsereturn# try to obtain the right to start a server; if we can''t,someone else# must be doing it - try to reconnecttry:if FOO_CLIENT_DEBUG: log(''try to get right to startserver'')serverStartLock=open(TMP_PATH+''serverStart.lock'','' w'')fcntl.lockf(serverStartLock.fileno(),fcntl.LOCK_EX |fcntl.LOCK_NB)except:if FOO_CLIENT_DEBUG: log(''someone else is doing it; wait2'')while 1:time.sleep(POLL_SERVER_INTVL)if self.connect(): return# safe to start a server and connect to itif FOO_CLIENT_DEBUG: log(''start server'')exitCode=os.system(''python -OO "%sfooServer.py" &''%FOO_PATH)if exitCode==0:if FOO_CLIENT_DEBUG: log(''server is being started; wait3'')while 1:time.sleep(POLL_SERVER_INTVL)if self.connect(): returnelse:if FOO_CLIENT_DEBUG: log(''sever bootstrapping failed'')self.connected=Falseraise "Cannot start FOOServer"def connect (self):"""Attempts to connect to FOOServer from PORT_MIN toPORT_MAX"""if FOO_CLIENT_DEBUG: log(''connection attempt'')port=PORT_MINwhile port<=PORT_MAX:try:self.socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)self.socket.connect(('''',port))breakexcept:self.socket.close()port+=1if port>PORT_MAX:if FOO_CLIENT_DEBUG: log(''connection failed 2'')return Falseif FOO_CLIENT_DEBUG: log(''connection succeeded at port%d''%port)return True....FooClient()---- CLIENT CODE SNIPPET ENDS ----From the log (when problem occurred) I see even *AFTER* the server wasstarted and accepted connections (several connections came and wenthappily), a connection would come in and hit the "connection failed 1"log line. This shouldn''t have happened as the default value ofstartServer for FooClient.__init__() is True. In the very sameincident, FooServer was started twice, but in the log there''s no traceof two "start server" lines, but only the "connection failed 1" linein the very end of the log.I realize this is a rather complex question to ask for help, but I''mreally at wits end. Feel free to skip the detailed description, andjust throw me some general tips and hints. Thank you VERY MUCH!推荐答案 fo ************* @ yahoo.com.tw （Fortepianissimo）写道：fo*************@yahoo.com.tw (Fortepianissimo) writes:这是情况：我希望我的服务器在连接时启动。当第一个连接进来时，服务器没有运行。 客户端意识到这一事实，然后启动服务器并尝试再次连接。这当然都发生在同一台机器上（仅限本地连接）。 连接速度可以达到30 + /秒，因此服务器是有线程的（使用SocketServer.ThreadingTCPServer）。此外，服务器的初始化分为两个：一个是做真实的，冗长的设置，另一个是尽快开始lisenting。 问题：我需要预防启动了多个服务器副本。我通过使用文件锁定（fcntl.lockf（））来做到这一点。但是，并非每次代码都成功阻止服务器启动多次。以下是相关代码： 当使用fcntl.lockf时，同一 进程中的不同FooClient实例将能够锁定文件并启动另一台服务器。您可以使用fcntl.flock来防止或者使用一些全局标记。 还要确保通过保留文件来保持文件打开 （即self.serverStartLock = open（...））。 出于调试目的，删除'if self.connect（）：return''和 我想你会看到更多服务器正在启动。 ----客户代码链接开始---- 来自fooConsts import * import socket，fcntl，os，sys，time，logging POLL_SERVER_INTVL = 0.5 如果FOO_CLIENT_DEBUG： myPID = os.getpid（） logger = logging.getLogger（''FOO Client''） hdlr = logging.FileHandler（TMP_PATH +''fooClient.log''） formatter = logging.Formatter（''％（asctime）s％（message）s''） hdlr.setFormatter（formatter） logger.addHandler（hdlr） logger.setLevel（logging.INFO） ） def log（info）： logge r.info（''％d：％s''％（myPID，info）） class FooClient： def __init __（self，startServer = True）：" ;""连接到FooServer（如果存在），否则启动它并连接到它" self.connected = True 如果self.connect（）：return 如果FOO_CLIENT_DEBUG：log（''连接失败1''） self.connected = False 返回 ＃尝试获取启动服务器的权利;如果我们不能，其他人＃必须这样做 - 尝试重新连接尝试：如果FOO_CLIENT_DEBUG：log（''尝试正确开始 server''） serverStartLock = open（TMP_PATH +''serverStart.lock''，''w''）fcntl.lockf（serverStartLock.fileno（），fcntl.LOCK_EX | fcntl。 LOCK_NB）除了：如果FOO_CLIENT_DEBUG：登录（''别人正在做;等待 2''） 1： time.sleep（POLL_SERVER_INTVL ）如果self.connect（）：返回 ＃safe启动服务器并连接到它如果FOO_CLIENT_DEBUG：log（''start server''） exitCode = os.system（''python -OO"％sfooServer.py"&''％FOO_PATH）如果exitCode == 0：如果FOO_CLIENT_DEBUG：log（''服务器正在开始;等待 3''） whil e 1： time.sleep（POLL_SERVER_INTVL）如果self.connect（）：返回否则：如果FOO_CLIENT_DEBUG：log（''sever bootstrapping failed''） self.connected = False raise"无法启动FOOServer" def connect（self）："""尝试从PORT_MIN连接到FOOServer PORT_MAX""" 如果FOO_CLIENT_DEBUG：log（''连接尝试''） port = PORT_MIN 端口< = PORT_MAX：尝试： self.socket = socket.socket（socket.AF_INET， socket.SOCK_STREAM） self.socket.connect（（''''，port）） break 除了： self.socket.close（）端口+ = 1 如果端口> PORT_MAX：如果FOO_CLIENT_DEBUG：log（''connection fa iled 2''）返回False 如果FOO_CLIENT_DEBUG：log（''连接成功在端口％d''％port）返回True ... FooClient（） ----客户端代码链接结束---- 从日志中（出现问题时）我甚至看到* AFTER *服务器启动并接受了连接（几个连接来了又快乐地），连接将进入并点击连接失败1日志行。这不应该是因为FooClient的启动服务器的默认值.__ init __（）为True。在同样的 嗯，可能有太多的连接尝试正在等待...... 事件，FooServer启动了两次，但是在日志中有''没有任何痕迹两个启动服务器行，但只有连接失败1，在日志的最后。 我意识到这是一个相当复杂的问题，请求帮助，但我真的很有智慧。请随意跳过详细说明，然后给我一些一般的提示和提示。非常感谢！ Here is the situation: I want my server started up upon connection. When the first connection comes in, the server is not running. The client realizes the fact, and then starts up the server and tries to connect again. This of course all happens on the same machine (local connection only). The connections can come in as fast as 30+/sec, so the server is threaded (using SocketServer.ThreadingTCPServer). Further, the server initialization is threaded into two: one is to do the real, lengthy setup, the other is start lisenting ASAP. The problem: I need to prevent multiple copies of the server being started. I did this by using file locking (fcntl.lockf()). However, not every time the code successfully prevented the server being started up more than one time. Here is the relevant code:When using fcntl.lockf different FooClient instances in the sameprocess will be able lock the file and start another server. You couldeither use fcntl.flock to prevent that or use some global flag.Also be sure to keep the file open by keeping a reference to it(i.e. self.serverStartLock=open(...)).For debugging purposes, remove that ''if self.connect(): return'' andI think you''ll see much more servers being started. ---- CLIENT CODE SNIPPET STARTS ---- from fooConsts import * import socket,fcntl,os,sys,time,logging FOO_CLIENT_DEBUG=1 POLL_SERVER_INTVL=0.5 if FOO_CLIENT_DEBUG: myPID=os.getpid() logger = logging.getLogger(''FOO Client'') hdlr = logging.FileHandler(TMP_PATH+''fooClient.log'') formatter = logging.Formatter(''%(asctime)s %(message)s'') hdlr.setFormatter(formatter) logger.addHandler(hdlr) logger.setLevel(logging.INFO) def log (info): logger.info(''%d: %s''%(myPID,info)) class FooClient: def __init__ (self, startServer=True): """Connects to FooServer if it exists, otherwise starts it and connects to it""" self.connected=True if self.connect(): return elif not startServer: if FOO_CLIENT_DEBUG: log(''connection failed 1'') self.connected=False return # try to obtain the right to start a server; if we can''t, someone else # must be doing it - try to reconnect try: if FOO_CLIENT_DEBUG: log(''try to get right to start server'') serverStartLock=open(TMP_PATH+''serverStart.lock'','' w'') fcntl.lockf(serverStartLock.fileno(),fcntl.LOCK_EX |fcntl.LOCK_NB) except: if FOO_CLIENT_DEBUG: log(''someone else is doing it; wait 2'') while 1: time.sleep(POLL_SERVER_INTVL) if self.connect(): return # safe to start a server and connect to it if FOO_CLIENT_DEBUG: log(''start server'') exitCode=os.system(''python -OO "%sfooServer.py" &''%FOO_PATH) if exitCode==0: if FOO_CLIENT_DEBUG: log(''server is being started; wait 3'') while 1: time.sleep(POLL_SERVER_INTVL) if self.connect(): return else: if FOO_CLIENT_DEBUG: log(''sever bootstrapping failed'') self.connected=False raise "Cannot start FOOServer" def connect (self): """Attempts to connect to FOOServer from PORT_MIN to PORT_MAX""" if FOO_CLIENT_DEBUG: log(''connection attempt'') port=PORT_MIN while port<=PORT_MAX: try: self.socket=socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.connect(('''',port)) break except: self.socket.close() port+=1 if port>PORT_MAX: if FOO_CLIENT_DEBUG: log(''connection failed 2'') return False if FOO_CLIENT_DEBUG: log(''connection succeeded at port %d''%port) return True ... FooClient() ---- CLIENT CODE SNIPPET ENDS ---- From the log (when problem occurred) I see even *AFTER* the server was started and accepted connections (several connections came and went happily), a connection would come in and hit the "connection failed 1" log line. This shouldn''t have happened as the default value of startServer for FooClient.__init__() is True. In the very sameWell, maybe too many connection attempts are pending... incident, FooServer was started twice, but in the log there''s no trace of two "start server" lines, but only the "connection failed 1" line in the very end of the log. I realize this is a rather complex question to ask for help, but I''m really at wits end. Feel free to skip the detailed description, and just throw me some general tips and hints. Thank you VERY MUCH! - 脑机器人技术ag boppstrasse 64。 55118 mainz。德国 fon [phone]。传真[phone] http://brainbot.com/ mailto： ra**@brainbot.com--brainbot technologies agboppstrasse 64 . 55118 mainz . germanyfon [phone] . fax [phone] http://brainbot.com/ mailto:ra**@brainbot.com 2004-02-10 13:46:37 -0500， ra ** @ brainbot.com 说：On 2004-02-10 13:46:37 -0500, ra**@brainbot.com said: fo ************* @ yahoo.com.tw （Fortepianissimo）写道： fo*************@yahoo.com.tw (Fortepianissimo) writes:问题：我需要预防启动了多个服务器副本。我通过使用文件锁定（fcntl.lockf（））来做到这一点。但是，并非每次代码都成功阻止服务器启动多次。以下是相关代码：当使用fcntl.lockf时，在同一个进程中的不同FooClient实例将能够锁定文件并启动另一台服务器。您可以使用fcntl.flock来阻止它或者使用一些全局标志。 The problem: I need to prevent multiple copies of the server being started. I did this by using file locking (fcntl.lockf()). However, not every time the code successfully prevented the server being started up more than one time. Here is the relevant code: When using fcntl.lockf different FooClient instances in the same process will be able lock the file and start another server. You could either use fcntl.flock to prevent that or use some global flag. 嗯...我不知道有什么flock（）和lockf（）之间的区别， 我也没有从文档中获得太多信息。你能解释一下为什么lockf（）不会锁定文件的原因吗？ 实际上我写了一个小脚本来测试lockf（）是否做了什么它b / b 声称： ---代码开始--- ＃！/ usr / bin / env python import os，fcntl，sys print" *即将打开flock.txt f = open（''flock.txt''，''w''） print" *打开文件 fcntl.lockf（f.fileno（）， fcntl.LOCK_EX | fcntl.LOCK_NB） 打印" *获得锁定，在下面输入你的行：" l = sys.stdin.readline（） f.truncate（） f.write（l） f.flush（） sys.stdin.readline （） f.close（） ---代码结束--- 似乎它锁定文件？ （Mac OS X 10.3.2）。 还要确保通过保持文件的引用来保持文件打开（即self.serverStartLock = open（...））。出于调试目的，删除如果self.connect（）：return''和我认为你会看到更多服务器正在启动。Hm... I didn''t know there''s a difference between flock() and lockf(),and I didn''t get much info from the document either. Could you explaina bit on why lockf() would not lock the file?Actually I wrote a tiny script just to test if lockf() does what itclaims to do:--- CODE STARTS ---#!/usr/bin/env pythonimport os,fcntl,sysprint "* about to open flock.txt"f=open(''flock.txt'',''w'')print "* opened the file"fcntl.lockf(f.fileno(),fcntl.LOCK_EX|fcntl.LOCK_NB )print "* obtained the lock, enter your line below:"l=sys.stdin.readline()f.truncate()f.write(l)f.flush()sys.stdin.readline()f.close()--- CODE ENDS ---It seems it does lock the file? (Mac OS X 10.3.2). Also be sure to keep the file open by keeping a reference to it (i.e. self.serverStartLock=open(...)). For debugging purposes, remove that ''if self.connect(): return'' and I think you''ll see much more servers being started. --- CODE SNIPPET STARTS --- class FooClient： def __init __（self，startServer = True）： """连接到FooServer，如果它存在，否则启动它并 连接到它"" self.connected = True if self.connect（）：return elif not startServer： if FOO_CLIENT_DEBUG：log（''connection failed 1''） self.connected = False 返回 ... --- CODE SNIPPET ENDS --- 那么在这种情况下，每个连接都会尝试启动服务器。好的 指向保持对锁文件的引用 - 我会添加它 并看看会发生什么。--- CODE SNIPPET STARTS ---class FooClient:def __init__ (self, startServer=True):"""Connects to FooServer if it exists, otherwise starts it andconnects to it"""self.connected=Trueif self.connect(): returnelif not startServer:if FOO_CLIENT_DEBUG: log(''connection failed 1'')self.connected=Falsereturn...--- CODE SNIPPET ENDS ---Well in that case every connection will try to start a server. Goodpoint on keeping a reference to the lock file though - I''ll add to itand see what happens. 从日志中（当出现问题时）我甚至看到* AFTER *服务器启动并接受了连接（几个连接来了又走了愉快地），连接将进入并点击连接失败1日志行。这不应该是因为FooClient的启动服务器的默认值.__ init __（）为True。在同一个 From the log (when problem occurred) I see even *AFTER* the server was started and accepted connections (several connections came and went happily), a connection would come in and hit the "connection failed 1" log line. This shouldn''t have happened as the default value of startServer for FooClient.__init__() is True. In the very same 那么，也许有太多的连接尝试正在等待... Well, maybe too many connection attempts are pending... 我没看到为什么这个应该影响 参数的默认值...如果startServer为True（默认值），该日志行应该从未达到过。 谢谢！ BenI failed to see why this should affect the default value of theargument... if startServer is True (default), that log line should havenever been reached.Thanks!Ben Benjamin Han< th ** @ is。 for.spambot>写道：Benjamin Han <th**@is.for.spambot> writes: 2004-02-10 13:46:37 -0500， ra ** @ brainbot。 com 说： On 2004-02-10 13:46:37 -0500, ra**@brainbot.com said: fo * ************@yahoo.com.tw （Fortepianissimo）写道： fo*************@yahoo.com.tw (Fortepianissimo) writes:问题：我需要阻止服务器的多个副本开始了。我通过使用文件锁定（fcntl.lockf（））来做到这一点。但是，并非每次代码都成功阻止服务器启动多次。以下是相关代码：当使用fcntl.lockf时，不同的FooClient实例在同一个进程中将能够锁定文件并启动另一台服务器。你可以使用fcntl.flock来阻止它或使用一些全局标志。 The problem: I need to prevent multiple copies of the server being started. I did this by using file locking (fcntl.lockf()). However, not every time the code successfully prevented the server being started up more than one time. Here is the relevant code: When using fcntl.lockf different FooClient instances in the same process will be able lock the file and start another server. You could either use fcntl.flock to prevent that or use some global flag. 嗯...我不知道flock之间有什么区别（ ）和lockf（），我也没有从文档中获得太多信息。你能解释一下为什么lockf（）不会锁定文件吗？ Hm... I didn''t know there''s a difference between flock() and lockf(), and I didn''t get much info from the document either. Could you explain a bit on why lockf() would not lock the file? 好​​吧，它可能会在同一个文件中多次锁定文件/> 流程。这就是问题所在： ---- 导入fcntl def getlockfile（）： 返回打开（''serverStart.lock''，''w''） def getlock（f）： 尝试： 锁定（f.fileno（），fcntl.LOCK_EX | fcntl.LOCK_NB） 除外： 返回False 返回True def doit（）： f1 = getlockfile（） f2 = getlockfile（） print getlock（f1），getlock（f2） lock = fcntl.lockf doit（） lock = fcntl.flock doit（） --- 输出为： 真实 真假 实际上我写了一个小小的脚本只是为了测试lockf（）是否做了它所声称的内容执行： ---代码开始--- ＃！/ usr / bin / env python 导入os，fcntl，sys print" *即将打开flock.txt" f = open（''flock.txt''，''w''） print" * op ened文件 fcntl.lockf（f.fileno（），fcntl.LOCK_EX | fcntl.LOCK_NB）打印*获得锁定，在下面输入你的行： l = sys.stdin.readline（） f.truncate（） f.write（l） f.flush（） sys.stdin.readline（） f.close（） ---代码结束--- 它似乎确实锁定了文件？ （Mac OS X 10.3.2）。Well, it might lock the file multiple times in the sameprocess. That''s the problem:----import fcntldef getlockfile():return open(''serverStart.lock'', ''w'')def getlock(f):try:lock(f.fileno(), fcntl.LOCK_EX|fcntl.LOCK_NB)except:return Falsereturn Truedef doit():f1 = getlockfile()f2 = getlockfile()print getlock(f1), getlock(f2)lock = fcntl.lockfdoit()lock = fcntl.flockdoit()---Output is:True TrueTrue False Actually I wrote a tiny script just to test if lockf() does what it claims to do: --- CODE STARTS --- #!/usr/bin/env python import os,fcntl,sys print "* about to open flock.txt" f=open(''flock.txt'',''w'') print "* opened the file" fcntl.lockf(f.fileno(),fcntl.LOCK_EX|fcntl.LOCK_NB ) print "* obtained the lock, enter your line below:" l=sys.stdin.readline() f.truncate() f.write(l) f.flush() sys.stdin.readline() f.close() --- CODE ENDS --- It seems it does lock the file? (Mac OS X 10.3.2).还要确保通过保持文件的引用来保持文件打开（即self.serverStartLock = open（... ））。出于调试目的，删除'if self.connect（）：return''和我认为你会看到更多服务器正在启动。 ---代码链接开始--- 类FooClient： def __init __（self，startServer = True）："""连接到FooServer（如果存在），否则启动它并连接 to it" self.connected = True 如果self.connect（）：返回 elif不是startServer：如果FOO_CLIENT_DEBUG：log（''连接失败1 ''） self.connected = False 返回 .. --- CODE SNIPPET ENDS --- 那么在每种情况下连接将尝试启动服务器。好的指向保持对锁文件的引用 - 我会添加它并看看会发生什么。 Also be sure to keep the file open by keeping a reference to it (i.e. self.serverStartLock=open(...)). For debugging purposes, remove that ''if self.connect(): return'' and I think you''ll see much more servers being started. --- CODE SNIPPET STARTS --- class FooClient: def __init__ (self, startServer=True): """Connects to FooServer if it exists, otherwise starts it and connects to it""" self.connected=True if self.connect(): return elif not startServer: if FOO_CLIENT_DEBUG: log(''connection failed 1'') self.connected=False return .. --- CODE SNIPPET ENDS --- Well in that case every connection will try to start a server. Good point on keeping a reference to the lock file though - I''ll add to it and see what happens.从日志中（当问题发生时）我甚至看到* AFTER *服务器启动并接受了连接（几个连接来了又快乐地），一个连接会进来，点击连接失败1日志行。这不应该是因为FooClient的启动服务器的默认值.__ init __（）为True。在同一个 From the log (when problem occurred) I see even *AFTER* the server was started and accepted connections (several connections came and went happily), a connection would come in and hit the "connection failed 1" log line. This shouldn''t have happened as the default value of startServer for FooClient.__init__() is True. In the very same 好吧，也许有太多连接尝试待决...... Well, maybe too many connection attempts are pending... 我没看到为什么这会影响参数...如果startServer为True（默认值），则该日志行应该从未到过。 I failed to see why this should affect the default value of the argument... if startServer is True (default), that log line should have never been reached. 嗯，那么我想你将错误的论点传递给了 FooClient .__ init__。我只是想说，即使服务器在那个端口上听取了，这种连接尝试也可能会失败。 谢谢！ 本Well, then I suppose you''re passing an false argument toFooClient.__init__. I just wanted to say, that even if the server islistening on that port, that connection attempts may fail. Thanks! Ben - 脑机器人技术ag boppstrasse 64。 55118 mainz。德国 fon [phone]。传真[phone] http://brainbot.com/ mailto： ra**@brainbot.com--brainbot technologies agboppstrasse 64 . 55118 mainz . germanyfon [phone] . fax [phone] http://brainbot.com/ mailto:ra**@brainbot.com 这篇关于连接时服务器引导（警告：LONG）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！ 上岸，阿里云！