httpd module

src/main/java/dev/plex/HTTPDModule.java

@@ -0,0 +1,82 @@
+package dev.plex;
+
+import dev.plex.config.Config;
+import dev.plex.config.ModuleConfig;
+import dev.plex.module.PlexModule;
+import dev.plex.request.impl.GetEndpoints;
+import dev.plex.util.PlexLog;
+import lombok.Getter;
+import net.milkbowl.vault.permission.Permission;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.eclipse.jetty.server.*;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHandler;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+public class HTTPDModule extends PlexModule {
+
+    public static ServletContextHandler context;
+    private Thread serverThread;
+    private AtomicReference<Server> atomicServer = new AtomicReference<>();
+
+    @Getter
+    private static Permission permissions = null;
+
+    private ModuleConfig config;
+
+    @Override
+    public void enable() {
+        config =  new ModuleConfig(this, "settings.yml");
+        config.load();
+        PlexLog.debug("HTTPD Module Port: {0}", config.getInt("server.port"));
+        if (!setupPermissions() && getPlex().getSystem().equalsIgnoreCase("permissions") && !Bukkit.getPluginManager().isPluginEnabled("Vault")) {
+            throw new RuntimeException("Plex-HTTPD requires the 'Vault' plugin as well as a Permissions plugin that hooks into 'Vault.' We recommend LuckPerms!");
+        }
+        serverThread = new Thread(() -> {
+            Server server = new Server();
+            ServletHandler servletHandler = new ServletHandler();
+
+            context = new ServletContextHandler(servletHandler, "/", ServletContextHandler.SESSIONS);
+            HttpConfiguration configuration = new HttpConfiguration();
+            configuration.addCustomizer(new ForwardedRequestCustomizer());
+            HttpConnectionFactory factory = new HttpConnectionFactory(configuration);
+            ServerConnector connector = new ServerConnector(server, factory);
+            connector.setPort(config.getInt("server.port"));
+            connector.setHost("0.0.0.0");
+
+            new GetEndpoints();
+
+            server.setConnectors(new Connector[]{connector});
+            server.setHandler(context);
+
+            atomicServer.set(server);
+            PlexLog.debug("Set atomicServer value? {0}", atomicServer.get() != null);
+            try {
+                server.start();
+                server.join();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }, "jetty-server");
+        serverThread.start();
+    }
+
+    @Override
+    public void disable() {
+        PlexLog.debug("Stopping jetty server");
+        try {
+            atomicServer.get().stop();
+            atomicServer.get().destroy();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private boolean setupPermissions() {
+        RegisteredServiceProvider<Permission> rsp = Bukkit.getServicesManager().getRegistration(Permission.class);
+        permissions = rsp.getProvider();
+        return permissions != null;
+    }
+}

src/main/java/dev/plex/request/AbstractServlet.java

@@ -0,0 +1,83 @@
+package dev.plex.request;
+
+import com.google.common.collect.Lists;
+import dev.plex.HTTPDModule;
+import dev.plex.util.PlexLog;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServlet;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.Data;
+import org.eclipse.jetty.servlet.ServletHolder;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Enumeration;
+import java.util.List;
+
+public class AbstractServlet extends HttpServlet {
+
+    private final List<Mapping> GET_MAPPINGS = Lists.newArrayList();
+
+    public AbstractServlet() {
+        for (Method declaredMethod : this.getClass().getDeclaredMethods()) {
+            declaredMethod.setAccessible(true);
+            if (declaredMethod.isAnnotationPresent(GetMapping.class)) {
+                GetMapping getMapping = declaredMethod.getAnnotation(GetMapping.class);
+                Mapping mapping = new Mapping(declaredMethod, getMapping);
+                if (declaredMethod.isAnnotationPresent(MappingHeaders.class)) {
+                    mapping.setHeaders(declaredMethod.getAnnotation(MappingHeaders.class));
+                }
+                GET_MAPPINGS.add(mapping);
+                ServletHolder holder = new ServletHolder(this);
+                HTTPDModule.context.addServlet(holder, getMapping.endpoint() + "*");
+            }
+        }
+    }
+
+    @Override
+    public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+
+        PlexLog.debug("Context Path: " + req.getHttpServletMapping().getMatchValue());
+
+        String ipAddress = req.getHeader("X-FORWARDED-FOR");
+        if (ipAddress == null) {
+            ipAddress = req.getRemoteAddr();
+        }
+        PlexLog.debug("HTTP Remote IP: " + ipAddress);
+        PlexLog.debug("HTTP Local IP: " + req.getLocalAddr());
+
+        /*Enumeration<String> headerz = req.getHeaderNames();
+        while (headerz.hasMoreElements()) {
+            String header = headerz.nextElement();
+            PlexLog.debug("Header: {0} Value {1}", header, req.getHeader(header));
+        }*/
+
+        PlexLog.debug("-------------------------");
+        GET_MAPPINGS.stream().filter(mapping -> mapping.getMapping().endpoint().substring(1, mapping.getMapping().endpoint().length() - 1).equalsIgnoreCase(req.getHttpServletMapping().getMatchValue())).forEach(mapping -> {
+            if (mapping.headers != null) {
+                for (String headers : mapping.headers.headers()) {
+                    String header = headers.split(";")[0];
+                    String value = headers.split(";")[1];
+                    resp.addHeader(header, value);
+                }
+            }
+            resp.setStatus(HttpServletResponse.SC_OK);
+            try {
+                Object object = mapping.method.invoke(this, req);
+                resp.getWriter().println(object.toString());
+            } catch (IOException | IllegalAccessException | InvocationTargetException e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+
+    @Data
+    public class Mapping {
+        private final Method method;
+        private final GetMapping mapping;
+        private MappingHeaders headers;
+    }
+}

src/main/java/dev/plex/request/GetMapping.java

@@ -0,0 +1,13 @@
+package dev.plex.request;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface GetMapping {
+
+    String endpoint();
+
+}

src/main/java/dev/plex/request/MappingHeaders.java

@@ -0,0 +1,11 @@
+package dev.plex.request;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface MappingHeaders {
+
+    String[] headers();
+
+}

src/main/java/dev/plex/request/impl/GetEndpoints.java

@@ -0,0 +1,71 @@
+package dev.plex.request.impl;
+
+import com.google.common.collect.Lists;
+import com.google.gson.GsonBuilder;
+import dev.plex.HTTPDModule;
+import dev.plex.Plex;
+import dev.plex.cache.DataUtils;
+import dev.plex.player.PlexPlayer;
+import dev.plex.punishment.PunishmentManager;
+import dev.plex.rank.enums.Rank;
+import dev.plex.request.AbstractServlet;
+import dev.plex.request.GetMapping;
+import dev.plex.util.PlexLog;
+import jakarta.servlet.http.HttpServletRequest;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+
+import java.util.ArrayList;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+//@RestController
+//@RequestMapping("/api/admins")
+public class GetEndpoints extends AbstractServlet {
+
+    @GetMapping(endpoint = "/api/admins/")
+    public String getAdmins(HttpServletRequest request) {
+        String ipAddress = request.getHeader("X-FORWARDED-FOR");
+        if (ipAddress == null) {
+            ipAddress = request.getRemoteAddr();
+        }
+        final PlexPlayer player = DataUtils.getPlayerByIP(ipAddress);
+        if (player == null) return "Couldn't load your IP Address: " + ipAddress + ". Check if your SSL settings are setup correctly.";
+        if (Plex.get().getSystem().equalsIgnoreCase("ranks")) {
+            PlexLog.debug("Plex-HTTPD using ranks check");
+            if (!player.getRankFromString().isAtLeast(Rank.ADMIN)) {
+                return new GsonBuilder().setPrettyPrinting().create().toJson(Plex.get().getAdminList().getAllAdminPlayers().stream().peek(plexPlayer -> plexPlayer.setIps(Lists.newArrayList())).collect(Collectors.toList()));
+            }
+        } else if (Plex.get().getSystem().equalsIgnoreCase("permissions")) {
+            PlexLog.debug("Plex-HTTPD using permissions check");
+            final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(UUID.fromString(player.getUuid()));
+            if (!HTTPDModule.getPermissions().playerHas(null, offlinePlayer, "plex.httpd.indefbans.access")) {
+                return new GsonBuilder().setPrettyPrinting().create().toJson(Plex.get().getAdminList().getAllAdminPlayers().stream().peek(plexPlayer -> plexPlayer.setIps(Lists.newArrayList())).collect(Collectors.toList()));
+            }
+        }
+        return new GsonBuilder().setPrettyPrinting().create().toJson(new ArrayList<>(Plex.get().getAdminList().getAllAdminPlayers()));
+    }
+
+    @GetMapping(endpoint = "/api/indefbans/")
+    public String getBans(HttpServletRequest request) {
+        String ipAddress = request.getHeader("X-FORWARDED-FOR");
+        if (ipAddress == null) {
+            ipAddress = request.getRemoteAddr();
+        }
+        final PlexPlayer player = DataUtils.getPlayerByIP(ipAddress);
+        if (player == null) return "Couldn't load your IP Address: " + ipAddress + ". Check if your SSL settings are setup correctly.";
+        if (Plex.get().getSystem().equalsIgnoreCase("ranks")) {
+            PlexLog.debug("Plex-HTTPD using ranks check");
+            if (!player.getRankFromString().isAtLeast(Rank.ADMIN)) {
+                return "Not a high enough rank to view this page.";
+            }
+        } else if (Plex.get().getSystem().equalsIgnoreCase("permissions")) {
+            PlexLog.debug("Plex-HTTPD using permissions check");
+            final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(UUID.fromString(player.getUuid()));
+            if (!HTTPDModule.getPermissions().playerHas(null, offlinePlayer, "plex.httpd.indefbans.access")) {
+                return "Not enough permissions to view this page.";
+            }
+        }
+        return new GsonBuilder().setPrettyPrinting().create().toJson(new ArrayList<>(Plex.get().getPunishmentManager().getIndefiniteBans().stream().toList()));
+    }
+}

src/main/resources/module.yml

@@ -0,0 +1,4 @@
+name: Plex-HTTPD
+version: 0.1
+description: HTTPD server for Plex
+main: dev.plex.HTTPDModule

src/main/resources/settings.yml

@@ -0,0 +1,2 @@
+server:
+  port: 27192