def __init__(self, master_ip, master_port, max_clients, mumbleteam_enable, mumbleteam_ip, mumbleteam_port, ircbot_enable, ircbot_ip, ircbot_port):
self.authentication_model = AuthenticationModel()
self.servers_model = ServersModel()
self.socket_manager = SocketManager(master_ip, master_port, max_clients)
if mumbleteam_enable:
self.mumbleteam_connection = MumbleTeamConnection(mumbleteam_ip, mumbleteam_port)
else:
self.mumbleteam_connection = None
if ircbot_enable:
self.ircbot_connection = IrcBotConnection(ircbot_ip, ircbot_port)
else:
self.ircbot_connection = None
self.punitive_model = PunitiveModel()
#######################################
#connect up our signals
#######################################
#SocketManager
self.socket_manager.started.connect(self.on_started)
self.socket_manager.update.connect(self.on_update)
self.socket_manager.stopped.connect(self.on_stopped)
self.socket_manager.connect.connect(self.on_connect)
self.socket_manager.request.connect(self.on_request)
self.socket_manager.disconnect.connect(self.on_disconnect)
#AuthenticationModel
self.authentication_model.challenge.connect(self.on_auth_challenge)
self.authentication_model.accept.connect(self.on_auth_accept)
self.authentication_model.deny.connect(self.on_auth_deny)
#PunitiveModel
self.punitive_model.update.connect(self.on_effect_update)
self.punitive_model.remove.connect(self.on_effect_remove)
#######################################
#start up the socket_manager
#######################################
self.socket_manager.run()
def __init__(self, master_ip, master_port, max_clients):
self.authentication_model = AuthenticationModel()
self.servers_model = ServersModel()
self.punitive_model = PunitiveModel()
self.stats_model = StatsModel()
self.socket_manager = SocketManager(master_ip, master_port, max_clients)
#######################################
# connect up our signals
#######################################
# SocketManager
self.socket_manager.started.connect(self.on_started)
self.socket_manager.stopped.connect(self.on_stopped)
self.socket_manager.connect.connect(self.on_connect)
self.socket_manager.request.connect(self.on_request)
self.socket_manager.disconnect.connect(self.on_disconnect)
# ServersModel
self.servers_model.challenge.connect(self.on_challenge)
self.servers_model.accept.connect(self.on_accept)
self.servers_model.deny.connect(self.on_deny)
# AuthenticationModel
self.authentication_model.challenge.connect(self.on_auth_challenge)
self.authentication_model.accept.connect(self.on_auth_accept)
self.authentication_model.deny.connect(self.on_auth_deny)
# PunitiveModel
self.punitive_model.update.connect(self.on_punitive_effect_update)
self.punitive_model.remove.connect(self.on_punitive_effect_remove)
#######################################
# start up the socket_manager
#######################################
self.socket_manager.run()
class Controller(object):
commands = {}
def __init__(self, master_ip, master_port, max_clients, mumbleteam_enable, mumbleteam_ip, mumbleteam_port, ircbot_enable, ircbot_ip, ircbot_port):
self.authentication_model = AuthenticationModel()
self.servers_model = ServersModel()
self.socket_manager = SocketManager(master_ip, master_port, max_clients)
if mumbleteam_enable:
self.mumbleteam_connection = MumbleTeamConnection(mumbleteam_ip, mumbleteam_port)
else:
self.mumbleteam_connection = None
if ircbot_enable:
self.ircbot_connection = IrcBotConnection(ircbot_ip, ircbot_port)
else:
self.ircbot_connection = None
self.punitive_model = PunitiveModel()
#######################################
#connect up our signals
#######################################
#SocketManager
self.socket_manager.started.connect(self.on_started)
self.socket_manager.update.connect(self.on_update)
self.socket_manager.stopped.connect(self.on_stopped)
self.socket_manager.connect.connect(self.on_connect)
self.socket_manager.request.connect(self.on_request)
self.socket_manager.disconnect.connect(self.on_disconnect)
#AuthenticationModel
self.authentication_model.challenge.connect(self.on_auth_challenge)
self.authentication_model.accept.connect(self.on_auth_accept)
self.authentication_model.deny.connect(self.on_auth_deny)
#PunitiveModel
self.punitive_model.update.connect(self.on_effect_update)
self.punitive_model.remove.connect(self.on_effect_remove)
#######################################
#start up the socket_manager
#######################################
self.socket_manager.run()
def on_started(self, ip, port):
sys.stderr.write("Master server started.\n")
sys.stderr.write("Listening on ({}, {}).\n".format(ip, port))
sys.stderr.write("Press Ctrl-c to exit.\n")
def on_update(self):
self.punitive_model.refresh()
def on_stopped(self):
sys.stderr.write("\nMaster server stopped.\n")
def on_connect(self, client):
sys.stderr.write("client connected {}.\n".format(client.address))
def on_request(self, client, data):
sys.stderr.write("client command {}: {}\n".format(client.address, repr(data)))
split_data = data.split(None, 1)
split_data_len = len(split_data)
if split_data_len < 1:
return
elif split_data_len < 2:
command = split_data[0]
arg_string = ""
else:
command, arg_string = split_data
if command in self.commands:
try:
self.commands[command](self, client, arg_string)
except:
exceptionType, exceptionValue, exceptionTraceback = sys.exc_info() #@UnusedVariable
sys.stderr.write("Uncaught exception occurred processing master client command.\n")
sys.stderr.write(traceback.format_exc())
def on_disconnect(self, client):
self.servers_model.remove_server(client)
sys.stderr.write("client disconnected {}.\n".format(client.address))
def on_auth_challenge(self, client, authid, challenge):
message = "chalauth %s %s\n" % (authid, challenge)
client.send(message)
def on_auth_accept(self, client, authid, uid, display_name, groups):
def remove_spaces(string):
return string.translate(None, ' ')
display_name = remove_spaces(display_name)
groups = map(remove_spaces, groups)
message = "succauth {} {} {} {}\n".format(authid, uid, display_name, ' '.join(groups))
client.send(message)
def on_auth_deny(self, client, authid):
message = "failauth {}\n".format(authid)
client.send(message)
def on_effect_update(self, effect_id, effect_type, target_ip, target_mask, reason):
message = "effectupdate {} {} {} {} {}\n".format(effect_id, effect_type, target_ip, target_mask, reason)
self.servers_model.broadcast(message)
def on_effect_remove(self, effect_id):
message = "effectremove {}\n".format(effect_id)
self.servers_model.broadcast(message)
class Controller(object):
def __init__(self, master_ip, master_port, max_clients):
self.authentication_model = AuthenticationModel()
self.servers_model = ServersModel()
self.punitive_model = PunitiveModel()
self.stats_model = StatsModel()
self.socket_manager = SocketManager(master_ip, master_port, max_clients)
#######################################
# connect up our signals
#######################################
# SocketManager
self.socket_manager.started.connect(self.on_started)
self.socket_manager.stopped.connect(self.on_stopped)
self.socket_manager.connect.connect(self.on_connect)
self.socket_manager.request.connect(self.on_request)
self.socket_manager.disconnect.connect(self.on_disconnect)
# ServersModel
self.servers_model.challenge.connect(self.on_challenge)
self.servers_model.accept.connect(self.on_accept)
self.servers_model.deny.connect(self.on_deny)
# AuthenticationModel
self.authentication_model.challenge.connect(self.on_auth_challenge)
self.authentication_model.accept.connect(self.on_auth_accept)
self.authentication_model.deny.connect(self.on_auth_deny)
# PunitiveModel
self.punitive_model.update.connect(self.on_punitive_effect_update)
self.punitive_model.remove.connect(self.on_punitive_effect_remove)
#######################################
# start up the socket_manager
#######################################
self.socket_manager.run()
def on_started(self, ip, port):
print "Master server started."
print "Listening on (%s, %s)." % (str(ip), str(port))
print "Press Ctrl-c to exit."
def on_stopped(self):
print "\nMaster server stopped."
def on_connect(self, client):
print "client connected %s" % str(client.address)
def on_request(self, client, data):
print "client request %s:" % str(client.address), data
"""
#inbound messages
list = list servers
sr = server registration
sc = server confirmation
ar = authentication request
ac = authentication confirmation
eu = effect update
er = effect remove
sd = stats data
#outbound messages
rc = registration challenge
rs = registration success
rf = registration failure
ac = authentication challenge
as = authentication success
af = authentication failure
na = names add
nr = names remove
eu = effect update
er = effect remove
"""
if data[0] == "list":
servers_list = self.servers_model.get_server_list()
client.send(servers_list)
if data[0] == "sr":
self.servers_model.register_server(client, data[1], data[2])
elif data[0] == "sc":
self.servers_model.confirm_server(client, data[1])
elif not self.servers_model.is_server_confirmed(client):
client.disconnect()
return
else:
if data[0] == "ar":
self.authentication_model.request_authentication(client, data[1], data[2])
elif data[0] == "ac":
self.authentication_model.confirm_authentication(client, data[1], data[2])
elif data[0] == "ec":
self.punitive_model.create_effect(client, *data[1:])
elif data[0] == "sd":
self.punitive_model.add_data(client, data)
def on_disconnect(self, client):
print "client disconnected %s" % str(client.address)
def on_challenge(self, client, challenge):
message = "rc %s\n" % challenge
client.send(message)
def on_accept(self, client):
client.unlimit()
effect_list = self.punitive_model.get_effect_list()
names_list = self.authentication_model.get_name_list()
message = "".join(("rs\n", effect_list, names_list))
client.send(message)
def on_deny(self, client):
client.send("rf\n")
client.disconnect()
def on_auth_challenge(self, client, authid, challenge):
message = "ac %s %s\n" % (authid, challenge)
client.send(message)
def on_auth_accept(self, client, authid, userid, groups, names):
message = "as %d %d %s %s\n" % (authid, userid, ",".join(groups), ",".join(names))
client.send(message)
def on_auth_deny(self, client, authid):
message = "af %s\n" % authid
client.send(message)
def on_punitive_effect_update(self, effect_id, effect_type, target_ip, target_mask, reason):
message = "eu %d %d %s %s %s\n" % (effect_id, effect_type, target_ip, target_mask, reason)
self.servers_model.broadcast(message)
def on_punitive_effect_remove(self, effect_id):
message = "er %d\n" % effect_id
self.server_model.broadcast(message)
