mcmanager 0.1.0__tar.gz

mcmanager-0.1.0/MANIFEST.in

@@ -0,0 +1,5 @@
+recursive-include mcmanager/configs *
+recursive-include mcmanager/console/templates *
+recursive-include mcmanager/console/static *
+include README.md
+include requirements.txt

mcmanager-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: mcmanager
+Version: 0.1.0
+Summary: A Django-based web interface to manage Minecraft servers on a VPS
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: Django
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Games/Entertainment
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Django<5.2.0,>=4.2.0
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: whitenoise>=6.0.0
+
+# mcmanager (BETA)
+
+Um painel web simples baseado em Django para gerenciar servidores Minecraft diretamente na sua VPS Linux.
+
+## Instalação
+
+### 1. Instalar o Java 8 (Necessário para o Minecraft)
+
+```console
+sudo apt-get update
+sudo apt-get install openjdk-8-jre-headless
+```
+
+### 2. Instalar o mcmanager do PyPI
+
+```console
+pip install mcmanager
+```
+
+### 3. Inicializar e rodar o painel
+
+```console
+# Inicializa o banco de dados e cria os diretórios na pasta ~/.mcmanager
+mcmanager init
+
+# Cria um usuário administrador
+mcmanager createsuperuser
+
+# Inicia o painel
+mcmanager run
+```
+
+Pronto! Acesse `http://sua-vps-ip:8000/admin/` para logar com o superusuário criado e começar a gerenciar seus servidores.
+
+---
+
+## Estrutura de Diretórios e Dados
+
+Por padrão, todos os dados do painel ficam armazenados de forma isolada na home do usuário:
+- `~/.mcmanager/db.sqlite3` (Banco de dados do painel)
+- `~/.mcmanager/jar/` (Coloque seus arquivos `.jar` de servidor aqui, ex: `spigot.jar`, `vanilla.jar`)
+- `~/.mcmanager/servers/` (Diretório onde cada servidor criado será executado)
+- `~/.mcmanager/configs/` (Onde fica o `server.properties` padrão)
+- `~/.mcmanager/staticfiles/` (Arquivos estáticos compilados do painel)
+
+### Customizações por Variáveis de Ambiente
+
+Você pode ajustar o comportamento do painel definindo variáveis de ambiente antes de executar o comando `mcmanager`:
+
+* **`MCMANAGER_DATA_DIR`**: Altera a pasta padrão onde os servidores e banco de dados são salvos (padrão: `~/.mcmanager`).
+* **`MCMANAGER_JAVA_BIN`**: Especifica o caminho binário do Java (padrão: `/usr/lib/jvm/java-8-openjdk-amd64/bin/java`). Use `whereis java` para encontrar o caminho correto na sua VPS.
+* **`MCMANAGER_ALLOWED_HOSTS`**: Lista de hosts permitidos separados por vírgula (padrão: `*`).
+* **`MCMANAGER_DEBUG`**: Define se o painel roda em modo debug (`True` ou `False`).
+
+Exemplo definindo um caminho diferente de Java e iniciando:
+```console
+export MCMANAGER_JAVA_BIN="/usr/bin/java"
+mcmanager run
+```
+
+---
+
+## Desenvolvimento Local
+
+Se você deseja contribuir ou modificar o código localmente:
+
+1. Clone o repositório.
+2. Crie e ative um ambiente virtual.
+3. Instale as dependências e o pacote local no modo editável:
+   ```console
+   pip install -r requirements.txt
+   pip install -e .
+   ```
+4. Ao rodar `python manage.py runserver`, o painel rodará em modo debug local e usará a própria pasta do projeto para salvar os arquivos de desenvolvimento.
+
+### Comandos de Desenvolvimento Úteis
+
+* **Formatar código:**
+  ```console
+  python manage.py format_code
+  ```
+* **Gerar nova Secret Key de desenvolvimento:**
+  ```console
+  python manage.py generate_secret_key
+  ```
+
+## Capturas de Tela
+
+![alt text](screenshot.png)
+![alt text](screenshot2.png)

mcmanager-0.1.0/README.md

@@ -0,0 +1,90 @@
+# mcmanager (BETA)
+
+Um painel web simples baseado em Django para gerenciar servidores Minecraft diretamente na sua VPS Linux.
+
+## Instalação
+
+### 1. Instalar o Java 8 (Necessário para o Minecraft)
+
+```console
+sudo apt-get update
+sudo apt-get install openjdk-8-jre-headless
+```
+
+### 2. Instalar o mcmanager do PyPI
+
+```console
+pip install mcmanager
+```
+
+### 3. Inicializar e rodar o painel
+
+```console
+# Inicializa o banco de dados e cria os diretórios na pasta ~/.mcmanager
+mcmanager init
+
+# Cria um usuário administrador
+mcmanager createsuperuser
+
+# Inicia o painel
+mcmanager run
+```
+
+Pronto! Acesse `http://sua-vps-ip:8000/admin/` para logar com o superusuário criado e começar a gerenciar seus servidores.
+
+---
+
+## Estrutura de Diretórios e Dados
+
+Por padrão, todos os dados do painel ficam armazenados de forma isolada na home do usuário:
+- `~/.mcmanager/db.sqlite3` (Banco de dados do painel)
+- `~/.mcmanager/jar/` (Coloque seus arquivos `.jar` de servidor aqui, ex: `spigot.jar`, `vanilla.jar`)
+- `~/.mcmanager/servers/` (Diretório onde cada servidor criado será executado)
+- `~/.mcmanager/configs/` (Onde fica o `server.properties` padrão)
+- `~/.mcmanager/staticfiles/` (Arquivos estáticos compilados do painel)
+
+### Customizações por Variáveis de Ambiente
+
+Você pode ajustar o comportamento do painel definindo variáveis de ambiente antes de executar o comando `mcmanager`:
+
+* **`MCMANAGER_DATA_DIR`**: Altera a pasta padrão onde os servidores e banco de dados são salvos (padrão: `~/.mcmanager`).
+* **`MCMANAGER_JAVA_BIN`**: Especifica o caminho binário do Java (padrão: `/usr/lib/jvm/java-8-openjdk-amd64/bin/java`). Use `whereis java` para encontrar o caminho correto na sua VPS.
+* **`MCMANAGER_ALLOWED_HOSTS`**: Lista de hosts permitidos separados por vírgula (padrão: `*`).
+* **`MCMANAGER_DEBUG`**: Define se o painel roda em modo debug (`True` ou `False`).
+
+Exemplo definindo um caminho diferente de Java e iniciando:
+```console
+export MCMANAGER_JAVA_BIN="/usr/bin/java"
+mcmanager run
+```
+
+---
+
+## Desenvolvimento Local
+
+Se você deseja contribuir ou modificar o código localmente:
+
+1. Clone o repositório.
+2. Crie e ative um ambiente virtual.
+3. Instale as dependências e o pacote local no modo editável:
+   ```console
+   pip install -r requirements.txt
+   pip install -e .
+   ```
+4. Ao rodar `python manage.py runserver`, o painel rodará em modo debug local e usará a própria pasta do projeto para salvar os arquivos de desenvolvimento.
+
+### Comandos de Desenvolvimento Úteis
+
+* **Formatar código:**
+  ```console
+  python manage.py format_code
+  ```
+* **Gerar nova Secret Key de desenvolvimento:**
+  ```console
+  python manage.py generate_secret_key
+  ```
+
+## Capturas de Tela
+
+![alt text](screenshot.png)
+![alt text](screenshot2.png)

mcmanager-0.1.0/mcmanager/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for mcmanager project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/4.0/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mcmanager.settings')
+
+application = get_asgi_application()

mcmanager-0.1.0/mcmanager/cli.py

@@ -0,0 +1,115 @@
+import os
+import sys
+import argparse
+import shutil
+from pathlib import Path
+
+def get_data_dir():
+    """Determina o diretório de dados com base na variável de ambiente ou home"""
+    if os.environ.get("MCMANAGER_DATA_DIR"):
+        return Path(os.environ["MCMANAGER_DATA_DIR"]).resolve()
+    
+    debug_mode = os.environ.get("MCMANAGER_DEBUG", "False").lower() in ("true", "1", "yes")
+    if debug_mode:
+        # Se estiver em modo debug local, usa a pasta do próprio projeto
+        return Path(__file__).resolve().parent.parent
+    else:
+        return Path.home() / ".mcmanager"
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="mcmanager - Painel de Controle de Servidores Minecraft"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True, help="Subcomando a executar")
+
+    # Comando init
+    init_parser = subparsers.add_parser("init", help="Inicializa o diretório de dados, banco e arquivos padrões")
+
+    # Comando run
+    run_parser = subparsers.add_parser("run", help="Inicia o servidor web do painel")
+    run_parser.add_argument("--host", default="0.0.0.0", help="Endereço IP para escutar (padrão: 0.0.0.0)")
+    run_parser.add_argument("--port", type=int, default=8000, help="Porta para escutar (padrão: 8000)")
+
+    # Comando createsuperuser
+    createsuperuser_parser = subparsers.add_parser(
+        "createsuperuser", help="Cria um usuário administrador para o painel"
+    )
+
+    # Comando shell
+    shell_parser = subparsers.add_parser("shell", help="Inicia o console interativo do Django")
+
+    args = parser.parse_args()
+
+    # 1. Obter e criar estrutura de dados do usuário
+    data_dir = get_data_dir()
+    data_dir.mkdir(parents=True, exist_ok=True)
+    (data_dir / "servers").mkdir(exist_ok=True)
+    (data_dir / "jar").mkdir(exist_ok=True)
+    (data_dir / "configs").mkdir(exist_ok=True)
+
+    # 2. Copiar server.properties padrão se não existir
+    properties_dest = data_dir / "configs" / "server.properties"
+    if not properties_dest.exists():
+        # Tenta carregar usando importlib.resources (PEP 517)
+        copied = False
+        try:
+            from importlib import resources
+            # Python 3.9+
+            source_path = resources.files("mcmanager").joinpath("configs/server.properties")
+            with source_path.open("rb") as fsrc:
+                with open(properties_dest, "wb") as fdst:
+                    shutil.copyfileobj(fsrc, fdst)
+            copied = True
+        except Exception:
+            pass
+
+        if not copied:
+            # Fallback para caminho relativo
+            source_path = Path(__file__).resolve().parent / "configs" / "server.properties"
+            if source_path.exists():
+                shutil.copy(source_path, properties_dest)
+                copied = True
+
+        if copied:
+            print(f"[*] Arquivo server.properties padrão copiado para: {properties_dest}")
+        else:
+            print("[!] Aviso: Não foi possível copiar o arquivo server.properties padrão.")
+
+    # 3. Configurar variáveis de ambiente do Django
+    os.environ.setdefault("MCMANAGER_DATA_DIR", str(data_dir))
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mcmanager.settings")
+
+    # 4. Inicializar Django
+    import django
+    django.setup()
+
+    from django.core.management import call_command
+
+    # 5. Executar os subcomandos
+    if args.command == "init":
+        print("[*] Executando migrações do banco de dados...")
+        call_command("migrate", interactive=False)
+        print("[*] Coletando arquivos estáticos...")
+        call_command("collectstatic", "--noinput", "--clear")
+        print("\n[+] Inicialização concluída com sucesso!")
+        print(f"[+] Seus dados estão em: {data_dir}")
+        print("[+] Agora você pode rodar: mcmanager createsuperuser")
+
+    elif args.command == "run":
+        bind_address = f"{args.host}:{args.port}"
+        print(f"[*] Iniciando servidor mcmanager em http://{bind_address}/")
+        print("[*] Pressione CTRL+C para encerrar.")
+        # Em produção, rodamos sem autoreload
+        call_command("runserver", "--noreload", "--nostatic", bind_address)
+
+    elif args.command == "createsuperuser":
+        try:
+            call_command("createsuperuser")
+        except KeyboardInterrupt:
+            print("\n[!] Operação cancelada.")
+
+    elif args.command == "shell":
+        call_command("shell")
+
+if __name__ == "__main__":
+    main()

mcmanager-0.1.0/mcmanager/configs/server.properties

@@ -0,0 +1,33 @@
+#Minecraft server properties
+#Wed Jul 10 19:30:06 UTC 2024
+generator-settings=
+op-permission-level=4
+allow-nether=true
+level-name=world
+enable-query=false
+allow-flight=true
+announce-player-achievements=true
+server-port=25566
+level-type=DEFAULT
+enable-rcon=false
+force-gamemode=false
+level-seed=
+server-ip=
+max-build-height=256
+spawn-npcs=true
+white-list=false
+spawn-animals=true
+hardcore=false
+snooper-enabled=true
+online-mode=false
+resource-pack=
+pvp=true
+difficulty=1
+enable-command-block=false
+gamemode=0
+player-idle-timeout=0
+max-players=5
+spawn-monsters=true
+generate-structures=true
+view-distance=10
+motd=A Minecraft Server

mcmanager-0.1.0/mcmanager/console/admin.py

@@ -0,0 +1,29 @@
+from typing import Any
+from django.contrib import admin
+from django.http import HttpRequest
+from django.http.response import HttpResponse
+from .models import Server, Type
+
+
+@admin.register(Server)
+class ServerAdmin(admin.ModelAdmin):
+    list_display = ('name', 'port', 'type', 'status')
+    exclude = ('jar', 'server_properties')
+    search_fields = ('name', 'port', 'type')
+    list_filter = ('type', 'status')
+    readonly_fields = ('status',)
+
+    def get_form(self, request, obj=..., change=..., **kwargs) -> Any:
+        if obj is None:
+            self.exclude = ('jar', 'server_properties')
+            self.readonly_fields = ('status',)
+        else:
+            self.exclude = None
+            self.readonly_fields = ('status', 'jar')
+        return super().get_form(request, obj, change, **kwargs)
+
+
+@admin.register(Type)
+class TypeAdmin(admin.ModelAdmin):
+    list_display = ('name',)
+    search_fields = ('name',)

mcmanager-0.1.0/mcmanager/console/apps.py

@@ -0,0 +1,22 @@
+from django.apps import AppConfig
+
+
+class ConsoleConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'mcmanager.console'
+
+    def ready(self) -> None:
+        try:
+            print('Checking server status...')
+            from .views import is_server_running
+            from .models import Server
+            for server in Server.objects.all():
+                if is_server_running(server.id):
+                    server.status = True
+                    server.save()
+                else:
+                    server.status = False
+                    server.save()
+            print('Server status checked!')
+        except Exception as e:
+            print(e)

mcmanager-0.1.0/mcmanager/console/models.py

@@ -0,0 +1,112 @@
+import uuid
+import os
+import shutil
+from django.db import models
+from django.conf import settings
+from django.dispatch import receiver
+from django.db.models.signals import post_save, pre_save, pre_delete
+
+
+def get_jar_files():
+    jar_dir = getattr(settings, 'JAR_DIR', os.path.join(settings.BASE_DIR, 'jar'))
+    if not os.path.exists(jar_dir):
+        os.makedirs(jar_dir)
+    return [(x, x) for x in os.listdir(jar_dir) if x.endswith('.jar')]
+
+
+def get_default_server_prop():
+    configs_dir = getattr(settings, 'CONFIGS_DIR', os.path.join(settings.BASE_DIR, 'configs'))
+    with open(os.path.join(configs_dir, 'server.properties'), 'r', encoding='utf-8') as arq:
+        text = arq.read()
+    return text
+
+
+class Type(models.Model):
+    name = models.CharField(max_length=100)
+    dependencies = models.JSONField(blank=True, null=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return self.name
+
+
+class Server(models.Model):
+    name = models.CharField(max_length=100)
+    jar_template = models.CharField(max_length=100, choices=get_jar_files())
+    jar = models.CharField(max_length=100, blank=True, null=True)
+    # ip = models.GenericIPAddressField(blank=True, null=True)
+    port = models.IntegerField(default=25565)
+    memory_limit = models.IntegerField("Memory Limit (MB)", default=1024)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    type = models.ForeignKey(
+        Type, on_delete=models.CASCADE, related_name='servers')
+    status = models.BooleanField(default=False)
+    server_properties = models.TextField(blank=True, null=True)
+
+    def __str__(self):
+        return self.name
+
+
+@receiver(pre_delete, sender=Server)
+def pre_delete_server(sender, instance, **kwargs):
+    servers_dir = getattr(settings, 'SERVERS_DIR', os.path.join(settings.BASE_DIR, 'servers'))
+    server_path = os.path.join(servers_dir, f'server_{instance.id}')
+    if os.path.exists(server_path):
+        shutil.rmtree(server_path)
+
+
+pre_delete.connect(pre_delete_server, sender=Server)
+
+
+@receiver(post_save, sender=Server)
+def post_save_server(sender, instance, **kwargs):
+    servers_dir = getattr(settings, 'SERVERS_DIR', os.path.join(settings.BASE_DIR, 'servers'))
+    jar_dir = getattr(settings, 'JAR_DIR', os.path.join(settings.BASE_DIR, 'jar'))
+    configs_dir = getattr(settings, 'CONFIGS_DIR', os.path.join(settings.BASE_DIR, 'configs'))
+
+    server_path = os.path.join(servers_dir, f'server_{instance.id}')
+    properties_path = os.path.join(server_path, 'server.properties')
+
+    if not instance.jar:
+        instance.jar = str(instance.id) + "_" + instance.jar_template
+        os.makedirs(server_path, exist_ok=True)
+        shutil.copy(os.path.join(jar_dir, instance.jar_template), os.path.join(server_path, instance.jar))
+        shutil.copy(os.path.join(configs_dir, 'server.properties'), properties_path)
+        
+        if instance.type.dependencies:
+            for dependency in instance.type.dependencies:
+                dep_source = os.path.join(jar_dir, dependency)
+                dep_dest = os.path.join(server_path, dependency)
+                if os.path.isdir(dep_source):
+                    shutil.copytree(dep_source, dep_dest)
+                else:
+                    shutil.copy(dep_source, dep_dest)
+                    
+        with open(os.path.join(server_path, 'eula.txt'), 'w', encoding='utf-8') as f:
+            f.write('eula=true')
+            
+        new_server_properties = []
+        with open(properties_path, 'r', encoding='utf-8', errors='ignore') as f:
+            for line in f:
+                if line.startswith('server-port='):
+                    new_server_properties.append(f'server-port={instance.port}\n')
+                else:
+                    new_server_properties.append(line)
+                    
+        with open(properties_path, 'w', encoding='utf-8') as f:
+            f.write(''.join(new_server_properties))
+            
+        with open(properties_path, 'r', encoding='utf-8', errors='ignore') as f:
+            text = f.read()
+            
+        instance.server_properties = text
+        instance.save()
+    else:
+        with open(properties_path, 'w', encoding='utf-8') as f:
+            f.write(instance.server_properties)
+
+
+post_save.connect(post_save_server, sender=Server)
+