def ping(server_port, timeout=1, error_only=False):
""" Returns whether the server is running on 'server_port'.
If error_only, return False only if there was an error (ie the
socket is closed).
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
sock.bind(('localhost', 0))
sock.listen(1)
try:
port = str(sock.getsockname()[1])
send_port(server_port, "ping", port, timeout=timeout)
try:
server, address = accept_no_intr(sock)
try:
command, arguments = receive(server)
return command == "__status__" and bool(int(arguments))
finally:
try:
server.shutdown(socket.SHUT_RD)
except:
pass
except socket.error:
# 'sock' may have timed out, so use try..except.
try:
sock.shutdown(socket.SHUT_RD)
except:
pass
return False
except:
try:
sock.shutdown(socket.SHUT_RD)
except:
pass
def ping(server_port, timeout=1, error_only=False):
""" Returns whether the server is running on 'server_port'.
If error_only, return False only if there was an error (ie the
socket is closed).
"""
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(timeout)
sock.bind(('localhost', 0))
sock.listen(1)
try:
port = str(sock.getsockname()[1])
send_port(server_port, "ping", port, timeout=timeout)
try:
server, address = accept_no_intr(sock)
try:
command, arguments = receive(server)
return command == "__status__" and bool(int(arguments))
finally:
try:
server.shutdown(socket.SHUT_RD)
except:
pass
except socket.error:
# 'sock' may have timed out, so use try..except.
try:
sock.shutdown(socket.SHUT_RD)
except:
pass
return False
except:
try:
sock.shutdown(socket.SHUT_RD)
except:
pass
def main(self, port=0):
""" Starts the server mainloop. If 'port' is specified, the assumption
is that this Server was spawned from an object on said port. The
Server will inform the Client that it has been created, and if fails
to contact the client, this function will return.
"""
try:
# Start listening *before* we (potentially) inform the spawner that
# we are working. This means that if the spawner tries to register,
# we will be ready.
logger.info("Server listening on port %i..." % self._port)
self._sock.listen(5)
self._sock.settimeout(300)
# If necessary, inform the launcher that we have initialized
# correctly by telling it our port
if port:
if not send_port(port, "__port__", str(self._port), timeout=5):
msg = "Server could not contact spawner. Shutting down..."
logger.warning(msg)
return
# Start the mainloop
while True:
try:
client, address = accept_no_intr(self._sock)
except socket.timeout:
# Every 5 minutes of inactivity, we trigger a garbage
# collection. We do this to make sure the server doesn't
# stay on, with dead process as zombies.
self._gc()
continue
try:
if address[0] != '127.0.0.1':
msg = "Server received connection from a non-local " \
"party (port %s). Ignoring..."
logger.warning(msg, address[0])
continue
command, arguments = receive(client)
logger.debug("Server received: %s %s", command, arguments)
if command == "send":
port, command, arguments = arguments.split(MESSAGE_SEP)
self._send_from(int(port), command, arguments)
elif command == "register":
port, type, other_type = arguments.split(MESSAGE_SEP)
self._register(int(port), type, other_type)
elif command == "unregister":
self._unregister(int(arguments))
elif command == "ping":
self._send_to(int(arguments), "__status__", "1")
elif command == "spawn":
self._spawn(arguments)
else:
logger.error("Server received unknown command: %s %s",
command, arguments)
finally:
client.close()
finally:
self._sock.close()
def main(self, port=0):
""" Starts the server mainloop. If 'port' is specified, the assumption
is that this Server was spawned from an object on said port. The
Server will inform the Client that it has been created, and if fails
to contact the client, this function will return.
"""
try:
# Start listening *before* we (potentially) inform the spawner that
# we are working. This means that if the spawner tries to register,
# we will be ready.
logger.info("Server listening on port %i..." % self._port)
self._sock.listen(5)
self._sock.settimeout(300)
# If necessary, inform the launcher that we have initialized
# correctly by telling it our port
if port:
if not send_port(port, "__port__", str(self._port), timeout=5):
msg = "Server could not contact spawner. Shutting down..."
logger.warning(msg)
return
# Start the mainloop
while True:
try:
client, address = accept_no_intr(self._sock)
except socket.timeout:
# Every 5 minutes of inactivity, we trigger a garbage
# collection. We do this to make sure the server doesn't
# stay on, with dead process as zombies.
self._gc()
continue
try:
if address[0] != '127.0.0.1':
msg = "Server received connection from a non-local " \
"party (port %s). Ignoring..."
logger.warning(msg, address[0])
continue
command, arguments = receive(client)
logger.debug("Server received: %s %s", command, arguments)
if command == "send":
port, command, arguments = arguments.split(MESSAGE_SEP)
self._send_from(int(port), command, arguments)
elif command == "register":
port, type, other_type = arguments.split(MESSAGE_SEP)
self._register(int(port), type, other_type)
elif command == "unregister":
self._unregister(int(arguments))
elif command == "ping":
self._send_to(int(arguments), "__status__", "1")
elif command == "spawn":
self._spawn(arguments)
else:
logger.error("Server received unknown command: %s %s",
command, arguments)
finally:
client.close()
finally:
self._sock.close()
def run(self):
# Get the server port, spawning it if necessary
server_port = get_server_port()
if server_port == -1 or not Server.ping(server_port, timeout=5):
if len(self.client.server_prefs):
# Spawn the server
logger.info("Client spawning Server...")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
sock.bind(('localhost', 0))
sock.listen(1)
port = sock.getsockname()[1]
args = self.client.server_prefs + ( port, )
code = "from envisage.plugins.remote_editor.communication." \
"server import main; main(r'%s', '%s', %i)" % args
spawn_independent([sys.executable, '-c', code])
# Await a reponse from the server
try:
server, address = accept_no_intr(sock)
try:
command, arguments = receive(server)
if command == "__port__":
self.client._server_port = int(arguments)
else:
raise socket.error
finally:
# Use try...except to handle timeouts
try:
server.shutdown(socket.SHUT_RD)
except:
pass
except socket.error, e:
logger.error(repr(e))
logger.error("Client spawned a non-responsive Server! " \
"Unregistering...")
self.client.error = True
self.client.unregister()
return
finally:
sock.close()
def run(self):
# Get the server port, spawning it if necessary
server_port = get_server_port()
if server_port == -1 or not Server.ping(server_port, timeout=5):
if len(self.client.server_prefs):
# Spawn the server
logger.info("Client spawning Server...")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
sock.bind(('localhost', 0))
sock.listen(1)
port = sock.getsockname()[1]
args = self.client.server_prefs + (port, )
code = "from envisage.plugins.remote_editor.communication." \
"server import main; main(r'%s', '%s', %i)" % args
spawn_independent([sys.executable, '-c', code])
# Await a reponse from the server
try:
server, address = accept_no_intr(sock)
try:
command, arguments = receive(server)
if command == "__port__":
self.client._server_port = int(arguments)
else:
raise socket.error
finally:
# Use try...except to handle timeouts
try:
server.shutdown(socket.SHUT_RD)
except:
pass
except socket.error, e:
logger.error(repr(e))
logger.error("Client spawned a non-responsive Server! " \
"Unregistering...")
self.client.error = True
self.client.unregister()
return
finally:
sock.close()
self.client.error = not send_port(self.client._server_port, 'register',
arguments)
self.client.registered = True
# Send queued commands (these can only exist if we spawned the server)
for command, args in self.client._queue:
arguments = MESSAGE_SEP.join((port, command, args))
self.client.error = not send_port(self.client._server_port, 'send',
arguments)
self.client._queue = []
# Start the loop to listen for commands from the Server
logger.info("Client listening on port %i..." % self.client._port)
try:
while not self._finished:
server, address = accept_no_intr(sock)
# Reject non-local connections
if address[0] != '127.0.0.1':
msg = "Client on port %s received connection from a " \
"non-local party (port %s). Ignoring..."
logger.warning(msg % (port, address[0]))
continue
# Receive the command from the server
self.client.error = False
command, arguments = receive(server)
msg = r"Client on port %s received: %s %s"
logger.debug(msg, port, command, arguments)
# Handle special commands from the server
self.client.error = not send_port(self.client._server_port, 'register',
arguments)
self.client.registered = True
# Send queued commands (these can only exist if we spawned the server)
for command, args in self.client._queue:
arguments = MESSAGE_SEP.join((port, command, args))
self.client.error = not send_port(self.client._server_port, 'send',
arguments)
self.client._queue = []
# Start the loop to listen for commands from the Server
logger.info("Client listening on port %i..." % self.client._port)
try:
while not self._finished:
server, address = accept_no_intr(sock)
# Reject non-local connections
if address[0] != '127.0.0.1':
msg = "Client on port %s received connection from a " \
"non-local party (port %s). Ignoring..."
logger.warning(msg % (port, address[0]))
continue
# Receive the command from the server
self.client.error = False
command, arguments = receive(server)
msg = r"Client on port %s received: %s %s"
logger.debug(msg, port, command, arguments)
# Handle special commands from the server
