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