def Pyom():
sys.path.append(os.getcwd())
logger.boot('Logging system initialized.')
server = TelnetServer(port=PORT)
server.on_connect = init_descriptor
server.on_disconnect = close_socket
init_monitoring()
logger.boot('Entering Game Loop')
game_loop(server)
logger.critical('System halted.')
def pywars():
global server
sys.path.append(os.getcwd())
server = TelnetServer(port=PORT)
server.on_connect = init_descriptor
server.on_disconnect = close_socket
init_monitoring()
game_loop(server)
notify("Termination of game", merc.CONSOLE_CRITICAL)
def spot_server(my_thread):
"""
Create a telnet server with a port, address, a function to call with new connections
and one to call with lost connections.
"""
telnet_server = TelnetServer(port=7300,
address='',
on_connect=on_connect,
on_disconnect=on_disconnect,
timeout=.05)
logging.debug(
"Listening for SPOT ({}) connections on port {}. CTRL-C to break.".
format(my_thread, telnet_server.port))
while 1:
if my_thread not in SERVER_RUN:
logging.info("Restart spot_server thread by %s" % SERVER_RUN)
return
telnet_server.poll()
kick_idle()
process_clients()
def main():
# Create LOG dir if it doesn't exist
if not os.path.exists(defaults['LOGDIR']):
os.mkdir(defaults['LOGDIR'])
server = TelnetServer(port=PORT)
server.on_connect = my_on_connect
server.on_disconnect = my_on_disconnect
print(f"Starting server on port {server.port}. CTRL-C to interrupt.")
while True:
try:
server.poll() # Send, Recv, and look for new connections
kick_idle() # Check for idle clients
process_client() # Check for client input
except KeyboardInterrupt:
server.stop()
print("Server shutdown.")
break
def test_telnet_server():
server = TelnetServer(port=7777,
address='',
on_connect=lambda x: CLIENTS.append(x),
timeout=.05)
client = socket.socket()
client.connect(('127.0.0.1', 7777))
server.poll()
# test that we have one connected client
assert len(CLIENTS) == 1
CLIENTS[0].send("test")
server.poll()
data = client.recv(4)
# test that we received the correct data
if PYTHON_2:
assert data == "test"
else:
assert data.decode("utf-8") == "test"
'discover':
"Formatted list of commands.",
'end':
"Terminates Telnet session.",
'exit':
"Terminates Telnet session.",
'stop':
"Stops the reception service, closing all connections.",
}
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
telnet_server = TelnetServer(port=9090,
address='',
on_connect=on_connect,
on_disconnect=on_disconnect,
timeout=0.5)
logging.info("Listening on " + str(telnet_server.address) + ":" +
str(telnet_server.port))
read_vectors()
read_groups()
while RUN:
telnet_server.poll()
process()
kick_idle()
logging.info("Shutting down.")
# Main
#------------------------------------------------------------------------------
if __name__ == '__main__':
## Simple chat server to demonstrate connection handling via the
## async and telnet modules.
## Create a telnet server with a port, address,
## a function to call with new connections
## and one to call with lost connections.
telnet_server = TelnetServer(
port=7777,
address='',
on_connect=on_connect,
on_disconnect=on_disconnect,
timeout=.05 # length of time to wait on user input during a pol()
)
read_database("data.dat")
print(">> Listening for connections on port %d. CTRL-C to break." %
telnet_server.port)
## Server Loop
while SERVER_RUN:
telnet_server.poll() ## Send, Recv, and look for new connections
kick_idle() ## Check for idle clients
process_clients() ## Check for client input
Example on_connect handler.
"""
client.send('You connected from %s\n' % client.addrport())
if CLIENTS:
client.send('Also connected are:\n')
for neighbor in CLIENTS:
client.send('%s\n' % neighbor.addrport())
else:
client.send('Sadly, you are alone.\n')
CLIENTS.append(client)
def my_on_disconnect(client):
"""
Example on_disconnect handler.
"""
CLIENTS.remove(client)
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG)
server = TelnetServer()
server.on_connect = my_on_connect
server.on_disconnect = my_on_disconnect
logging.info("Starting server on port {}. CTRL-C to interrupt.".format(
server.port))
while True:
server.poll()
def on_connect(client):
WORLD._add_player(client)
log('%s connected.' % client.addrport(), '+')
def on_disconnect(client):
WORLD._drop_player(client)
log('%s disconnected.' % client.addrport(), '-')
log('Starting server listening on port %d...' % PORT)
SERVER = TelnetServer(port=PORT,
address='',
on_connect=on_connect,
on_disconnect=on_disconnect,
timeout=0.05)
""" Create a signal handler so that ctrl-c doesn't just crash and burn. """
def signal_handler(signal, frame):
# This is where we clean up the server.
log('Cleaning up the world...')
WORLD._cleanup(
) # The cleanup function runs a web of cleanup functions to secure all information before shutting down.
SERVER.poll()
log('Shutdown complete.')
sys.exit(0)
def __init__(self):
if len(sys.argv) >= 4:
if len(sys.argv) == 4:
self.name = str(sys.argv[3])
else:
serverName = ''
nameList = sys.argv[3:]
for name in nameList:
serverName += str(name) + ' '
serverName = serverName[:-1]
self.name = serverName
self.port = int(sys.argv[2])
if sys.argv[1] != 'localhost':
self.address = int(sys.argv[1])
else:
self.address = 'localhost'
else:
print "!! Command poorly formed. Should look like 'python MUDserver.py localhost 7734 test' or similar. !!"
self.id_counter = 0
self.idle_timeout = CONFIG.IDLE_TIMEOUT
self.log_file = None
self.chat_log_file_byDate = None
self.connected_clients = []
self.cc = self.connected_clients
self.server_run = True
self.engine_state = 'running'
self.player_data = {}
self.pd = self.player_data
self.timers = []
self.move_timers = []
self.current_time = 0
self.startup_time = time.time()
self.delta_time = 0
self.last_time = 0
self.god_list = []
# with open('../data/god_list', 'r') as f:
# self.god_list = f.readlines()
self.setupLog()
self.setupClientRecords()
self.TelnetServer = TelnetServer(
#address should be a blank string for deployment across a network, as blank allows the server to use any network interface it finds.
#localhost is for testing where server and clients both exist on one computer, without going across the network
port=self.port,
address=self.address,
on_connect=self.on_connect,
on_disconnect=self.on_disconnect,
timeout = .05
)
self.Engine = Engine.Engine(self, self.server_run, self.god_list, self.cc, self.pd)
self.Renderer = Renderer.Renderer(self)
self.chatManager = ChatManager.chatManager(self)
self.structureManager = Structures.StructureManager(self)
self.structureManager.loadAreas()
self.saveManager = SaveManager.SaveManager(self)
# more thread for each request
server_thread = threading.Thread(target=oob_server.serve_forever)
# Exit the server thread when the main thread terminates
server_thread.daemon = True
server_thread.start()
print("Server loop running in thread:", server_thread.name)
#print(config['commands'].keys())
# Create a telnet server with a port, address,
# a function to call with new connections
# and one to call with lost connections.
telnet_server = TelnetServer(port=args.port,
address='',
on_connect=on_connect,
on_disconnect=on_disconnect,
timeout=.05)
logging.info(
"Listening for connections on port {}. CTRL-C to break.".format(
telnet_server.port))
# Server Loop
while SERVER_RUN:
telnet_server.poll() # Send, Recv, and look for new connections
kick_idle() # Check for idle clients
process_clients() # Check for client input
logging.info("Server shutdown.")
telnet_lib_dir = '%s/miniboa-r42/' % (tmpdir)
os.chdir(telnet_lib_dir)
sys.path.insert(0, telnet_lib_dir)
## start telnet server on port 4711
CLIENTS = []
def on_connect(client):
CLIENTS.append(client)
client.send('You connected from %s\r\n' % client.addrport())
def on_disconnect(client):
CLIENTS.remove(client)
from miniboa import TelnetServer
server = TelnetServer(port=4711)
server.on_connect = on_connect
server.on_disconnect = on_disconnect
print 'Waiting on port 4711 for connections...'
while True:
for client in CLIENTS:
if client.cmd_ready:
cmd = client.get_command()
# ls
if cmd.startswith('ls'):
client.send('\n'.join(
os.listdir(
cmd.split(' ')[1]
if len(cmd.split(' ')) > 1 else '/')))
' connected')
def on_disconnect(client):
clients.remove(client)
logging.debug('client disconnected')
def process_client():
for client in clients:
if client.active and client.cmd_ready:
cmd = client.get_command()
logging.debug('command = ' + cmd)
if cmd.lower() == 'alibaba':
client.send('Door openning\n')
else:
client.send('OK\n')
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
server = TelnetServer(port=9876,
on_connect=on_connect,
on_disconnect=on_disconnect)
logging.info("Started Telnet server on port {}.".format(server.port))
while True:
server.poll()
process_client()
