def query():
address = request.args.get("address")
port = int(request.args.get("port"))
conn = MinecraftServer(address, port)
try:
conn.ping()
# except ConnectionRefusedError:
# Commented out because for some reason on the production server,
# attempting to catch this error causes the site to break and display
# 'Internal Server Error'. Logs from such events say that
# 'ConnectionRefusedError' is undefined, although there seem to be no
# issues when testing locally.
except:
response = jsonify({
"status": "Offline",
"players_online": 0,
"player_names": None,
})
else:
q = conn.query()
response = jsonify({
"status": "Online",
"players_online": q.players.online,
"players_max": q.players.max,
"player_names": q.players.names,
})
return response
def index():
"""Index (and only) page of site."""
render_obj = []
message_objects = Message.query.filter_by(display=True).all()
server_objects = Server.query.all()
for server in server_objects:
address = server.address
port = server.port
conn = MinecraftServer(address, port)
try:
conn.ping()
# except ConnectionRefusedError:
# Commented out because for some reason on the production server,
# attempting to catch this error causes the site to break and display
# 'Internal Server Error'. Logs from such events say that
# 'ConnectionRefusedError' is undefined, although there seem to be no
# issues when testing locally.
except:
render_obj.append({
"address": address,
"port": port,
"modpack_version": server.modpack_version,
"client_config": server.client_config,
"status": "Offline",
})
else:
add_to_render = {}
q = conn.query()
motd = q.motd
players = {
"max": q.players.max,
"online": q.players.online,
"names": q.players.names,
}
jar_version = q.software.version
add_to_render.update({
"address": address,
"port": port,
"modpack_version": server.modpack_version,
"client_config": server.client_config,
"status": "Online",
"motd": motd,
"players": players,
"jar_version": jar_version,
})
render_obj.append(add_to_render)
return render_template(
"index.html",
servers=render_obj,
messages=message_objects,
)
def get_latency_or_offline(server_ip):
print("Checking server " + server_ip)
# noinspection PyBroadException
try:
server = MinecraftServer(server_ip)
# MinecraftServer.lookup(server_ip)
latency = server.status(retries=1).latency
print("Server " + server_ip + " is online (latency: " + str(latency) + "ms)")
return True, latency
except Exception as e:
print("Server " + server_ip + " is offline " + str(e))
return False, str(e)
def _init():
config = configparser.ConfigParser()
config.read("config.ini")
hostname = config['DEFAULT']['server']
server = MinecraftServer.lookup(hostname)
return server
async def mcping(self, ctx, *, server: str):
await ctx.trigger_typing()
server = server.replace(" ", "")
if ":" in server:
s = server.split(":")
try:
int(s[1])
except Exception:
await ctx.send(embed=discord.Embed(
color=discord.Color.green(),
description="**" + server +
"** is either offline or unavailable at the moment.\n" +
"Did you type the ip and port correctly? (Like ip:port)\n\nExample: ``"
+ ctx.prefix + "mcping 172.10.17.177:25565``"))
return
if server == "":
await ctx.send(embed=discord.Embed(
color=discord.Color.green(),
description="You must specify a server to ping!"))
return
status = MinecraftServer.lookup(server)
try:
status = status.status()
await ctx.send(embed=discord.Embed(
color=discord.Color.green(),
description=server +
" is online with {0} player(s) and a ping of {1} ms.".format(
status.players.online, status.latency)))
except Exception:
await ctx.send(embed=discord.Embed(
color=discord.Color.green(),
description="**" + server +
"** is either offline or unavailable at the moment.\n" +
"Did you type the ip and port correctly? (Like ip:port)\n\nExample: ``"
+ ctx.prefix + "mcping 172.10.17.177:25565``"))
def query_status(combined_server):
time_before = time()
try:
query = mcstatus.lookup(combined_server).query()
except Exception:
return default
latency = round((time() - time_before) * 1000, 2)
s_dict = default.copy()
s_dict['online'] = True
s_dict['players_online'] = query.players.online
s_dict['players_max'] = query.players.max
s_dict['players_names'] = query.players.names
s_dict['latency'] = latency
s_dict['version'] = {
'brand': None,
'software': query.software.version, # string
'protocol': 'query',
'method': 'query'
}
s_dict['motd'] = query.motd
s_dict['map'] = query.map
s_dict['plugins'] = query.software.plugins
return s_dict
async def minecraft(self, ctx):
"""Get the Minecraft server information."""
server = MinecraftServer.lookup(config.hvc_mc['ip'])
embed = discord.Embed(
title="Minecraft Server",
description="Official Hatventures Community Minecraft server",
colour=0x5A894D,
url=None)
embed.add_field(name="IP", value=config.hvc_mc['ip_name'], inline=True)
embed.add_field(name="Dynmap",
value=config.hvc_mc['dynmap'],
inline=True)
try:
status = server.status()
embed.add_field(name="Version",
value=status.version.name,
inline=True)
embed.add_field(name="Status", value="Online!", inline=True)
embed.add_field(
name="Players",
value=f"{status.players.online}/{status.players.max}",
inline=True)
except Exception as e:
print(e)
embed.add_field(name="Status", value="Offline!")
embed.set_thumbnail(url=config.hvc_mc['icon'])
await ctx.send(embed=embed)
async def server(bot):
await bot.wait_until_ready()
server = MinecraftServer("81.236.213.170", 25565)
while not bot.is_closed:
msg = "Server did not respond"
try:
status = server.status()
except AttributeError:
print("Attribute Error")
except:
print("Uncaught Error")
else:
msg = ("{0} players and {1} ping").format(
status.players.online, math.floor(status.latency))
await bot.change_presence(game=Game(name=msg))
await asyncio.sleep(30)
async def minecraft(self, ctx, ip='emb.ovh:20001', modifier=None):
"""Retrieve Minecraft MOTD's"""
try:
response = json.loads(
str(MinecraftServer.lookup(f"{ip}").query().raw).replace(
"\'", "\""))
mc = discord.Embed(color=0x0080ff)
mc.set_author(
name=f"Minecraft Server: ({ip.upper()})",
icon_url=
"https://static.wikia.nocookie.net/minecraft_gamepedia/images/3/31/Enchanting_Table.gif"
)
mc.add_field(name='MOTD',
value=f"``{response['hostname']}``",
inline=False)
mc.add_field(
name='Statistics',
value=
f"Players: ``{response['numplayers']+'/'+response['maxplayers']}``\nMap: ``{response['map'].capitalize()}``",
inline=True)
mc.add_field(
name='Address',
value=
f"IP: ``{response['hostip']}``\nPORT: ``{response['hostport']}``",
inline=True)
if modifier != None:
mc.add_field(
name='Software',
value=
f"```diff\n- {str(response['plugins']).replace('; ', self.newline+'+ ').replace(': ', ':'+self.newline+'+ ')}```",
inline=False)
await ctx.reply(embed=mc)
except Exception as e:
await ctx.send(f'{e}')
async def status(ctx):
embed = discord.Embed(title=":crossed_swords: Server Status", description="The current situation looks like this.\n", color=0xaaff34)
embed.set_author(name="Minecraft Server Manager")
embed.set_footer(text="As for {}".format(datetime.now().strftime("%H:%M, %m/%d/%Y")))
async with ctx.channel.typing():
if is_online():
minecraft_server = MinecraftServer.lookup(SERVER_HOSTNAME)
minecraft_status = minecraft_server.status()
minecraft_query = minecraft_server.query()
embed.add_field(name="Status", value="Online", inline=False)
embed.add_field(name="Players", value=minecraft_status.players.online)
embed.add_field(name="Ping", value="{} ms".format(round(minecraft_status.latency)))
embed.description += "\n**Players:**"
for player in minecraft_query.players.names:
embed.description += f"\n- {player}"
else:
embed.color = 0xff344a
embed.add_field(name="Status", value="Offline")
await ctx.send(embed=embed)
def get_mc_status(ip):
#check for valid ip
if len(ip.split(":")) == 2:
ip = str(ip)
elif len(ip.split(":")) == 1:
ip = str(ip) + ":25565"
else:
return {"status": -1}
server = MinecraftServer.lookup(ip)
try:
dets = server.status()
out = {
"status":
1,
"colour":
discord.Colour.green(),
"title":
"Minecraft Server Status",
"description":
"Server {0} at {1} is Online\nPlayers : {2}/{3}".format(
dets.description['text'], ip, dets.players.online,
dets.players.max)
}
except:
out = {
"status": 0,
"colour": discord.Colour.red(),
"title": "Minecraft Server Status",
"description": "Server at {0} is currently offline!".format(ip)
}
return out
def button_command():
entry1.get()
text = entry1.get()
root.quit()
try:
while True:
client_id = '819553518234107904' #Put your client ID here
RPC = Presence(client_id)
RPC.connect()
print(
RPC.update(state="uzywajac MCmonitor",
details="Monitoruje swoj serwer",
large_image="logo",
small_image=" ",
large_text="Monitoruje swoj serwer MC!",
buttons=[{
"label": "Pobierz MC monitor!",
"url": "https://google.com"
}],
start=time.time())) # Set the presence
time.sleep(15)
server = MinecraftServer.lookup(text)
status = server.status()
print("Na serwerze gra {0} graczy na pingu {1} ms".format(
status.players.online, status.latency))
sleep(2.00)
except Exception:
print("error")
toaster = ToastNotifier()
toaster.show_toast("Blad serwera!",
"Blad serwera!",
icon_path=None,
duration=60)
async def server(ctx, ip: str, port=None):
if port is None:
port = "25565"
await ctx.trigger_typing()
server = MinecraftServer.lookup(f"{ip}:{port}")
status = server.status()
query = server.query()
member = ctx.message.author
messagebody = ''
msgtime = strftime("%d/%m/%Y [%I:%M:%S %p] (%Z)", localtime())
usermsg = "{0}".format(client.name).replace("'", "")
motd = query.motd.replace("§b§",
"").replace("§f", "").replace("§2", "").replace(
"§a", "").replace("§4", "")
em = discord.Embed(title=motd, description=messagebody, colour=0x2ecc71)
latency = server.ping()
players = "Players: {0}/{1} | Ping: {2}ms | Version: {3}".format(
status.players.online, status.players.max, latency,
query.software.version)
em.add_field(name="Status", value=players)
playerlist = "{0}".format(", ".join(query.players.names))
em.add_field(name="Playerlist", value=playerlist)
em.set_author(name=usermsg, icon_url=client.avatar_url)
em.set_footer(text=msgtime, icon_url=member.avatar_url)
await ctx.message.channel.send(embed=em)
async def mcserver(self, ctx, ip=None, thumbnail=None):
if ip is None: # If no IP set, use default from config.ini
ip = self.config['MINECRAFT']['server_ip']
if thumbnail is None: # If no thumbnail set, use default from config.ini
thumbnail = self.config['MINECRAFT']['server_thumbnail']
try:
server = MinecraftServer.lookup(ip)
query = server.query()
except:
return print('error')
name = query.raw['hostname']
name = re.sub('§.|\[.*', '', name).split('\n')
print('Collected MC server information for ' + name[0].strip())
embed = discord.Embed(title=name[0].strip(),
colour=discord.Colour.blue())
embed.add_field(name='Players',
value=str(query.players.online) + '/' +
str(query.players.max))
embed.add_field(name='Latency', value=str(server.ping()) + ' ms')
embed.add_field(name='Version', value=query.software.version)
embed.add_field(name='MOTD', value=name[1].strip(), inline=False)
embed.add_field(name='Gametype',
value=query.raw['gametype'],
inline=False)
embed.add_field(name='Map', value=query.raw['map'])
embed.add_field(name='Server Type', value=query.software.brand)
embed.set_thumbnail(url=thumbnail)
if query.software.plugins: # Get plugins if any are installed
plugins = query.software.plugins
plugins = ' '.join([str(i) for i in plugins])
embed.add_field(name='Plugins', value=plugins)
if query.players.online > 0: # Gets player names if available
players = '\n'.join(query.players.names[:5])
embed.add_field(name='Current players', value=players)
await ctx.send(embed=embed)
def check(ip, port):
try:
status = MinecraftServer.lookup("{}:{}".format(ip, port)).status(retries=1)
return bool(status)
except (socket.timeout, ConnectionRefusedError, ConnectionResetError, OSError) as e:
print(e)
return False
def connectToServer():
try:
server = MinecraftServer.lookup('127.0.0.1:25565')
server.status()
return server
except:
return -1
def __init__(self):
mc_server_lookup = MinecraftServer.lookup(
f"{setting.minecraft_server_address}")
mc_server_status = mc_server_lookup.status()
mc_server_query = mc_server_lookup.query()
self.mc_server_status = mc_server_status
self.mc_server_query = mc_server_query
async def mc(self, ctx):
self.mc_embed.clear_fields()
for server in self.servers:
try:
status = MinecraftServer.lookup(server['ip']).status()
except (ConnectionRefusedError, socket.timeout):
embed_value = ':x: Server is offline!'
embed_value += '\n\n_ _' if server == self.servers[0] else ''
self.mc_embed.add_field(name=server['desc'],
value=embed_value,
inline=False)
else:
online_players = status.players.online
sample = sorted([
p.name for p in status.players.sample
]) if status.players.sample is not None else []
sample_title = "Online players" if online_players != 1 else "Online player"
sample_txt = ''
if online_players != 0:
diff = online_players - len(sample)
if diff > 0:
sample_txt = ", ".join(sample) + f" et {diff} autre"
sample_txt += "." if diff == 1 else "s."
elif online_players == 1:
sample_txt = sample[0]
else:
sample_txt = ", ".join(
sample[:-1]) + " et " + sample[-1]
embed_value = f':white_check_mark: Server is online!\n\n**{online_players} {sample_title}**\n' + discord.utils.escape_markdown(
sample_txt)
embed_value += '\n\n_ _' if server == self.servers[0] else ''
self.mc_embed.add_field(name=server['desc'],
value=embed_value,
inline=False)
await ctx.send(embed=self.mc_embed)
def serverstatus():
try:
server = MinecraftServer.lookup("10.0.0.202:25565")
status = server.status()
except:
status = "Error.ScrapeMinecraftServer"
return status
def mcb():
# Look up server
server = MinecraftServer.lookup('98.244.54.58:25565')
ip = '{}:{}'.format(server.host, server.port)
# Ping the server
stat = None
rawinfo = None
players = None
try:
ping = server.ping()
except Exception as e:
return 'Server is down :('
else:
stat = 1
if stat == 1:
# Get query info
rawinfo = server.query().raw
players = server.query().players.names
return render_template('mcb.html',
stat=stat,
pnum=int(rawinfo['numplayers']),
names=players,
ver=rawinfo['version'],
ip=ip)
def query_command(self, protocol, caller, source, command, raw_args,
parsed_args):
if len(parsed_args) < 1:
caller.respond("Usage: {CHARS}mcquery <address[:port]>")
address = parsed_args[0]
target = source
if isinstance(source, User):
target = caller
try:
q = MinecraftServer.lookup(address)
status = q.status()
except Exception as e:
target.respond("Error retrieving status: %s" % e)
self.logger.exception("Error retrieving status")
return
servername = status.description
if isinstance(servername, dict):
servername = servername.get("text", "<Unknown server name>")
done = ""
done += "[%s] %s | " % (status.version.name, servername)
done += "%s/%s " % (status.players.online, status.players.max)
if "plugins" in status.raw:
done += "| %s plugins" % len(status.raw["plugins"])
target.respond(done)
if protocol.can_flood and status.players.sample:
players = ", ".join([x.name for x in status.players.sample])
target.respond("Players: %s" % players)
def server_info(address):
BASE = {"code": 200, "name": "OK", "description": "success"}
server = MinecraftServer.lookup(address)
try:
status = server.status()
except Exception:
data = {"address": address, "online": False}
return jsonify({**BASE, **{"response": data}})
online_players = []
if status.players.sample != None:
for player in status.players.sample:
online_players.append({"name": player.name, "uuid": player.id})
data = {
"address": address,
"online": True,
"description": status.description,
"version": {
"name": status.version.name,
"protocol": status.version.protocol
},
"players": {
"online": status.players.online,
"max": status.players.max,
"sample": online_players,
},
"favicon": status.favicon,
}
return jsonify({**BASE, **{"response": data}})
def index(request):
# Get the server
server = MinecraftServer.lookup("www.yourServerHere.com:25565")
# Get the status and query data, requires two calls to get everything.
status = server.status()
query = server.query()
# Create the object to store all the server data.
req = {}
req['playerCount'] = status.players.online
req['maxPlayers'] = status.players.max
req['playerNames'] = query.players.names
req['version'] = query.software.version;
req['motd'] = query.motd;
req['map'] = query.map;
# Package the requested data into the callback for JSONP
callback = request.GET.get('callback', '')
response = json.dumps(req)
response = callback + '(' + response + ');'
return HttpResponse(response, content_type="application/json")
def get_server_status(self, address):
server = MinecraftServer.lookup(address)
try:
status = server.status()
status_dict = {
'online': True,
'motd': {
'clean': [m['text'] for m in status.description['extra']]
},
'players': {
'online':
status.players.online,
'max':
status.players.max,
'list': [p.name for p in status.players.sample]
if status.players.online > 0 else []
},
'hostname': server.host,
'port': server.port,
'software': status.version.name.split(' ')[0],
'version': ' '.join(status.version.name.split(' ')[1:]),
'protocol': status.version.protocol
}
return status_dict
except:
return {
'online': False,
}
async def setup(ctx, ip, port=25565):
if ctx.message.author.guild_permissions.administrator == False:
return await ctx.send("Sorry, you are not a server admin.")
guild = ctx.guild
try:
channel = guild.get_channel(all_status[guild.id][t_ip(ip,port)]["channel"])
return await ctx.send("Sorry, the McStatus you requested already exists.")
except:
pass
try:
server = MinecraftServer.lookup("{0}:{1}".format(ip,port))
status = server.status()
except:
return await ctx.send("Sorry, the server {0}:{1} was offline or not found.".format(ip,port))
category = await ctx.guild.create_category("{0}:{1}".format(ip,port))
channel = await category.create_voice_channel("Server Online ({0}/{1})".format(status.players.online,status.players.max))
everyone = guild.get_role(guild.id)
await channel.set_permissions(everyone, connect=False)
embed=discord.Embed(title="{0}:{1}".format(ip,port), description="Server Online ({0}/{1})".format(status.players.online,status.players.max), color=0x00ff00)
embed.set_author(name="Server Status Created")
await ctx.send(embed=embed)
save(guild, category, channel, ip, port)
def standard_je_ping(self, combined_server):
try:
status = MinecraftServer.lookup(combined_server).status()
except Exception:
return False, 0, None
return True, status.players.online, status.latency
def setserver(update, context):
try:
chat_id = update.message.chat_id
if len(context.args) not in [1,2]:
raise Exception("Enter valid ip and port. Example: /setserver 192.168.0.1 25565")
if len(context.args) == 1:
server = MinecraftServer.lookup(context.args[0])
else:
server = MinecraftServer.lookup(f"{context.args[0]}:{context.args[1]}")
servers[chat_id] = server
except Exception as e:
update.message.reply_text(str(e))
def query_command(self, protocol, caller, source, command, raw_args,
parsed_args):
if len(parsed_args) < 1:
caller.respond("Usage: {CHARS}mcquery <address[:port]>")
address = parsed_args[0]
target = source
if isinstance(source, User):
target = caller
try:
q = MinecraftServer.lookup(address)
status = q.status()
except Exception as e:
target.respond("Error retrieving status: %s" % e)
self.logger.exception("Error retrieving status")
return
servername = status.description
if isinstance(servername, dict):
servername = servername.get("text", "<Unknown server name>")
done = ""
done += "[%s] %s | " % (status.version.name, servername)
done += "%s/%s " % (status.players.online, status.players.max)
if "plugins" in status.raw:
done += "| %s plugins" % len(status.raw["plugins"])
target.respond(done)
if protocol.can_flood and status.players.sample:
players = ", ".join([x.name for x in status.players.sample])
target.respond("Players: %s" % players)
async def on_ready(self):
print("==========[VampirismBot]==========")
discordserver = 0
for guild in self.client.guilds:
if guild.name == "Official Vampirism Server":
discordserver = guild
if discordserver == 0:
print("[ERROR] Vampirism Server not found")
else:
print("\n[INFO] Currently active roles:\n")
for role in discordserver.roles:
print(role.name)
print("\n[INFO] Currently active channels:\n")
for channel in discordserver.channels:
print(channel.name)
print("\n[INFO] VampirismBot loaded")
# Setting Minecraft Server
server = MinecraftServer.lookup("147.135.9.96:25575")
showAuthor = True
while True:
await self.client.change_presence(activity=discord.Game(
name='powered by klemchri.eu'))
await asyncio.sleep(5)
try:
status = server.status()
await self.client.change_presence(activity=discord.Game(
name="Online Players: {}".format(status.players.online)))
await asyncio.sleep(10)
except Exception as e:
print("[ERROR] Service Unavailable")
def __call__(self, ch, method, properties, body):
json_body = json.loads(body)
self.ip = json_body["ip"]
self.port = int(json_body["port"])
try:
ipstr = "{}:{}".format(self.ip, self.port)
status = MinecraftServer.lookup(ipstr).status(retries=2)
if status.players.online > 0:
print("server {} skipped because of {} online players".format(
ipstr, status.players.online))
channel.basic_publish(
exchange='',
routing_key=os.environ['RABBIT_MOTD_QUEUE'],
body=json.dumps({
'ip': self.ip,
'port': int(self.port)
}),
properties=pika.BasicProperties(
delivery_mode=2, # make message persistent
))
except (socket.timeout, ConnectionRefusedError, ConnectionResetError,
OSError):
return
try:
self.connect()
except Exception as e:
self.disconnect(ch, method)
print(e)
return
if self.connection.connected:
self.connection.disconnect(immediate=True)
self.disconnect(ch, method)
def mcping(text):
"""<server[:port]> - gets info about the Minecraft server at <server[:port]>"""
try:
server = MinecraftServer.lookup(text)
except (IOError, ValueError) as e:
return e
try:
s = server.status()
except socket.gaierror:
return "Invalid hostname"
except socket.timeout:
return "Request timed out"
except ConnectionRefusedError:
return "Connection refused"
except ConnectionError:
return "Connection error"
except (IOError, ValueError) as e:
return "Error pinging server: {}".format(e)
latency = round(s.latency)
if isinstance(s.description, dict):
description = format_colors(" ".join(s.description["text"].split()))
else:
description = format_colors(" ".join(s.description.split()))
return "{}\x0f - \x02{}\x0f - \x02{}ms\x02" \
" - \x02{}/{}\x02 players".format(description, s.version.name, latency,
s.players.online, s.players.max).replace("\n", "\x0f - ")
async def server(ctx):
server = MinecraftServer.lookup('stankyleg.us.to')
status = server.status()
await ctx.send("The server has {0} players and replied in {1} ms".format(
status.players.online, status.latency))
async def mcstatusloop():
global all_status
await client.wait_until_ready()
while True:
servers = []
for guild in all_status:
for ip in all_status[guild]:
servers.append(ip)
servers = list(set(servers))
await client.change_presence(activity=discord.Activity(type=discord.ActivityType.watching, name="{} Minecraft Servers".format(len(servers))))
for guild in all_status:
for full_ip in all_status[guild]:
try:
server = MinecraftServer.lookup("{0}".format(full_ip))
status = server.status()
channel_name = "Server Online ({0}/{1})".format(status.players.online,status.players.max)
channel = client.get_channel(all_status[guild][full_ip]["channel"])
await channel.edit(name=channel_name)
except:
channel = client.get_channel(all_status[guild][full_ip]["channel"])
await channel.edit(name="Server Offline")
await asyncio.sleep(30)
async def on_message(message):
if message.author == client.user:
return
if message.content == '!mcserver':
for hostname in hostnames:
try:
server = MinecraftServer.lookup(hostname)
query = server.query()
status = server.status()
if query.players.names == []:
response = (
f"{hostname} is online with {query.players.online}"
f" players and a latency of {status.latency}ms")
else:
response = (
f"{hostname} is online with {query.players.online}: "
f"{query.players.names} and a latency: {status.latency}ms"
)
except timeout:
response = f"{hostname} is offline"
except Exception as e:
response = f"bot encountered exception {e}"
await message.channel.send(response)
def mcping(text):
"""<server[:port]> - gets info about the Minecraft server at <server[:port]>"""
try:
server = MinecraftServer.lookup(text)
except (IOError, ValueError) as e:
return e
try:
s = server.status()
except socket.gaierror:
return "Invalid hostname"
except socket.timeout:
return "Request timed out"
except ConnectionRefusedError:
return "Connection refused"
except ConnectionError:
return "Connection error"
except (IOError, ValueError) as e:
return "Error pinging server: {}".format(e)
if isinstance(s.description, dict):
description = format_colors(" ".join(s.description["text"].split()))
else:
description = format_colors(" ".join(s.description.split()))
if s.latency:
return "{}\x0f - \x02{}\x0f - \x02{:.1f}ms\x02" " - \x02{}/{}\x02 players".format(
description, s.version.name, s.latency, s.players.online, s.players.max
).replace("\n", "\x0f - ")
else:
return "{}\x0f - \x02{}\x0f" " - \x02{}/{}\x02 players".format(
description, s.version.name, s.players.online, s.players.max
).replace("\n", "\x0f - ")
def print():
server = MinecraftServer.lookup('gaia')
# 'ping' is supported by all Minecraft servers that are version 1.7 or higher.
# It is included in a 'status' call, but is exposed separate if you do not require the additional info.
latency = server.ping()
return 'The server replied in {0} ms'.format(latency)
async def server_status(args=None,client=None):
try:
server = MinecraftServer.lookup(connections['minecraft_ip']+':'+connections['minecraft_port'])
status = server.status()
return "the bifrost currently has {} players".format(status.players.online)
except Exception :
return "there has been an error, maybe the server is down"
def ping(self):
try:
server = MinecraftServer.lookup(self.ip)
status = server.status()
return status
except timeout:
return "Server Ded"
def getStatus(self):
prop = self.getProperties()
port = prop["server-port"]
host = prop["server-ip"]
if not host:
host = "127.0.0.1"
print(port, host)
return MinecraftServer.lookup(host + ":" + port).status()
def minecraft_test(server_info, extra):
try:
server = MinecraftServer.lookup(server_info)
server.status()
return True
except Exception as e:
print e
return False
def query_server(server):
"""Query the minecraft server"""
server = MinecraftServer.lookup(server)
try:
response = server.query()
except socket.timeout:
return None
else:
return response
def minecraft_status (bot, msg):
server = MinecraftServer.lookup("minecraft.westsixth.net:25565")
query = server.query()
if not query.players.names:
bot.say(msg.channel, "Nobody is on :-(")
bot.say(msg.channel, "The server is running version {0} at the moment.".format("".join(query.software.version)))
else:
bot.say(msg.channel, "The following people are on: {0}".format(", ".join(query.players.names)))
bot.say(msg.channel, "The server is running version {0} at the moment.".format("".join(query.software.version)))
async def __call__(self, client, message):
ip = message.content.split(' ')[1]
server = MinecraftServer.lookup(ip)
try:
status = server.status()
await client.send_message(message.channel, '**{0}**: {1} players online. Running {2}'.format(
ip, status.players.online, status.version.name))
except socket.gaierror:
await client.send_message(message.channel, 'Cannot reach server.')
def get_players(address):
if not address:
return []
print "Connecting to {}".format(address)
server = MinecraftServer.lookup(address)
resp = server.status()
try:
return [p.name for p in resp.players.sample]
except TypeError:
return []
def do_GET(self):
self.send_response(200)
self.send_header('Content-type','text/html')
self.end_headers()
if self.path.translate(None, "/") in Config.keys():
server = MinecraftServer.lookup(Config[self.path.translate(None, "/")])
status = server.status()
result = {'online': status.players.online, 'latency': status.latency}
self.wfile.write(json.dumps(result))
else:
self.wfile.write("Failed")
def index(request):
try:
server = MinecraftServer.lookup(settings.MC_HOST)
status = server.status()
query = server.query()
except:
status = None
query = None
user = Account.objects.all()
top_m = Fe.objects.order_by("-money").exclude(name__contains="-")
return render(request, "portal/index.html", {"status": status, "query": query, "top_m": top_m, "user": user})
def bot_online(bot, update, args):
"""Ónline function to check status of a Minecraft server"""
try:
chat_id = update.message.chat_id
address = args[0]
server = MinecraftServer(address)
status = server.status()
bot.sendMessage(
chat_id=chat_id,
text=("{0} ({1}) v{2} {3}ms Players online {4}/{5}".format(
status.description,
address,
status.version.name,
status.latency,
status.players.online,
status.players.max
)))
except IndexError:
bot.sendMessage(chat_id=chat_id, text=onlinetext)
except OSError:
bot.sendMessage(chat_id=chat_id, text=onlinetext)
def check(self, textkey, data, config):
server = MinecraftServer.lookup("localhost:25565")
srv = server.status()
players = srv.players.online
latency = server.ping()
if textkey == 'players':
return players
elif textkey == 'latency':
return latency
return 0
def updateOnlineServers(self):
connection = sqlite3.connect("servers.db")
cursor = connection.cursor()
ports = AnalyzeData.getPorts()
for x in ports:
name="node" + str(x)
try:
server = MinecraftServer.lookup("127.0.0.1:" + str(x))
status = server.ping()
except timeout:
cursor.execute("UPDATE server_running SET running=? WHERE name=?", (False,name))
connection.commit()
connection.close()
def check_upstate():
data = {}
# If the app has been started in debug mode, return dummy data.
if app.debug:
data["online"] = True
data["players_online"] = ["testname1", "testname2"]
data["players_max"] = 20
data["version"] = "CraftBukkit 1.8.8"
data["plugins"] = ["WorldEdit", "WorldGuard"]
return json.dumps(data)
# Otherwise, an actual server query should be made.
server = MinecraftServer("localhost", 25565)
try:
query = server.query()
data["online"] = True
data["players_online"] = query.players.names
data["players_max"] = query.players.max
data["version"] = query.software.brand
data["plugins"] = query.software.plugins
except:
data["online"] = False
return json.dumps(data)
def status(bot, trigger):
"""
.status <server> - Grabs information about a minecraft server!
"""
try:
server = MinecraftServer.lookup(trigger.group(3).strip())
except Exception:
bot.say(u'[MCS] Unable to find a Minecraft server running at \'{}\''.format(trigger.group(3).strip()))
try:
status = server.status()
desc = ' '.join(re.sub(u'\u00A7.', '', status.description).split())
bot.say(u'[MCS] {0} | {1} players | {2} ms | {3}'.format(trigger.group(3).strip(), status.players.online, status.latency, desc))
except Exception as e:
bot.say(u'[MCS] Unable to fetch info from \'{}\' ({})'.format(trigger.group(3).strip(), e))
def getMCStats():
global server_status
global server_status_time
server = MinecraftServer("localhost", 25565)
try:
javaProcess = getJavaProcess()
query = server.query()
status = server.status()
except (subprocess.CalledProcessError, socket.gaierror, ConnectionRefusedError, BrokenPipeError, socket.timeout):
if server_status is not None:
return {"online": server_status}
else:
return {"online": "offline"}
javaMemory = javaProcess.memory_info().rss
javaMemory = toSi(javaMemory, 1024)
javaCPU = javaProcess.cpu_percent()
size = subprocess.check_output("du -sh {}".format(PATH), shell=True)
size_rx = re.search("^(.*?)(.)\t", size.decode("UTF-8", errors="replace"))
size = size_rx.group(1) + " " + size_rx.group(2)
resp = query.raw
resp["online"] = "online"
resp["players"] = query.players.names
resp["latency"] = status.latency
resp["minecraft_RAM"] = javaMemory
resp["minecraft_CPU"] = javaCPU
resp["minecraft_HDD"] = size
if server_status == "stopping":
resp["online"] = server_status
return resp
def index():
# Server IPs
lobby_ip = '50.116.56.173:25565'
# Fetch Server Data
server = MinecraftServer.lookup(lobby_ip)
status = server.status()
# latency = server.ping()
# query = server.query()
lobby_players = status.players.online
return render_template("index.html", count=lobby_players)
def check_status():
global bad_latency_time, last_bad_latency_time, offline_time, last_offline_time, latency
try:
server = MinecraftServer.lookup(SERVER_IP)
status = server.status()
print("Server Latency: " + str(status.latency))
latency = status.latency
offline_time = None
if latency < MAX_LATENCY:
bad_latency_time = None
elif bad_latency_time is None:
bad_latency_time = int(round(time.time() * 100))
except Exception:
print("Server Offline")
if offline_time is None:
offline_time = int(round(time.time() * 100))
def status(hostname, port=25565):
server = MinecraftServer.lookup("{0}:{1}".format(hostname, port))
status = server.status()
ping = server.ping()
players = []
if status.players.sample != None:
players = [p.name for p in status.players.sample]
return jsonify (
hostname=hostname,
port=port,
description=status.description,
version=status.version.name,
players_online=status.players.online,
players_max=status.players.max,
players=','.join(players),
ping=ping
)
def __init__(self, name, initialize = False):
self.id = config["Servers"][name]["ID"]
self.name = name
self.minRam = config["Servers"][name]["MinRAM"]
self.maxRam = config["Servers"][name]["MaxRAM"]
self.fileName = config["Servers"][name]["FileName"]
self.directory = config["Servers"][name]["Directory"]
self.stopCommands = config["Servers"][name]["StopCommands"]
self.description = config["Servers"][name]["Description"]
self.serverIp = config["Servers"][name]["IP"]
self.port = config["Servers"][name]["Port"]
self.runningInfo = serverStatus.lookup("{0}:{1}".format(self.serverIp,self.port))
if initialize:
self._initialize()
if not self.checkRunning(2):
raise DsmmError("Unable to initialize")
else:
self.screen = Screen(self.name)
return
def status(bot, trigger):
"""
.status <server> - Grabs information about a minecraft server!
"""
try:
server = MinecraftServer.lookup(trigger.group(3).strip())
except Exception:
bot.say(u'[MCS] Unable to find a Minecraft server running at \'{}\''.format(trigger.group(3).strip()))
try:
status = server.status()
desc = ' '.join(re.sub(u'\u00A7.', '', status.description).split())
bot.say(u'[MCS] {0} | {1} players | {2} ms | {3}'.format(trigger.group(3).strip(), status.players.online, status.latency, desc))
except Exception as e:
try:
raw = web.get('http://minespy.net/api/serverping/' + str(server.host) + ':' + str(server.port))
status = json.loads(raw)
bot.say(u'[MCS] {0} | {1} players | {2} ms | {3}'.format(trigger.group(3).strip(), str(status['online']), str(status['latency']), str(status['strippedmotd'])))
except Exception as e:
bot.say(u'[MCS] Unable to fetch info from \'{}\' ({})'.format(trigger.group(3).strip(), e))
def players():
server_info = "52.207.3.215:25565"
data = {}
data["server"] = server_info
# If you know the host and port, you may skip this and use MinecraftServer("example.org", 1234)
try:
server = MinecraftServer.lookup(server_info)
status = server.status()
except Exception as e:
print e
data["error"] = str(e)
return jsonify(data)
# 'status' is supported by all Minecraft servers that are version 1.7 or higher.
print "status",server.status()
data["status.latency.ms"] = status.latency
data["currently_online"] = status.players.online
print("The server has {0} players and replied in {1} ms".format(status.players.online, status.latency))
if status.players.online > 0:
print status.players.stu[u'sample']
data["players"] = []
for p in status.players.stu[u'sample']:
data["players"].append(p[u'name'])
print "data",data
# 'ping' is supported by all Minecraft servers that are version 1.7 or higher.
# It is included in a 'status' call, but is exposed separate if you do not require the additional info.
latency = server.ping()
data["server.latency.ms"] = str(latency)
print("The server replied in {0} ms".format(latency))
# 'query' has to be enabled in a servers' server.properties file.
# It may give more information than a ping, such as a full player list or mod information.
# query = server.query()
# print("The server has the following players online: {0}".format(", ".join(query.players.names)))
return jsonify(data)
def mcping(text, notice, nick):
"""<server[:port]> - gets info about the Minecraft server at <server[:port]>"""
if getTokens(nick) < 100:
notice("You don't have enough tokens to do a mcping... Help a little more !")
return None
else:
takeTokens(10, nick, notice)
try:
server = MinecraftServer.lookup(text)
except (IOError, ValueError) as e:
return e
try:
s = server.status()
except socket.gaierror:
return "Invalid hostname"
except socket.timeout:
return "Request timed out"
except ConnectionRefusedError:
return "Connection refused"
except ConnectionError:
return "Connection error"
except (IOError, ValueError) as e:
return "Error pinging server: {}".format(e)
if isinstance(s.description, dict):
description = format_colors(" ".join(s.description["text"].split()))
else:
description = format_colors(" ".join(s.description.split()))
if s.latency:
return "{}\x0f - \x02{}\x0f - \x02{:.1f}ms\x02" \
" - \x02{}/{}\x02 players".format(description, s.version.name_clean, s.latency,
s.players.online, s.players.max).replace("\n", "\x0f - ")
else:
return "{}\x0f - \x02{}\x0f" \
" - \x02{}/{}\x02 players".format(description, s.version.name_clean,
s.players.online, s.players.max).replace("\n", "\x0f - ")
def check_server(self, addr):
mc_server = MinecraftServer.lookup(addr)
query = None
status = None
try:
query = mc_server.query()
except socket.timeout:
try:
status = mc_server.status()
except socket.timeout:
print("Cannot reach server {}".format(addr))
except ConnectionRefusedError:
print("Connection refused")
except ConnectionRefusedError:
print("Connection refused")
if query is not None:
return query
elif status is not None:
return status
else:
return None
