async def repost_messages(self):
self.servers = Servers()
self.server_list = self.servers.get()
repost_count = 0
# remove old discord embed
channels = [server["channel"] for server in self.server_list]
channels = list(set(channels)) # remove duplicated channels
for channel in channels:
try:
await client.get_channel(channel).purge(
check=lambda m: m.author == client.user)
except Exception as e:
self.print_to_console(
f'ERROR: Unable to delete bot messages.\n{e}')
finally:
await asyncio.sleep(SEND_DELAY)
# send new discord embed
for server in self.server_list:
try:
message = await client.get_channel(
server["channel"]).send(embed=self.get_embed(server))
server["message_id"] = message.id
repost_count += 1
except Exception as e:
self.message_error_count += 1
self.print_to_console(
f'ERROR: Failed to send message for server: {self.get_server_info(server)}. Missing permissions ?\n{e}'
)
finally:
self.servers.update_server_file(self.server_list)
await asyncio.sleep(SEND_DELAY)
self.print_to_console(f'{repost_count} messages reposted.')
class DNSProxy(SocketServer.ThreadingMixIn, SocketServer.UDPServer):
SocketServer.ThreadingMixIn.daemon_threads = True
allow_reuse_address = True
def __init__(self, address=("0.0.0.0", 53), VERBOSE=2):
self.VERBOSE = VERBOSE
print "listening at:", address
SELF = self
class ProxyHandle(SocketServer.BaseRequestHandler):
# Ctrl-C will cleanly kill all spawned threads
daemon_threads = True
# much faster rebinding
allow_reuse_address = True
def handle(self):
data = self.request[0]
socket = self.request[1]
addr = self.client_address
DNSProxy.transfer(SELF, data, addr, socket)
SocketServer.UDPServer.__init__(self, address, ProxyHandle)
def loadConfig(self, config):
self.DNSS = config.DNSS
self.servers = Servers()
for s in self.DNSS:
assert len(s) == 3
ip, port, type_of_server = s
self.servers.addDNSServer(DNSServer(ip, port, type_of_server))
self.WHITE_DNSS = config.WHITE_DNSS
for ws in self.WHITE_DNSS:
assert len(ws) == 4
ip, port, type_of_server, white_list = ws
self.servers.addWhiteDNSServer(DNSServer(ip, port, type_of_server, white_list))
def transfer(self, query_data, addr, server):
if not query_data: return
domain = bytetodomain(query_data[12:-4])
qtype = struct.unpack('!h', query_data[-4:-2])[0]
print 'domain:%s, qtype:%x, thread:%d' % \
(domain, qtype, threading.activeCount())
sys.stdout.flush()
response = None
for i in range(9):
response, dnsserv = self.servers.query(query_data)
if response:
# udp dns packet no length
server.sendto(response[2:], addr)
if int(self.VERBOSE) > 0:
dnsserv.showInfo(query_data, 0)
dnsserv.showInfo(response[2:], 1)
break
if response is None:
print "[ERROR] Tried 9 times and failed to resolve %s" % domain
return
def find_status_by_server(self, serial_no=None):
if serial_no is not None and serial_no != "":
s = Servers(self._rpcurl)
server_rec = s.find_by_serial_no(serial_no)
if server_rec is not None:
installstate = self._proxy.dc2.deployment.installstate.get(
{"server_id": server_rec["_id"]})
if installstate is not None:
return installstate
return None
def __init__(self, bot):
print('\n----------------')
print('Github: \thttps://github.com/DiscordGSM/DiscordGSM')
print('Discord:\thttps://discord.gg/Cg4Au9T')
print('----------------\n')
self.bot = bot
self.servers = Servers()
self.server_list = self.servers.get()
self.messages = []
self.message_error_count = self.current_display_server = 0
def loadConfig(self, config):
self.DNSS = config.DNSS
self.servers = Servers()
for s in self.DNSS:
assert len(s) == 3
ip, port, type_of_server = s
self.servers.addDNSServer(DNSServer(ip, port, type_of_server, self.VERBOSE))
self.WHITE_DNSS = config.WHITE_DNSS
for ws in self.WHITE_DNSS:
assert len(ws) == 4
ip, port, type_of_server, white_list = ws
self.servers.addWhiteDNSServer(DNSServer(ip, port, type_of_server, self.VERBOSE, white_list))
class DNSProxy(SocketServer.ThreadingMixIn, SocketServer.UDPServer):
SocketServer.ThreadingMixIn.daemon_threads = True
allow_reuse_address = True
def __init__(self, address=("0.0.0.0", 53), VERBOSE=2):
self.VERBOSE = VERBOSE
print "listening at:", address
SELF = self
class ProxyHandle(SocketServer.BaseRequestHandler):
# Ctrl-C will cleanly kill all spawned threads
daemon_threads = True
# much faster rebinding
allow_reuse_address = True
def handle(self):
data = self.request[0]
socket = self.request[1]
addr = self.client_address
DNSProxy.transfer(SELF, data, addr, socket)
SocketServer.UDPServer.__init__(self, address, ProxyHandle)
def loadConfig(self, config):
self.DNSS = config.DNSS
self.servers = Servers()
for s in self.DNSS:
assert len(s) == 3
ip, port, type_of_server = s
self.servers.addDNSServer(DNSServer(ip, port, type_of_server, self.VERBOSE))
self.WHITE_DNSS = config.WHITE_DNSS
for ws in self.WHITE_DNSS:
assert len(ws) == 4
ip, port, type_of_server, white_list = ws
self.servers.addWhiteDNSServer(DNSServer(ip, port, type_of_server, self.VERBOSE, white_list))
def transfer(self, query_data, addr, server):
if not query_data: return
domain = bytetodomain(query_data[12:-4])
qtype = struct.unpack('!h', query_data[-4:-2])[0]
#print 'domain:%s, qtype:%x, thread:%d' % (domain, qtype, threading.activeCount())
sys.stdout.flush()
response = None
for i in range(9):
response = self.servers.query(query_data)
if response:
# udp dns packet no length
server.sendto(response[2:], addr)
break
if response is None:
print "[ERROR] Tried 9 times and failed to resolve %s" % domain
return
def find_by_server_serial(self, serial_no=None):
if serial_no is not None:
s = Servers(self._rpcurl)
server_rec = s.find_by_serial_no(serial_no)
if server_rec is not None:
host_list = self._proxy.dc2.inventory.hosts.find(
{"server_id": server_rec["_id"]})
if (host_list is not None and
len(host_list) > 0 and
host_list[0] is not None):
return host_list[0]
return None
def find_by_server_mac(self, mac_addr=None):
if mac_addr is not None:
s = Servers(self._rpcurl)
server_rec = s.find_by_mac(mac_addr)
if server_rec is not None:
host_list = self._proxy.dc2.inventory.hosts.find(
{"server_id": server_rec["_id"]})
if (host_list is not None and
len(host_list) > 0 and
host_list[0] is not None):
return host_list[0]
return None
async def refresh_discord_embed(self):
# refresh servers.json cache
self.servers = Servers()
self.server_list = self.servers.get()
# remove old discord embed
channels = [server['channel'] for server in self.server_list]
channels = list(set(channels)) # remove duplicated channels
for channel in channels:
await bot.get_channel(channel).purge(check=lambda m: m.author==bot.user)
# send new discord embed
self.messages = [await bot.get_channel(s['channel']).send(content=('frontMessage' in s and s['frontMessage'].strip()) and s['frontMessage'] or None, embed=self.get_embed(s)) for s in self.server_list]
def test_sp():
network_file = "../Networks/isno_30_4"
#network_file = "../Networks/isno_5_2"
n = Network(network_file)
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
#servers_file = "../DataComposite/test-cost.txt"
servers_file = "../DataComposite/isno_30_4-t2-costs.txt"
s = Servers(t, n, servers_file)
#users_dem_file = "../DataComposite/test-users.txt"
#users_top_file = "../DataComposite/test-user_topo.txt"
users_dem_file = "../DataComposite/isno_30_4-t2-users.txt"
users_top_file = "../DataComposite/isno_30_4-t2-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n,
t,
s,
u,
opt_cong=True,
congestion_cost=True,
cong_opt_method="sp",
cong_of="fortz")
print("Starting EA:")
ea = EACompositeServices(cs, optimize_routing_weights=True)
ea_par = {"max_evaluations": 50000}
#bestsol = ea.run_evol_alg(ea_pars = ea_par)
ea.run_evol_alg(True, max_cpus=4, ea_pars=ea_par)
def test_germany():
network_file = "../Networks/germany50.txt"
n = Network(network_file, "sndlib")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
servers_file = "../DataComposite/germany50-cost.txt"
s = Servers(t, n, servers_file)
users_dem_file = "../DataComposite/germany50-users.txt"
users_top_file = "../DataComposite/germany50-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n, t, s, u, opt_cong=True, congestion_cost=True)
print("Starting EA:")
ea = EACompositeServices(cs)
#bestsol = ea.run_evol_alg()
bestsol = ea.run_evol_alg(True, max_cpus=50)
of = cs.of_normalized_penalty(bestsol, True)
print("Objective function:", of)
def test_mo():
network_file = "../Networks/geant.txt"
n = Network(network_file, "sndlib")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
servers_file = "../DataComposite/geant-t2-costs.txt"
s = Servers(t, n, servers_file)
users_dem_file = "../DataComposite/geant-t2-users.txt"
users_top_file = "../DataComposite/geant-t2-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n,
t,
s,
u,
opt_cong=True,
congestion_cost=True,
cong_of="fortz")
ea_par = {"max_evaluations": 10000}
ea = EACompositeServices(cs)
#ea = EACompositeServices(cs,optimize_routing_weights = True)
ea.run_mo(ea_pars=ea_par, plot=True)
def test_tree():
network_file = "../Networks/test_tree"
n = Network(network_file)
filename_tree = "../DataComposite/tree_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
servers_file = "../DataComposite/test_tree-cost.txt"
s = Servers(t, n, servers_file)
users_dem_file = "../DataComposite/test_tree-users.txt"
users_top_file = "../DataComposite/test_tree-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n, t, s, u, opt_cong=True, congestion_cost=True)
print(cs)
print("Starting EA:")
ea = EACompositeServices(cs)
ea_par = {"max_evaluations": 5000}
bestsol = ea.run_evol_alg(ea_pars=ea_par)
#bestsol = ea.run_evol_alg(True, max_cpus = 50)
of = cs.of_normalized_penalty(bestsol, True)
print("Objective function:", of)
def update_status_by_server(
self,
serial_no=None,
status=None,
progress=None):
if serial_no is not None and serial_no != "":
s = Servers(self._rpcurl)
server_rec = s.find_by_serial_no(serial_no)
if server_rec is not None:
installstate = self._proxy.dc2.deployment.installstate.get(
{"server_id": server_rec["_id"]})
if installstate is not None:
result = self._update_status(
installstate, status, progress)
return result
return None
def test_germany():
network_file = "../Networks/germany50.txt"
n = Network(network_file, "sndlib")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
servers_file = "../DataComposite/germany50-cost.txt"
s = Servers(t, n, servers_file)
users_dem_file = "../DataComposite/germany50-users.txt"
users_top_file = "../DataComposite/germany50-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n, t, s, u, opt_cong=False, congestion_cost=False)
hcs = CompositeHeuristic(cs)
order = list(range(len(cs.users)))
sol = hcs.heuristic(order)
print(sol)
of = cs.of_normalized_penalty(sol, True)
print("Objective function:", of)
def test1():
n = Network("../Networks/isno_5_2")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
s = Servers(t, n, "../DataComposite/isno_5_2-costs.txt")
u = Users(n, "../DataComposite/isno_5_2-users.txt",
"../DataComposite/isno_5_2-user_topo.txt")
cs = CompositeServices(n,
t,
s,
u,
opt_cong=False,
congestion_cost=True,
cong_of="fortz")
hcs = CompositeHeuristic(cs)
order = list(range(len(cs.users)))
sol = hcs.heuristic(order)
print(sol)
of = cs.of_normalized_penalty(sol, True)
print("Objective function:", of)
async def refresh_discord_embed(self):
# refresh servers.json cache
self.servers = Servers()
self.server_list = self.servers.get()
# remove old discord embed
channels = [server['channel'] for server in self.server_list]
channels = list(set(channels)) # remove duplicated channels
for channel in channels:
await bot.get_channel(channel).purge(
check=lambda m: m.author == bot.user)
# send new discord embed
self.messages = []
for server in self.server_list:
if ('frontMessage' in server and server['frontMessage'] != ''):
self.messages.append(await bot.get_channel(
server['channel']).send(server['frontMessage']))
self.messages.append(await bot.get_channel(
server['channel']).send(embed=self.get_embed(server)))
def test2():
n = Network("../Networks/isno_5_2")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
s = Servers(t, n, "../DataComposite/test-cost.txt")
u = Users(n, "../DataComposite/test-users.txt",
"../DataComposite/test-user_topo.txt")
cs = CompositeServices(n, t, s, u, opt_cong=True, congestion_cost=True)
print(cs)
def loadConfig(self, config):
self.DNSS = config.DNSS
self.servers = Servers()
for s in self.DNSS:
assert len(s) == 3
ip, port, type_of_server = s
self.servers.addDNSServer(DNSServer(ip, port, type_of_server, self.VERBOSE))
self.WHITE_DNSS = config.WHITE_DNSS
for ws in self.WHITE_DNSS:
assert len(ws) == 4
ip, port, type_of_server, white_list = ws
self.servers.addWhiteDNSServer(DNSServer(ip, port, type_of_server, self.VERBOSE, white_list))
def __init__(self, apikey=None, timeout=None, verbose=False):
headers = {}
if apikey:
headers['apikey'] = apikey
_api = API(timeout=timeout, verbose=verbose)
def api(method, uri, attrs={}):
return _api.request(method, self.API_URL + uri, attrs, headers)
self.appliances = Appliances(api)
self.servers = Servers(api)
self.backups = Backups(api)
def setup_session(self):
"""Creates instances
This method is called when the game is first started.
It will create instances for players, map generators
and servers.
15 servers instances will be created
"""
self.player_1 = Hacker()
self.player_2 = Hacker()
self.servers = []
for srv in range(15):
self.servers.append(Servers(srv))
self.wmap = Worldmap(self.servers)
def test5():
filename_tree = "../DataComposite/tree_syn_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
n = Network("../Networks/geant.txt", "sndlib")
s = Servers(t, n, "../DataComposite/geant-tree-syn-costs.txt")
u = Users(n, "../DataComposite/geant-tree-syn-users.txt",
"../DataComposite/geant-tree-syn-user_topo.txt")
cs = CompositeServices(n, t, s, u, opt_cong=False, congestion_cost=False)
#print(cs)
print(cs.min_cost())
print(cs.minimum_first_hop())
def test1():
from composite_heuristic import CompositeHeuristic
n = Network("../Networks/isno_5_2")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
s = Servers(t, n, "../DataComposite/isno_5_2-costs.txt")
u = Users(n, "../DataComposite/isno_5_2-users-v2.txt",
"../DataComposite/isno_5_2-user_topo.txt")
cs = CompositeServices(n, t, s, u, opt_cong=True, congestion_cost=True)
#print(cs)
hcs = CompositeHeuristic(cs)
order = list(range(len(cs.users)))
sol = hcs.heuristic(order)
cs.of_normalized_penalty(sol, printcomps=True)
def test_tree_syn_structure():
filename_tree = "../DataComposite/tree_syn_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
n = Network("../Networks/geant.txt", "sndlib")
u = Users(n)
u.generate_users(len(t), target_alu=0.25, target_delay=0.8)
u.write_demands("../DataComposite/geant-treesyn-alu25-del08-users.txt")
u.write_user_topo(
"../DataComposite/geant-treesyn-alu25-del08-user_topo.txt")
s = Servers(t, n)
s.generate_servers()
s.write_servers("../DataComposite/geant-treesyn-alu25-del08-costs.txt")
def test3():
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
#n = Network("../Networks/isno_30_4")
n = Network("../Networks/isno_5_2")
u = Users(n)
u.generate_users(len(t), target_alu=0.25, target_delay=0.8)
u.write_demands("../DataComposite/isno_5_2-t2-users.txt")
u.write_user_topo("../DataComposite/isno_5_2-t2-user_topo.txt")
#u.write_demands("../DataComposite/isno_30_4-t1-users.txt")
#u.write_user_topo("../DataComposite/isno_30_4-t1-user_topo.txt")
s = Servers(t, n)
s.generate_servers()
s.write_servers("../DataComposite/isno_5_2-t2-costs.txt")
def test1():
#etwork_file = "../Networks/isno_30_4"
network_file = "../Networks/isno_5_2"
n = Network(network_file)
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
#servers_file = "../DataComposite/test-cost.txt"
#servers_file = "../DataComposite/isno_30_4-t1-costs.txt"
servers_file = "../DataComposite/isno_5_2-t1-costs.txt"
s = Servers(t, n, servers_file)
#users_dem_file = "../DataComposite/test-users.txt"
#users_top_file = "../DataComposite/test-user_topo.txt"
#users_dem_file = "../DataComposite/isno_30_4-t1-users.txt"
#users_top_file = "../DataComposite/isno_30_4-t1-user_topo.txt"
users_dem_file = "../DataComposite/isno_5_2-t2-users.txt"
users_top_file = "../DataComposite/isno_5_2-t1-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n,
t,
s,
u,
opt_cong=False,
congestion_cost=True,
cong_of="fortz")
print("Starting EA:")
ea_par = {"max_evaluations": 500}
ea = EACompositeServices(cs)
assig = ea.run_evol_alg(ea_pars=ea_par)
#assig = ea.run_evol_alg(True, max_cpus = 50)
print("Best solution:")
print(assig)
def test_geant():
network_file = "../Networks/geant.txt"
n = Network(network_file, "sndlib")
#filename_tree = "../DataComposite/tree_syn_structure.txt"
filename_tree = "../DataComposite/linear_structure_loops.txt"
loops = True
t = ServicesTree(loops, filename_tree)
#servers_file = "../DataComposite/geant-loops-costs.txt"
servers_file = "../DataComposite/geant-lin-alu30-del09-costs.txt"
s = Servers(t, n, servers_file)
#users_dem_file = "../DataComposite/geant-treeloops-alu25-del07-users.txt"
users_dem_file = "../DataComposite/geant-lin-alu30-del09-users.txt"
#users_top_file = "../DataComposite/geant-treeloops-alu25-del07-user_topo.txt"
users_top_file = "../DataComposite/geant-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
# cs = CompositeServices(n, t, s, u, opt_cong = True, cong_opt_method = "sp",
# congestion_cost = True, cong_of = "fortz")
cs = CompositeServices(n,
t,
s,
u,
opt_cong=False,
congestion_cost=False,
cong_of="fortz")
ea_par = {"max_evaluations": 20000, "pop_size": 100}
ea = EACompositeServices(cs)
#ea = EACompositeServices(cs,optimize_routing_weights = True)
assig = ea.run_evol_alg(ea_pars=ea_par)
print("Best solution:")
print(assig)
def run(self):
""" Begin the simulation and record the system variables during execution. """
# Initialise the beginning parameters of the simulation
servers = Servers(self.total_servers)
self.event_handler = M1M2EventHandler()
self.event_handler.start()
# Begin iteration of events, record arrivals for checking
self.count_arrival = 0
self.arrival = {"handover": 0, "new": 0}
while self.count_arrival < self.total_arrival:
# Collect next event from the event handler
current_event = self.event_handler.next()
# Update simulation time
self.sim_time = current_event.time()
if current_event.type == "arrival":
# Arrival event received
priority = current_event.path
self.count_arrival += 1
self.arrival[priority] += 1
# Create new arrival event
self.event_handler.add(
M1M2Event(priority, "arrival", current_event.time()))
# Check server available
if (len(servers) > self.threshold) or \
(priority == "handover" and servers.is_free()):
# Begin serving the client.
current_event.served_by(servers.allocate())
# All event handler to manage departure
self.event_handler.add(current_event)
continue
# No servers were available therefore the event is blocked
self.event_handler.block(
current_event) # Arriving client has been blocked
else:
# Departure event received
servers.deallocate(
current_event.served_by()) # Free the server
self.event_handler.depart(
current_event) # Event recorded as departed.
def test1():
#network_file = "../Networks/isno_30_4"
network_file = "../Networks/geant.txt"
n = Network(network_file, "sndlib")
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
# servers_file = "../DataComposite/isno_30_4-t1-costs.txt"
servers_file = "../DataComposite/geant-t3-costs.txt"
s = Servers(t, n, servers_file)
users_dem_file = "../DataComposite/geant-t3-users.txt"
# users_dem_file = "../DataComposite/isno_30_4-t1-users.txt"
users_top_file = "../DataComposite/geant-t3-user_topo.txt"
# users_top_file = "../DataComposite/isno_30_4-t1-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n,
t,
s,
u,
opt_cong=True,
congestion_cost=True,
cong_opt_method="sp",
cong_of="fortz")
print("Starting EA:")
ea = DeapComposite(cs, optimize_routing_weights=True)
#ea.run_evol_alg({"num_gens": 100})
_, _, f = ea.run_mo({"max_evaluations": 10000, "algorithm": "spea"})
numpy.savetxt("front.csv", f)
def test2():
network_file = "../Networks/isno_30_4"
#network_file = "../Networks/isno_5_2"
n = Network(network_file)
filename_tree = "../DataComposite/linear_structure.txt"
loops = False
t = ServicesTree(loops, filename_tree)
#servers_file = "../DataComposite/test-cost.txt"
servers_file = "../DataComposite/isno_30_4-t1-costs.txt"
s = Servers(t, n, servers_file)
#users_dem_file = "../DataComposite/test-users.txt"
#sers_top_file = "../DataComposite/test-user_topo.txt"
users_dem_file = "../DataComposite/isno_30_4-t1-users.txt"
users_top_file = "../DataComposite/isno_30_4-t1-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
cs = CompositeServices(n,
t,
s,
u,
opt_cong=False,
congestion_cost=True,
cong_of="mlu")
hcs = CompositeHeuristic(cs)
order = list(range(len(cs.users)))
sol = hcs.heuristic(order)
print(sol)
of = cs.of_normalized_penalty(sol, True)
print("Objective function:", of)
def run(self):
""" Begin the simulation of a MMCC system. Process the information until
termination criteria is meet.
"""
# Initialise the beginning parameters of the simulation
servers = Servers(self.total_servers) # Set up server handler
self.event_handler = EventHandler() # Set up the event handler
start_event = Event("arrival", 0) # Construct the first event object
start_event.departure_time -= start_event.arrival_time # Reset times
start_event.arrival_time = 0 # Reset times
self.event_handler.add(start_event) # Create the first event
# Begin iteration of events, record arrivals for checking
self.count_arrival = 0
while self.count_arrival < self.total_arrival:
# Collect next event from the event handler
current_event = self.event_handler.next()
# Update simulation time
self.sim_time = current_event.time()
if current_event.type == "arrival":
# Create new arrival event
self.event_handler.add(Event('arrival', current_event.time()))
# Record number of arrivals
self.count_arrival += 1
# Check if any server is available
if not servers.is_free():
self.event_handler.block(current_event)
continue
# Begin serving the client.
current_event.served_by(servers.allocate())
# All event handler to manage departure
self.event_handler.add(current_event)
else:
# Departure event received
servers.deallocate(current_event.served_by())
self.event_handler.depart(current_event)
class asciiMap():
neutral = "N"
hostile = "X"
hacked = "H"
# Servers
server0 = Servers(0, 100, 200, "N")
server1 = Servers(1, 100, 200, "N")
server2 = Servers(2, 100, 200, "N")
server3 = Servers(3, 100, 200, "N")
server4 = Servers(4, 100, 200, "N")
server5 = Servers(5, 100, 200, "N")
server6 = Servers(6, 100, 200, "N")
server7 = Servers(7, 100, 200, "N")
server8 = Servers(8, 100, 200, "N")
server9 = Servers(9, 100, 200, "N")
server10 = Servers(10, 100, 200, "N")
server11 = Servers(11, 100, 200, "N")
server12 = Servers(12, 100, 200, "N")
server13 = Servers(13, 100, 200, "N")
server14 = Servers(14, 100, 200, "N")
server15 = Servers(15, 100, 200, "N")
#area = "...................." + server0 + "......\n..........." + server1 + "...............\n....." + server2 + ".....................\n...........................\n........." + server3 + ".........." + server4 + "......\n..." + server5 + ".........." + server6 + "............\n......" + server7 + "..........." + server8 + "........\n.........................." + server9 + "\n...........................\n...........................\n.." + server10 + "..........." + server11 + server12 + "...........\n............" + server13 + "........" + server14 + "...." + server15 + "\n"
def __init__(self, server0, server1, server2, server3, server4, server5,
server6, server7, server8, server9, server10, server11,
server12, server13, server14, server15):
self.server0 = server0
self.server1 = server1
self.server2 = server2
self.server3 = server3
self.server4 = server4
self.server5 = server5
self.server6 = server6
self.server7 = server7
self.server8 = server8
self.server9 = server9
self.server10 = server10
self.server11 = server11
self.server12 = server12
self.server13 = server13
self.server14 = server14
self.server15 = server15
#def get_area(self):
#return self.area
def get_status(self):
return self.server0.state
def get_map_state(self):
area = "...................." + self.server0.state + "......\n..........." + self.server1.state + "...............\n....." + self.server2.state + ".....................\n...........................\n........." + self.server3.state + ".........." + self.server4.state + "......\n..." + self.server5.state + ".........." + self.server6.sate + "............\n......" + self.server7.state + "..........." + self.server8.state + "........\n.........................." + self.server9.state + "\n...........................\n...........................\n.." + self.server10.state + "..........." + self.server11.state + self.server12.state + "...........\n............" + self.server13.state + "........" + self.server14.state + "...." + self.server15.state + "\n"
return area
from servers import Servers
script = r"""
defs="/etc/login.defs"
min=$(grep "^UID_MIN" $defs)
max=$(grep "^UID_MAX" $defs)
awk -F':' -v "min=${min##UID_MIN}" -v "max=${max##UID_MAX}" '{ if ( $3 >= min && $3 <= max) print $1 }' /etc/passwd
"""
ignoredUsers = ["ubuntu", "test_01", "temp"]
s = Servers()
s.loadHostsFrom("ip.txt")
for host, result in s.ssh(script):
users = result.stdout.splitlines()
for u in users:
if u not in ignoredUsers:
print(host + "\t" + u)
def run():
## FORMAT: type_optimization network_file services_tree instance_file results_file
## type_optimization:
## nc - no congestion
## d - congestion costs; shortest path delays
## sp - congestion costs; EA optimizing weights
## oc - congestion costs; MILP optimizaing congestion
## lnc, ld, lsp, loc - the same as before but with loops on the service tree
## network file - assuming sndlib format
## services tree - file with "tree" of services
## instance_file - defines "name" of instance
## assuming: instance_file + "-users.txt" - users demands
## assuming: instance_file + "-user_topo.txt" - users topologies
## assuming: instance_file + "-costs.txt" - server costs
## results_file: prefix of the files for results
## - files will be results_file + "-stats.txt" and results_file+ "-pop.txt"
## Options:
## -mo - do multiobjective optimization (NSGA 2)
## -p numcpus - activates parallel evaluation of OF with numcpus as maximum
## -ev maxevals - maximum number of evaluations (default: 10000)
## -mr rate - set mutation rate (per element)
## -lr rate - local opt rate (per individual)
## -r runs - number of runs (1 if not specified)
## -w weights - weights for the OF - fh, e2e, cost, congestion (split by ,)
network_file = sys.argv[2]
n = Network(network_file, "sndlib") #, engine = "igraph")
filename_tree = sys.argv[3]
if sys.argv[1][0] == "l":
loops = True
else:
loops = False
t = ServicesTree(loops, filename_tree)
servers_file = sys.argv[4] + "-costs.txt"
s = Servers(t, n, servers_file)
users_dem_file = sys.argv[4] + "-users.txt"
users_top_file = sys.argv[4] + "-user_topo.txt"
u = Users(n, users_dem_file, users_top_file)
optimize_routing_weig = False
if sys.argv[1] == "nc" or sys.argv[1] == "lnc":
cs = CompositeServices(n,
t,
s,
u,
opt_cong=False,
congestion_cost=False,
cong_of="fortz")
elif sys.argv[1] == "d" or sys.argv[1] == "ld":
cs = CompositeServices(n,
t,
s,
u,
opt_cong=False,
congestion_cost=True,
cong_of="fortz")
elif sys.argv[1] == "oc" or sys.argv[1] == "loc":
cs = CompositeServices(n,
t,
s,
u,
opt_cong=True,
congestion_cost=True,
cong_opt_method="milp",
cong_of="fortz")
elif sys.argv[1] == "sp" or sys.argv[1] == "lsp":
cs = CompositeServices(n,
t,
s,
u,
opt_cong=True,
congestion_cost=True,
cong_opt_method="sp",
cong_of="fortz")
optimize_routing_weig = True
## options
par = False
maxcpus = 1
multiobj = False
numruns = 1
eapars = {}
if len(sys.argv) > 6:
i = 6
while i < len(sys.argv):
if sys.argv[i] == "-p":
par = True
maxcpus = int(sys.argv[i + 1])
i += 2
elif sys.argv[i] == "-mo":
multiobj = True
i += 1
elif sys.argv[i] == "-ev":
eapars["max_evaluations"] = int(sys.argv[i + 1])
i += 2
elif sys.argv[i] == "-mr":
eapars["mutation_rate"] = float(sys.argv[i + 1])
i += 2
elif sys.argv[i] == "-lr":
eapars["local_opt_rate"] = float(sys.argv[i + 1])
i += 2
elif sys.argv[i] == "-r":
numruns = int(sys.argv[i + 1])
i += 2
elif sys.argv[i] == "-w":
wstr = sys.argv[i + 1]
tokens = wstr.split(",")
w = {}
w["fh"] = float(tokens[0])
w["e2e"] = float(tokens[1])
w["cost"] = float(tokens[2])
if cs.congestion_cost and len(tokens) > 3:
w["congestion"] = float(tokens[3])
cs.set_weights(w)
print(cs.weights)
i += 2
else:
print("Invalid option")
sys.exit(1)
res = {}
if multiobj:
res_keys = [
"type", "network", "tree", "instance", "popsize", "evals",
"mutation_rate", "local_rate"
]
else:
res_keys = [
"type", "network", "tree", "instance", "popsize", "evals",
"selected", "elites", "mutation_rate", "local_rate", "of_value",
"of_cost", "of_e2e", "of_fh", "of_cong"
]
for k in res_keys:
res[k] = []
network_name = sys.argv[2].split("/").pop()
tree_name = sys.argv[3].split("/").pop()
instance_name = sys.argv[4].split("/").pop()
for r in range(numruns):
start = timeit.default_timer()
ea = EACompositeServices(
cs, optimize_routing_weights=optimize_routing_weig)
res["type"].append(sys.argv[1])
res["network"].append(network_name)
res["tree"].append(tree_name)
res["instance"].append(instance_name)
if multiobj:
file_run = sys.argv[5] + "-run" + str(r)
res_ea = ea.run_mo(ea_pars=eapars,
display=False,
save_file=file_run)
#res["popsize"].append(res_ea["popsize"])
#res["evals"].append(res_ea["evals"])
#res["mutation_rate"].append(res_ea["mutation_rate"])
#res["local_rate"].append(res_ea["local_rate"])
#res_pd = pd.DataFrame(data = res)
#res_pd.to_csv(sys.argv[5] + "-results.csv")
else:
if sys.argv[5] == 'None':
_, res_ea = ea.run_evol_alg(parallel=par,
max_cpus=maxcpus,
ea_pars=eapars)
else:
file_run = sys.argv[5] + "-run" + str(r)
_, res_ea = ea.run_evol_alg(parallel=par,
max_cpus=maxcpus,
ea_pars=eapars,
save_file=file_run)
res["of_value"].append(res_ea["of_value"])
res["of_fh"].append(res_ea["of_fh"])
res["of_e2e"].append(res_ea["of_e2e"])
res["of_cost"].append(res_ea["of_cost"])
res["of_cong"].append(res_ea["of_cong"])
res["popsize"].append(res_ea["popsize"])
res["evals"].append(res_ea["evals"])
res["selected"].append(res_ea["selected"])
res["elites"].append(res_ea["elites"])
res["mutation_rate"].append(res_ea["mutation_rate"])
res["local_rate"].append(res_ea["local_rate"])
res_pd = pd.DataFrame(data=res)
res_pd.to_csv(sys.argv[5] + "-results.csv")
stop = timeit.default_timer()
print('Time EA: ', stop - start)
#'156.154.71.1',
'208.67.222.222',
#'208.67.220.220',
#'198.153.192.1',
#'198.153.194.1',
#'74.207.247.4',
#'209.244.0.3',
#'8.26.56.26'
]
DPORT = 53 # default dns port 53
TIMEOUT = 1 # set timeout 5 second
VERBOSE = 0
from servers import Servers
from dnsserver import DNSServer
ss=Servers()
for host in DHOSTS:
ss.addDNSServer(DNSServer(host))
#-------------------------------------------------------------
# Hexdump Cool :)
# default width 16
#--------------------------------------------------------------
def hexdump( src, width=16 ):
FILTER=''.join([(len(repr(chr(x)))==3) and chr(x) or '.' for x in range(256)])
result=[]
for i in xrange(0, len(src), width):
s = src[i:i+width]
hexa = ' '.join(["%02X"%ord(x) for x in s])
printable = s.translate(FILTER)
result.append("%04X %s %s\n" % (i, hexa, printable))
class DiscordGSM():
def __init__(self, bot):
print('\n----------------')
print('Github: \thttps://github.com/DiscordGSM/DiscordGSM')
print('Discord:\thttps://discord.gg/Cg4Au9T')
print('----------------\n')
self.bot = bot
self.servers = Servers()
self.server_list = self.servers.get()
self.messages = []
self.message_error_count = self.current_display_server = 0
def start(self):
self.print_to_console(f'Starting DiscordGSM v{VERSION}...')
self.query_servers.start()
def cancel(self):
self.query_servers.cancel()
self.print_servers.cancel()
self.presense_load.cancel()
async def on_ready(self):
# set username and avatar
icon_file_name = 'images/discordgsm' + ('DGSM_TOKEN' in os.environ
and '-heroku' or '') + '.png'
with open(icon_file_name, 'rb') as file:
try:
await bot.user.edit(username='******', avatar=file.read())
except:
pass
# print info to console
print('\n----------------')
print(f'Logged in as:\t{bot.user.name}')
print(f'Robot ID:\t{bot.user.id}')
app_info = await bot.application_info()
print(f'Owner ID:\t{app_info.owner.id} ({app_info.owner.name})')
print('----------------\n')
self.print_presense_hint()
self.presense_load.start()
await self.set_channels_permissions()
self.print_to_console(
f'Query server and send discord embed every {REFRESH_RATE} seconds...'
)
await self.refresh_discord_embed()
self.print_servers.start()
# query the servers
@tasks.loop(seconds=REFRESH_RATE)
async def query_servers(self):
server_count = self.servers.query()
self.print_to_console(f'{server_count} servers queried')
# pre-query servers before ready
@query_servers.before_loop
async def before_query_servers(self):
self.print_to_console('Pre-Query servers...')
server_count = self.servers.query()
self.print_to_console(f'{server_count} servers queried')
await self.bot.wait_until_ready()
await self.on_ready()
# send messages to discord
@tasks.loop(seconds=REFRESH_RATE)
async def print_servers(self):
if self.message_error_count < 20:
updated_count = 0
for i in range(len(self.server_list)):
try:
await self.messages[i].edit(
content=('frontMessage' in self.server_list[i] and
self.server_list[i]['frontMessage'].strip())
and self.server_list[i]['frontMessage'] or None,
embed=self.get_embed(self.server_list[i]))
updated_count += 1
except:
self.message_error_count += 1
self.print_to_console(
f'ERROR: message {i} fail to edit, message deleted or no permission. Server: {self.server_list[i]["addr"]}:{self.server_list[i]["port"]}'
)
self.print_to_console(f'{updated_count} messages updated')
else:
self.message_error_count = 0
self.print_to_console(f'Message ERROR reached, refreshing...')
await self.refresh_discord_embed()
# refresh discord presense
@tasks.loop(minutes=PRESENCE_RATE)
async def presense_load(self):
# 1 = display number of servers, 2 = display total players/total maxplayers, 3 = display each server one by one every 10 minutes
if len(self.server_list) == 0:
activity_text = f'Command: {DGSM_PREFIX}dgsm'
if PRESENCE_TYPE <= 1:
activity_text = f'{len(self.server_list)} game servers'
elif PRESENCE_TYPE == 2:
total_activeplayers = total_maxplayers = 0
for server in self.server_list:
server_cache = ServerCache(server['addr'], server['port'])
data = server_cache.get_data()
if data and server_cache.get_status() == 'Online':
total_activeplayers += int(data['players'])
total_maxplayers += int(data['maxplayers'])
activity_text = f'{total_activeplayers}/{total_maxplayers} active players' if total_maxplayers > 0 else '0 players'
elif PRESENCE_TYPE >= 3:
if self.current_display_server >= len(self.server_list):
self.current_display_server = 0
server_cache = ServerCache(
self.server_list[self.current_display_server]['addr'],
self.server_list[self.current_display_server]['port'])
data = server_cache.get_data()
if data and server_cache.get_status() == 'Online':
activity_text = f'{data["players"]}/{data["maxplayers"]} on {data["name"]}' if int(
data["maxplayers"]) > 0 else '0 players'
else:
activity_text = None
self.current_display_server += 1
if activity_text != None:
await bot.change_presence(status=discord.Status.online,
activity=discord.Activity(
name=activity_text, type=3))
self.print_to_console(
f'Discord presence updated | {activity_text}')
# set channels permissions before sending new messages
async def set_channels_permissions(self):
channels = [server['channel'] for server in self.server_list]
channels = list(set(channels)) # remove duplicated channels
for channel in channels:
try:
await bot.get_channel(channel).set_permissions(
bot.user,
read_messages=True,
send_messages=True,
reason='Display servers embed')
self.print_to_console(
f'Channel: {channel} | Permissions: read_messages, send_messages | Permissions set successfully'
)
except:
self.print_to_console(
f'Channel: {channel} | Permissions: read_messages, send_messages | ERROR: Permissions fail to set'
)
# remove old discord embed and send new discord embed
async def refresh_discord_embed(self):
# refresh servers.json cache
self.servers = Servers()
self.server_list = self.servers.get()
# remove old discord embed
channels = [server['channel'] for server in self.server_list]
channels = list(set(channels)) # remove duplicated channels
for channel in channels:
await bot.get_channel(channel).purge(
check=lambda m: m.author == bot.user)
# send new discord embed
self.messages = [
await bot.get_channel(s['channel']).send(
content=('frontMessage' in s and s['frontMessage'].strip())
and s['frontMessage'] or None,
embed=self.get_embed(s)) for s in self.server_list
]
def print_to_console(self, value):
print(datetime.now().strftime('%Y-%m-%d %H:%M:%S: ') + value)
# 1 = display number of servers, 2 = display total players/total maxplayers, 3 = display each server one by one every 10 minutes
def print_presense_hint(self):
if PRESENCE_TYPE <= 1:
hints = 'number of servers'
elif PRESENCE_TYPE == 2:
hints = 'total players/total maxplayers'
elif PRESENCE_TYPE >= 3:
hints = f'each server one by one every {PRESENCE_RATE} minutes'
self.print_to_console(
f'Presence update type: {PRESENCE_TYPE} | Display {hints}')
# get game server discord embed
def get_embed(self, server):
# load server cache
server_cache = ServerCache(server['addr'], server['port'])
# load server data
data = server_cache.get_data()
if data:
# load server status Online/Offline
status = server_cache.get_status()
emoji = (status == 'Online') and ':green_circle:' or ':red_circle:'
if status == 'Online':
if int(data['maxplayers']) <= int(data['players']):
color = discord.Color.from_rgb(240, 71, 71) # red
elif int(data['maxplayers']) <= int(data['players']) * 2:
color = discord.Color.from_rgb(250, 166, 26) # yellew
else:
color = discord.Color.from_rgb(67, 181, 129) # green
try:
if 'color' in server:
h = server['color'].lstrip('#')
rgb = tuple(int(h[i:i + 2], 16) for i in (0, 2, 4))
color = discord.Color.from_rgb(
rgb[0], rgb[1], rgb[2])
except Exception as e:
self.print_to_console(e)
else:
color = discord.Color.from_rgb(32, 34, 37) # dark
title = (data['password'] and ':lock: '
or '') + f'`{data["name"]}`'
custom = ('custom' in server) and server['custom'] or None
if custom and custom.strip():
embed = discord.Embed(title=title,
description=custom,
color=color)
elif server['type'] == 'SourceQuery' and not custom:
embed = discord.Embed(
title=title,
description=
f'Connect: steam://connect/{data["addr"]}:{server["port"]}',
color=color)
else:
embed = discord.Embed(title=title, color=color)
embed.add_field(name=FIELD_STATUS,
value=f'{emoji} **{status}**',
inline=True)
embed.add_field(name=f'{FIELD_ADDRESS}:{FIELD_PORT}',
value=f'`{data["addr"]}:{data["port"]}`',
inline=True)
flag_emoji = ('country' in server) and (
':flag_' + server['country'].lower() +
f': {server["country"]}') or ':united_nations: Unknown'
embed.add_field(name=FIELD_COUNTRY, value=flag_emoji, inline=True)
embed.add_field(name=FIELD_GAME, value=data['game'], inline=True)
embed.add_field(name=FIELD_CURRENTMAP,
value=data['map'],
inline=True)
if status == 'Online':
value = str(data['players']) # example: 20/32
if int(data['bots']) > 0:
value += f' ({data["bots"]})' # example: 20 (2)/32
else:
value = '0' # example: 0/32
embed.add_field(name=FIELD_PLAYERS,
value=f'{value}/{data["maxplayers"]}',
inline=True)
if 'image_url' in server:
image_url = str(server['image_url'])
else:
image_url = (
CUSTOM_IMAGE_URL and CUSTOM_IMAGE_URL.strip()
) and CUSTOM_IMAGE_URL or f'https://github.com/DiscordGSM/Map-Thumbnails/raw/master/{urllib.parse.quote(data["game"])}'
image_url += f'/{urllib.parse.quote(data["map"])}.jpg'
embed.set_thumbnail(url=image_url)
else:
# server fail to query
color = discord.Color.from_rgb(240, 71, 71) # red
embed = discord.Embed(
title='ERROR',
description=f'{FIELD_STATUS}: :warning: **Fail to query**',
color=color)
embed.add_field(name=f'{FIELD_ADDRESS}:{FIELD_PORT}',
value=f'{server["addr"]}:{server["port"]}',
inline=True)
embed.set_footer(
text=
f'DiscordGSM v{VERSION} | 📺Game Server Monitor | Last update: '
+ datetime.now().strftime('%a, %Y-%m-%d %I:%M:%S%p'),
icon_url=
'https://github.com/DiscordGSM/DiscordGSM/raw/master/images/discordgsm.png'
)
return embed
def get_server_list(self):
return self.server_list
servers_json = os.getenv('SERVERS_JSON')
if servers_json and servers_json.strip():
with open('configs/servers.json', 'w') as file:
file.write(servers_json)
# [HEROKU] Check bot token and servers.json valid before start
if 'DGSM_TOKEN' in os.environ:
invite_link = subprocess.run(['python3', 'getbotinvitelink.py'],
stdout=subprocess.PIPE,
shell=False).stdout.decode('utf8')
if 'https://discord.com/api/oauth2/authorize?client_id=' not in invite_link:
while True:
time.sleep(1)
with open('configs/servers.json', 'r') as file:
try:
Servers().get()
except Exception as e:
print(e)
while True:
time.sleep(1)
# env values
VERSION = '1.8.3'
SETTINGS = Settings.get()
DGSM_TOKEN = os.getenv('DGSM_TOKEN', SETTINGS['token'])
DGSM_PREFIX = os.getenv("DGSM_PREFIX", SETTINGS.get('prefix', '!'))
ROLE_ID = os.getenv('ROLE_ID', SETTINGS.get('role_id', '123'))
CUSTOM_IMAGE_URL = os.getenv('CUSTOM_IMAGE_URL', SETTINGS.get('image_url', ''))
REFRESH_RATE = int(os.getenv('REFRESH_RATE', SETTINGS['refreshrate'])) if int(
os.getenv('REFRESH_RATE', SETTINGS['refreshrate'])) > 5 else 5
PRESENCE_TYPE = int(
headers = {}
r = requests.head(target_url,
headers=headers,
allow_redirects=True,
timeout=10)
return {
"url": r.url,
"headers": r.headers
}
while True:
unvisited_links = Links.get_unvisited_links(conn)
if len(unvisited_links) == 0:
print("Nothing to crawl, going to sleep")
time.sleep(5)
continue
for link in unvisited_links:
print("Going to {}".format(link["url"]))
try:
result = head_for_server(link["domain"], link["url"])
print("Got result for {}. It is {}".format(link["url"], result["url"]))
Servers.insert_server(conn, link["link_id"], result["url"], result["headers"]["Server"])
except:
pass
conn.commit()
@sqlite_cache(timeout_seconds=800000, cache_none=False, ignore_args={"query_data"})
def _query(self, msg, query_data):
# print msg
ret = self.whiteListFirst(query_data)
if ret:
return ret
# random select a server
key = sample(self.dns_servers, 1)[0]
# print key
server = self.dns_servers[key]
return server.query(query_data)
if __name__ == "__main__":
ss = Servers()
s = DNSServer("8.8.8.8")
ss.addDNSServer(s)
########NEW FILE########
__FILENAME__ = test
#! /usr/bin/python
# -*- coding: utf-8 -*-
__author__ = "linkerlin"
import sys
import struct
try:
from dns import message as m
except ImportError as ex:
print "cannot find dnspython"
