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))
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