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 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()
result = dict(
ip=ip,
port=port,
latency=latency,
version=status.version.name,
p_online=status.players.online,
p_max=status.players.max,
motd=status.description,
)
q_out.put(result)
except Exception as e:
logging.debug("[Process %d] %s mcstatus exception: %s" %
(num, ip, e))
async def printStatus():
"""Print the updating status to the console."""
await client.wait_until_ready()
while not client.is_closed():
mcServer = MinecraftServer(cIP, cPort)
serverStatus = mcServer.status()
if cEnableNames is True and '{1}' in cMessageSend and serverStatus.players.online != 0:
mcQuery = mcServer.query()
if serverStatus.players.online == 1:
print('{0} Player :: {2} :: {1}'.format(serverStatus.players.online, ", ".join(mcQuery.players.names), getTime()))
else:
print('{0} Players :: {2} :: {1}'.format(serverStatus.players.online, ", ".join(mcQuery.players.names), getTime()))
else:
if serverStatus.players.online == 1:
print('{0} Player :: {1}'.format(serverStatus.players.online, getTime()))
else:
print('{0} Players :: {1}'.format(serverStatus.players.online, getTime()))
await asyncio.sleep(int(cRefresh))
def is_minecraft(host, check_population=False, check_version=None):
try:
server = MinecraftServer(host, 25565)
status = server.status()
players = status.players
if check_population:
if players.online == 0:
return None
if check_version is not None:
if check_version not in status.version.name:
return
try:
description = status.description['text']
except (TypeError, KeyError) as e:
if isinstance(e, KeyError):
description = status.description['translate']
else:
description = status.description
try:
description = re.sub(r'§.|\n', '', description)
except TypeError as e:
print(type(description))
print(description)
description = ' '.join(description.split())
return {
'description': description,
'version': status.version.name,
'players': f'{players.online}/{players.max}',
'host': server.host
}
except (socket.timeout, ConnectionRefusedError, OSError) as e:
pass
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)
def main():
hostname = socket.gethostname()
report_url = os.environ['REPORT_ROOMS_URL']
if not report_url:
raise Exception('REPORT_ROOMS_URL env var should be set')
# retry until started
while 1:
try:
# If you know the host and port, you may skip this and use MinecraftServer("example.org", 1234)
server = MinecraftServer("127.0.0.1", 25565)
while 1:
# 'status' is supported by all Minecraft servers that are version 1.7 or higher.
status = server.status()
print("[{2}] The server has {0} players and replied in {1} ms".format(
status.players.online,
status.latency,
time.strftime("%d.%m.%Y %H:%M:%S")))
req = urllib2.Request(report_url)
data = {
'nodes' : [
{
'nodeId': hostname,
'rooms': status.players.online
}
]
}
req.add_header('Content-Type', 'application/json')
response = urllib2.urlopen(req, json.dumps(data))
print('Reported server rooms: {0}'.format(response.info()))
sleep(5)
except Exception:
type, value, traceback = sys.exc_info()
print("Failed to connect to server {0}. Retrying".format(value))
sleep(1)
async def status(ctx: commands.Context):
"""Get the status of the server"""
server = get_volume().server
if server is not None:
ip = server.public_net.ipv4.ip
if server.status == 'running':
async with ctx.channel.typing():
try:
mc = MinecraftServer(ip)
status = mc.status()
await ctx.channel.send(
f"Minecraft server running at `{ip}`\r\n"
f"{status.description['text']} | "
f"{status.players.online}/{status.players.max} "
f"| {status.version.name}")
except Exception as e:
await ctx.channel.send(
f"Server running at `{ip}` but could not read Minecraft status:\r\n`{e}`"
)
else:
await ctx.channel.send(f"Server `{server.status}` at `{ip}`")
else:
await ctx.channel.send(f"No server active")
def get_player_list(address, port):
server = MinecraftServer(address, port=25565)
players = server.query()
return players.players.names
def get_status(address, port):
server = MinecraftServer(address, port=25565)
return server.status()
# 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 flask import Flask
from mcstatus import MinecraftServer
from pprint import pprint
htmlOnline = open("online.html").read()
htmlOffline = open("offline.html").read()
js = open("script.js").read()
css = open("style.css").read()
server = MinecraftServer("mc.spidunno.gq", 25565)
pprint((server.host))
onlinePlayers = ''
motd = ''
arr = []
arr2 = []
onlinePlayers = ''
# 'status' is supported by all Minecraft servers that are version 1.7 or higher.
status = server.status()
pprint((status.description['extra']))
if status.players.sample == None:
onlinePlayers = 'None'
else:
for i in range(len(status.players.sample)):
arr.append(str(status.players.sample[i].name))
onlinePlayers = ', '.join(arr)
print(onlinePlayers)
app = Flask('app')
def __init__(self, bot, channel_server_mapping):
self.bot = bot
self.channel_server_mapping = {
channel: MinecraftServer(server)
for channel, server in channel_server_mapping.items()
}
import sys
from mcstatus import MinecraftServer
server = MinecraftServer('minecraft.baffqd.com', 25565)
status = server.status()
print(status.players.online, end='')
sys.stdout.flush()
async def mcpe(self, ctx, server, port=19132):
try:
srv = MinecraftServer(f"{server}", int(port))
motd = srv.query()
except Exception:
embed_error = discord.Embed(
color=self.bot.embed_color,
title="→ Timeout Error:",
description=
"• The server is offline or you entered invalid information!")
await ctx.send(embed=embed_error)
else:
players_string = ", ".join(str(p) for p in motd.players.names)
plugins_string = ", ".join(str(l) for l in motd.software.plugins)
players_string_hastebin = ", \n".join(
str(p) for p in motd.players.names)
plugins_string_hastebin = ", \n".join(
str(l) for l in motd.software.plugins)
players_post = requests.post(
"https://hasteb.in/documents",
data=players_string_hastebin.encode('utf-8'))
hastebin_players_link = f"https://hasteb.in/{players_post.json()['key']}"
plugins_post = requests.post(
"https://hasteb.in/documents",
data=plugins_string_hastebin.encode('utf-8'))
hastebin_plugins_link = f"https://hasteb.in/{plugins_post.json()['key']}"
embed = discord.Embed(color=self.bot.embed_color,
title="→ Minecraft Bedrock Command")
embed.add_field(name="• IP Address:",
inline=True,
value=f"`{server}`")
embed.add_field(name="• Port:", inline=True, value=f"`{port}`")
embed.add_field(
name="• Players:",
inline=True,
value=f"`{len(motd.players.names)}/{motd.players.max}`")
embed.add_field(name="• Map:", inline=True, value=f"`{motd.map}`")
embed.add_field(name="• Software:",
inline=True,
value=f"`{motd.software.brand}`")
embed.add_field(name="• MOTD:",
inline=True,
value=f"`{motd.motd}`")
embed.add_field(name="• Version:",
inline=False,
value=f"`{motd.software.version}`")
if not len(motd.players.names):
embed.add_field(
name="• Player names:",
inline=False,
value="`No Player Information / No Players Online!`")
elif len(players_string) > 1024:
players_string = players_string[:1018]
players_string, _, _ = players_string.rpartition(', ')
players_string = '`' + players_string + '...`'
embed.add_field(name="• Player names:",
inline=False,
value=players_string)
else:
embed.add_field(name="• Player names:",
inline=False,
value='`' + '' +
', '.join(motd.players.names) + ', '[:-0] +
'`')
if not len(plugins_string):
embed.add_field(name="• Plugins:",
inline=False,
value="`No Plugin Information / No Plugins`")
elif len(plugins_string) > 1024:
plugins_string = plugins_string[:1018]
plugins_string, _, _ = plugins_string.rpartition(', ')
plugins_string = '`' + plugins_string + '...`'
embed.add_field(name="• Plugins:",
inline=False,
value=plugins_string)
else:
embed.add_field(name="• Plugins:",
inline=False,
value='`' + '' +
', '.join(motd.software.plugins) + ', '[:-0] +
'`')
embed.add_field(name="• Full plugins and players list:",
value=f"[**Players**]({hastebin_players_link})"
f"\n[**Plugins**]({hastebin_plugins_link})")
await ctx.send(embed=embed)
logger.info(
f"Utility | Sent MCPE: {ctx.author} | Server: {server} | Port: {port}"
)
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)))
def __init__(self):
self.server = MinecraftServer("minecraft-1", 25565)
def get_query(mc_server, port=25565):
mc = MinecraftServer(mc_server, port)
query = mc.query()
return query.players.names
import telegram
from mcstatus import MinecraftServer
from minecraft.networking.connection import Connection
from minecraft.networking.packets import Packet, clientbound, serverbound
from time import sleep
from datetime import timedelta
import json
import credentials
SENDMESSAGE = range(1)
updater = Updater(token=credentials.mcbot_token, use_context=True)
dispatcher = updater.dispatcher
# If you know the host and port, you may skip this and use MinecraftServer("example.org", 1234)
server = MinecraftServer("ioya.de")
def start(update, context):
update.message.reply_text(
"Hello to the IOYA Minecraft server Bot!\nType /status to see how many players are online.\nType /wakeup to start the server if you want to play soon.\nWith /startChat you can start to chat with people on the server. Everything you send will be forewarded to the server and backwards.\nWith /quit you can end the chat."
)
def status(update, context):
status = server.status()
if status.players.online == 0:
update.message.reply_text(
"Nobody is online. Type /wakeup to give the server a good morning slap."
)
else:
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "minedash.settings") # noqa
import django
django.setup() # noqa
from django.conf import settings
from django.utils import timezone
from metrics.models import MetricSample
import psutil
from mcstatus import MinecraftServer
from socket import error as socket_error
try:
server = MinecraftServer(settings.MINECRAFT_SERVER_URL)
status = server.status()
players = status.players.online
except (socket_error, AttributeError):
players = 0
cpu = psutil.cpu_percent(interval=5)
memory = psutil.virtual_memory().percent
disk_root = getattr(settings, 'MINECRAFT_DISK_ROOT', '/')
disk = psutil.disk_usage(disk_root).percent
now = timezone.now()
data = []
data.append({
"name": 'cpu',
"volume": cpu,
def str2bool(v):
return v.lower() in ("yes", "true", "t", "1")
class PersistentState:
server = stopped
wakeup_port = int(os.environ.get('SERVER_PORT', 25565))
server_port = 25566
motd = os.environ.get('MOTD', 'Unknown MOTD')
online_mode = str2bool(os.environ['ONLINE_MODE'])
state = PersistentState()
mcserver = MinecraftServer('localhost', state.server_port)
def load_properties():
# if the server has already been created,
# then it can read server.properties to get the motd
p = Properties()
try:
with open("/data/server.properties", "rb") as f:
p.load(f)
state.motd = p['motd'].data
except:
pass
print('Exception: ' + str(e))
full_status = ec2.describe_instances(InstanceIds=['i-074c82fc5718bf939'])
server_state = full_status['Reservations'][0]['Instances'][0]['State']['Name']
if server_state == 'stopped':
raw_html_form = raw_html_form.format("""
The server has not been started - <input type = "submit" value = "click here to start the server" />
""")
elif server_state == 'pending':
raw_html_form = raw_html_form.format("""
The server is still starting, give it a minute or two
""")
elif server_state == 'running':
# Get the MC server status
try:
server = MinecraftServer('52.52.246.252', 25565)
mc_status = server.status()
raw_html_form = raw_html_form.format("""
The server is up - it has {0} players online, and a latency of {1} ms"""
.format(mc_status.players.online,
mc_status.latency))
except:
raw_html_form = raw_html_form.format("""
The server has been started, but the MineCraft instance has not gone live yet - if this persists for more than a few minutes, tell Bryan to go fix it
""")
else:
raw_html_form = raw_html_form.format("""
The server is currently shutting down, come back in a minute or two
""")
print(raw_html_form)
from pprint import pprint
# Memory usage per instance and or node.
# CPU usage by instance or node.
# Version of the container running on any given instance.
# Number of container instances running.
# Population of each Minecraft server.
# Total current players and available capacity.
host = "13.80.133.210"
kubernetes.config.load_kube_config()
# kubernetes.client.configuration.api_key['authorization'] = 'YOUR_API_KEY'
api_instance = kubernetes.client.AdmissionregistrationApi()
try:
api_response = api_instance.get_api_group()
# pprint(api_response)
except ApiException as e:
print("Exception calling AdmissionregistrationApi->get_api_group: %s\n" %
e)
# If you know the host and port, you may skip this and use
server = MinecraftServer(host, 25565)
# 'status' is supported by all Minecraft servers that are version 1.7 or higher.
status = server.status()
print("The server has {0}/{1} players online".format(status.players.online,
status.players.max))
os.system("kubectl top nodes")
os.system("kubectl top pods")
from mcstatus import MinecraftServer # Server details. server_hostname = "mc.mxc42.com" server_port = 4242 # Make a server object with the right connection properties. server = MinecraftServer(server_hostname, server_port) # '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.status() print(query.players.online)
#!/usr/bin/env python3
import os
import time
from datetime import datetime, timedelta
import xmlrpc.client as xmlrpclib
from mcstatus import MinecraftServer
from supervisor.states import ProcessStates
from supervisor.xmlrpc import SupervisorTransport
import parsedatetime
port = 25566
mcserver = MinecraftServer('localhost', port)
transport = SupervisorTransport(None, None, 'http://localhost:9001/RPC2')
transport.verbose = True
server = xmlrpclib.Server('http://unused', transport=transport)
cal = parsedatetime.Calendar()
GRACE_PERIOD = cal.parseDT(os.environ.get('GRACE_PERIOD', '10 minutes'),
sourceTime=datetime.min)[0] - datetime.min
print(GRACE_PERIOD)
# state machine
class PersistentState:
wait_begin = None
start_begin = None
import json
import discord
import logging
from mcstatus import MinecraftServer
# set up logger
logger = logging.getLogger('discord')
logger.setLevel(logging.INFO)
handler = logging.FileHandler(filename='bot.log', encoding='utf-8', mode='a')
handler.setFormatter(
logging.Formatter('%(asctime)s:%(levelname)s:%(name)s:%(message)s'))
logger.addHandler(handler)
client = discord.Client()
bot_token = os.environ['DISCORD_TOKEN']
server = MinecraftServer(os.environ['MC_SERVER'], 25568)
# retrieve map of usernames to real names
with open('names.txt', 'r') as file:
real_names = json.load(file)
@client.event
async def on_ready():
print('Bot {0} is online'.format(client.user))
@client.event
async def on_message(message):
if message.author == client.user:
return
def getMCServerData():
cfg.debug(f"getMCServerData", DEBUG)
# get mc server info
mcServer = "minecraft.tas.qld.edu.au"
conn = create_connection(cfg.DB)
sql = "SELECT MAX(maxPing), date from ping"
cfg.debug(sql, DEBUG)
cur = conn.cursor()
cur.execute(sql)
maxPing = cur.fetchone()[0]
sql = "SELECT COUNT(name) FROM members"
cur.execute(sql)
count = cur.fetchone()[0]
try:
server = MinecraftServer(mcServer)
status = server.status()
latency = status.latency
playersOnLine = status.players.online
playersMax = status.players.max
query = server.query()
playersList = query.players.names
cfg.debug(f"Playerlist: {playersList}", DEBUG)
now = datetime.datetime.now()
# get max ping from db.
if latency > maxPing:
sql = f"INSERT INTO ping (maxPing, date) VALUES ({status.latency}, '{now}')"
cfg.debug(sql , DEBUG)
cur.execute(sql )
conn.commit()
maxPing = f"{latency} ms"
percent = math.floor(playersOnLine / playersMax * 100)
except Exception as e:
cfg.debug(f"MC error {e}", True)
playersList = []
playersOnLine = 0
playersMax = 20
percent = 0
latency = "OFFLINE"
count = 0
# listOfPlayers = "THIS WILL BE A LIST OF ALL PLAYERS"
serverData = {
"ip": mcServer,
"latency": f"{latency} ms",
"playersList": playersList,
"playerCount": playersOnLine,
"playersMax": playersMax,
"percent": percent,
"maxPing": f"{maxPing} ms",
"docLink": latestDoc,
"discord": discordInvite,
"members": count
}
cfg.debug(f"mc server data: {serverData} ", True)
return serverData
import os
import socket
from dotenv import load_dotenv
from mcstatus import MinecraftServer
from telegram import ParseMode
from telegram.ext import CallbackContext, CommandHandler, Updater
load_dotenv()
MINECRAFT_SERVER_IP = os.getenv("MINECRAFT_SERVER_IP")
MINECRAFT_SERVER_PORT = int(os.getenv("MINECRAFT_SERVER_PORT"))
TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
NEW_PLAYERS_CHAT_ID = os.getenv("NEW_PLAYERS_CHAT_ID")
minecraft_server = MinecraftServer(MINECRAFT_SERVER_IP, MINECRAFT_SERVER_PORT)
updater = Updater(token=TELEGRAM_BOT_TOKEN, use_context=True)
dispatcher = updater.dispatcher
updater_jobs = updater.job_queue
def start(update, context):
"""
Replies to /start command.
"""
print(f"Chat: {update.message.chat_id} started bot.")
context.bot.send_message(chat_id=update.message.chat_id, text="¡Hola!")
def players_online(update, context):
"""
async def on_disconnect():
takenGuild = bot.get_guild(843707273087549450)
channel = takenGuild.text_channels
nameChannel = None
for x in channel:
if x.name == "cập-nhật-thông-tin-server":
nameChannel = x
break
A_mgs = [] #Empty list to put all the messages in the log
async for x in nameChannel.history(limit=100):
A_mgs.append(x)
await nameChannel.delete_messages(A_mgs)
date_time_now = datetime.datetime.now()
date_time_now = str(date_time_now)
date_time_now = date_time_now[:19] + date_time_now[26:]
msg = ""
status = None
statusNgrok_str = None
statusServer_str = None
players = 0
latency = 0
res = 0
try:
res = urllib.request.urlopen("http://localhost:4040/status").getcode()
except:
res = 0
if res == 200:
os.system("curl http://localhost:4040/api/tunnels > tunnels.json")
with open('tunnels.json') as data_file:
datajson = json.load(data_file)
msg_spilt = []
for i in datajson['tunnels']:
if (str(i['name']) == "minefc"):
msg = msg + i['public_url']
msg = msg.replace("tcp://", "")
msg_spilt = msg.split(":")
msg = "IP hiện tại của server : " + msg
try:
server = MinecraftServer(msg_spilt[0], int(msg_spilt[1]))
status = server.status()
players = status.players.online
latency = status.latency
statusServer_str = "<:greendot:844047684955799572> đang hoạt động"
statusNgrok_str = "<:greendot:844047684955799572> đang hoạt động"
except:
statusServer_str = "<:reddot:844050179845652530> đã dừng"
statusNgrok_str = "<:greendot:844047684955799572> đang hoạt động"
else:
statusServer_str = "<:reddot:844050179845652530> đã dừng"
statusNgrok_str = "<:reddot:844050179845652530> đã dừng"
embed = discord.Embed(
title=f"{msg}",
description=
f"Tình trạng Server Minecraft: {statusServer_str}\n>>>Hiện tại đang có {players}/174 người chơi đang online.\n>>>Ping : {latency} ms\nTình trạng Ngrok: {statusNgrok_str}\nTự động cập nhật sau mỗi 10s.\nNgoài ra bot còn nhiều lệnh khác, nhập !help để biết thêm chi tiết!",
color=0x00ff00)
embed.set_footer(
text=
f" Made by TKG - {date_time_now} - Theo múi giờ UTC+7 của Đông Lào",
icon_url=bot_ava)
embed = await nameChannel.send(embed=embed)
def __init__(self):
self.mc = MinecraftServer('localhost',25565)
self.username = "******"
self.process_name = "java"
self.cmd_query = "server.jar"
self.stime = None
def collect_server_data(instance: str) -> dict:
"""Collect Data about the server and return it as a dict.
Args:
instance (str): The instance of which the data should be collected.
Returns:
dict: A dict containing various Information about the server.
"""
instance_path = storage.get_instance_path(instance)
if not instance_path.exists():
raise FileNotFoundError(f"Instance not found: {instance_path}.")
properties = config.get_properties(instance_path / "server.properties")
try:
envinfo = config.get_properties(instance_path /
CFGVARS.get('system', 'env_file'))
except FileNotFoundError:
envinfo = None
port = properties.get("server-port")
server = MinecraftServer('localhost', int(port))
status_info = status.get_simple_status(server)
files = storage.get_child_paths(instance_path)
total_size = sum(x.stat().st_size for x in files)
unit = service.get_unit(instance)
state = get_online_state(unit, status_info.get("proto"))
cmdvars = {
k: v
for k, v in (x.decode().split("=") for x in unit.Service.Environment)
}
cmd = " ".join(x.decode() for x in unit.Service.ExecStart[0][1])
resolved_cmd = cmd.replace("${", "{").format(**cmdvars)
jar_path = instance_path / cmdvars.get("JARFILE", "server.jar")
resolved_jar_path = storage.get_real_abspath(jar_path)
type_id = None
if resolved_jar_path != jar_path:
type_id = storage.get_type_id(resolved_jar_path)
try:
with open(instance_path / "whitelist.json") as wlist_hnd:
whitelist = json.load(wlist_hnd)
except FileNotFoundError:
whitelist = None
try:
plugins = plugin.get_plugins(instance)
except FileNotFoundError:
plugins = None
data = {
"instance_name": instance,
"instance_path": str(instance_path),
"total_file_size": total_size,
"status": {
"players_online": status_info.get('online'),
"players_max": properties.get('max-players', '?'),
"protocol_name": status_info.get('proto'),
"protocol_version": status_info.get('version'),
},
"service": {
"description": unit.Unit.Description.decode(),
"unit_file_state": unit.UnitFileState.decode(),
"state": state,
"main_pid": unit.Service.MainPID,
"start_command": resolved_cmd,
"memory_usage": unit.Service.MemoryCurrent,
"env": dict(cmdvars),
},
"type_id": type_id,
"config": {
"server.properties": properties,
"whitelist": whitelist,
"env_file": envinfo
},
"plugins": plugins,
}
return data
