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, )
class mcStatus: def __init__(self): self.mc = MinecraftServer('localhost',25565) self.username = "******" self.process_name = "java" self.cmd_query = "server.jar" self.stime = None def ping(self): try: self.mc.ping() return True except: return False def find_proc(self): ps = [] for p in psutil.process_iter(["username","name","cmdline","pid","create_time"]): if self.username == p.info['username']: if self.process_name == p.info['name']: if self.cmd_query in p.info['cmdline']: ps.append((p.info['pid'], p.info['create_time'])) if len(ps) == 0: return None elif len(ps) == 1: self.stime = int(time() - ps[0][1]) return ps[0][0] # to define custom Exception need class raise Exception('More than one server process found PIDs: {}'.format(str(ps))) def tmux(self):
def main(): parser = argparse.ArgumentParser(description='arguments') parser.add_argument('--serverAddress', type=str) parser.add_argument('--serverPort', type=int) parser.add_argument('--game', type=str) parser.add_argument('--gameType', type=str) parser.add_argument('--name', type=str) parser.add_argument('--rconpw', type=str, default="None") args = parser.parse_args() ip = requests.get('http://169.254.169.254/latest/meta-data/public-ipv4').text while True: if args.game in ('soldat', 'gmod', 'valheim'): import valve.source.a2s from valve.source import NoResponseError try: SERVER_ADDRESS = (args.serverAddress, args.serverPort) with valve.source.a2s.ServerQuerier(SERVER_ADDRESS) as server: server.info() # need to genericize this documentStore(args.game, args.gameType, args.name, ip) break except NoResponseError: time.sleep(5) print('No response yet!') elif args.game == 'factorio': import factorio_rcon from factorio_rcon.factorio_rcon import RCONConnectError try: factorio_rcon.RCONClient(args.serverAddress, args.serverPort, args.rconpw, timeout=5) documentStore(args.game, args.gameType, args.name, ip) break except RCONConnectError: print('No response yet!') time.sleep(5) elif args.game == 'minecraft': from mcstatus import MinecraftServer try: SERVER_ADDRESS = [args.serverAddress, args.serverPort] server = MinecraftServer(SERVER_ADDRESS[0], SERVER_ADDRESS[1]) server.ping() documentStore(args.game, args.gameType, args.name, ip) break except Exception as e: time.sleep(5) print('No response yet! However, {}'.format(e))
class minecraftStatus(models.Model): # TODO: add query to get online player usernames def __init__(self): self.server = MinecraftServer("minecraft-1", 25565) def reload(self): try: self.ping() self.status() self.onlinePlayers() return True except Exception as e: self.error = e return False def status(self): raw = self.server.status().raw self.description = raw['description']['text'] self.players = raw['players']['online'] self.version = raw['version']['name'] def onlinePlayers (self): self.playerNames = self.server.query().players.names def ping(self): self.latency = self.server.ping() def get_absolute_url(self): """Returns the url to access a particular instance of MyModelName.""" return reverse('model-detail-view', args=[str(self.id)])
def worker(num, q_in, q_out): while q_in.qsize() > 0: ip, port = q_in.get() logging.debug("[Process %d] received %s to process" % (num, ip)) try: server = MinecraftServer(ip, port) latency = int(server.ping()) status = server.status() s_result = dict(ip=ip, port=port, latency=latency, version=status.version.name, p_online=status.players.online, p_max=status.players.max) q_out.put(s_result) except Exception as e: logging.debug("[Process %d] %s mcstatus exception: %s" % (num, ip, e))
def mcstatus_ping(): global server server = MinecraftServer(server_name,server_port) latency = server.ping() if (latency.returncode == 0): logging.debug('The ping was successful.') logging.info('The ping time was %s ms.',latency) return 0 else: #If the ping is unsuccessful, increment the error count. logging.warning("The ping was unsuccessful. Server is offline or not responding to ping.") error_count = error_count + 1 logging.warning("Incrementing Error Count to %s.", error_count) return 1
def server_status(port, variant): if variant is None: variant = 'status' try: if variant == 'ping' or variant == 'status' or variant == 'query' or variant == 'test': server = MinecraftServer('127.0.0.1', port) if variant == 'ping': pyprint("Ping: %sms" % server.ping()) elif variant == 'status': s = server.status() f = 'x' if s.favicon is None else '^_^' description = format_strip(s.description) if isinstance( s.description, str) else format_strip( s.description['text']) sample = s.players.sample if sample is None: if s.players.online > 0: sample = "<Hidden>" else: sample = "<None>" pyprint("Status returned:\n" " - ping: %s ms [%s]\n" " - version: %s (protocol %s)\n" " - description: %s\n" " - players (%s/%s): %s" % (s.latency, f, s.version.name, s.version.protocol, description, s.players.online, s.players.max, sample)) elif variant == 'query': s = server.query() pyprint( "Query returned:\n" " - game: %s (%s)\n" " - ip: %s:%s\n" " - version: %s (%s)\n" " - description: %s\n" " - map: %s\n" " - plugins: %s\n" " - players (%s/%s): %s" % (s.raw['game_id'], s.raw['gametype'], s.raw['hostip'], s.raw['hostport'], s.software.version, s.software.brand, format_strip(s.motd), s.map, s.software.plugins, s.players.online, s.players.max, s.players.names)) except ConnectionRefusedError: pyprint("Could not connect to the server!", 3) except ConnectionResetError: pyprint("Query is not enabled on the server!", 3) except IOError: pyprint("Server is not ready yet!", 3)
from mcstatus import MinecraftServer # If you know the host and port, you may skip this and use MinecraftServer("example.org", 1234) # server = MinecraftServer.lookup("bcsn.us:25565") server = MinecraftServer("184.18.202.133:25565") # 'status' is supported by all Minecraft servers that are version 1.7 or higher. status = server.status() print("The server has {0} players and replied in {1} ms".format(status.players.online, status.latency)) # '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() 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)))
# This file is © TheBloodyscreen # It was created as part of the Minecraft Controller project in May of 2019 # If you want to use all or part of the code in this file, # please contact [email protected] from mcrcon import MCRcon from config import config from bloodyterminal import btext from mcstatus import MinecraftServer from rcon import Rcon # inits and stuffs colorCodes = [ "§1", "§4", "§c", "§6", "§e", "§2", "§a", "§b", "§3", "§9", "§d", "§5", "§f", "§7", "§8", "§0", "§r", "§l", "§o", "§n", "§m", "§k" ] # list of every available stylization for removal later server = MinecraftServer(config["serverIP"], config["serverPORT"]) status = server.status() description = status.description["text"] for color in colorCodes: # removing stylization from minecraft motd for better readability description = description.replace(color, "") ping = server.ping() image = status.favicon version = status.version.name worldName = server.query().map playersMax = server.query().players.max playersOnline = server.query().players.names playersOnlineAmount = server.query().players.online if __name__ == '__main__': pass
from mcstatus import MinecraftServer # If you know the host and port, you may skip this and use MinecraftServer("example.org", 1234) server = MinecraftServer("localhost", 25565) # 'status' is supported by all Minecraft servers that are version 1.7 or higher. status = server.status() print("The server has {0} players and replied in {1} ms".format(status.players.online, status.latency)) # '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() 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. qserver = MinecraftServer("127.0.0.1", 25566) query = qserver.query() print("The server has the following players online: {0}".format(", ".join(query.players.names)))
class MinecraftCommandModule(BaseCommandModule): def __init__(self, *, minecraft_host: str, minecraft_port: int): super().__init__() self.name = "MinecraftCommandModule" self.keywords = ["minecraft", "mc"] self.description = "Minecraft related commands for Gothbot" self.help_embed = self.generate_help_embed( title="Gothbot Minecraft Module", description=self.description, aliases=self.keywords, commands=[ ("help", "Prints this help box"), ("ping", "Checks if minecraft server is up"), ("players", "Checks who is online"), ("ip", "Prints the current IP for the server"), ], ) self.command_prefix = os.environ["COMMAND_PREFIX"] self.host = minecraft_host self.port = minecraft_port self.ip_string = self.host if self.port == 25565 else f"{self.host}:{self.port}" self.server = MinecraftServer(self.host, self.port) async def handle(self, message: discord.Message): segments = message.content.split(" ", 3) if len(segments) == 2: await self._handle_help(message.channel) return command = segments.pop() if command == "help": await self._handle_help(message.channel) elif command == "ping": await self._handle_ping(message.channel) elif command == "ip": await self._handle_ip(message.channel) elif command == "players": await self._handle_players(message.channel) else: await message.channel.send( f"Unknown command. Type `{self.command_prefix} {self.keywords[0]} help` to see available commands" ) async def _handle_help(self, channel: discord.TextChannel): logger.debug("Handling minecraft help request") await channel.send(embed=self.help_embed) async def _handle_ping(self, channel: discord.TextChannel): logger.debug("Handling minecraft ping request") message = f"`{self.ip_string}` appears to be down" try: latency = self.server.ping() message = f"`{self.ip_string}` is up and replied in {latency} ms" except Exception: pass await channel.send(message) async def _handle_ip(self, channel: discord.TextChannel): logger.debug("Handling minecraft ip request") await channel.send(f"The current minecraft ip is `{self.ip_string}`") async def _handle_players(self, channel: discord.TextChannel): logger.debug("Handling minecraft player request") message = f"Could not fetch players for `{self.ip_string}`" try: query = self.server.query() if query.players.names: message = f"`{self.ip_string}` has the following players online: {', '.join(query.players.names)}" else: message = f"`{self.ip_string}` has no players online" except Exception: pass await channel.send(message)
class MyClient(discord.Client): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) async def on_ready(self): print('Logged in as') print(self.user.name) print(self.user.id) print('------') self.channel = self.get_channel(int( os.environ['DISCORD_CHANNEL'])) # channel ID goes here self.mine_manager = os.environ["MINE_MANAGER"] self.mc_server = MinecraftServer(os.environ['MC_SERVER']) # await self.channel.send(WELCOME_MSG) activity = discord.CustomActivity("Miners: {}".format(0)) await self.change_presence(status=discord.Status.idle, activity=activity) self.mc_is_up = True self.user_count = 0 self.current_players = set() # create the background task and run it in the background self.bg_task = self.loop.create_task(self.my_background_task()) async def my_background_task(self): await self.wait_until_ready() while not self.is_closed(): await self.check_server_up() if self.is_up: await self.check_user_count() await self.check_shifts() await asyncio.sleep(15) # task runs every 15 seconds async def check_server_up(self): change = False is_up = False # for i in range(0,3): try: ping = self.mc_server.ping() is_up = True except: pass change = self.mc_is_up != is_up if change: if is_up: # server came online await self.channel.send(SERVER_UP) else: await self.channel.send(SERVER_DOWN.format(self.mine_manager)) self.is_up = is_up async def check_user_count(self): try: status = self.mc_server.status() except: return count = status.players.online change = count != self.user_count if change: status = discord.Status.online if count == 0: status = discord.Status.idle activity = discord.CustomActivity("Miners {}".format(count)) await self.change_presence(status=status, activity=activity) async def check_shifts(self): try: query = self.mc_server.query() except: return current_players = set(query.players.names) diff = current_players - self.current_players self.current_players = current_players if len(diff) > 0: for p in diff: await self.channel.send(random.choice(LOGIN_MSG).format(p))