/** Load all the classes in the current jar file so it can be overwritten */ private void loadAllClasses() { LWC lwc = LWC.getInstance(); try { // Load the jar JarFile jar = new JarFile(lwc.getPlugin().getFile()); // Walk through all of the entries Enumeration<JarEntry> enumeration = jar.entries(); while (enumeration.hasMoreElements()) { JarEntry entry = enumeration.nextElement(); String name = entry.getName(); // is it a class file? if (name.endsWith(".class")) { // convert to package String path = name.replaceAll("/", "."); path = path.substring(0, path.length() - ".class".length()); // Load it this.getClass().getClassLoader().loadClass(path); } } } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } }
public Database() { currentType = DefaultType; prefix = LWC.getInstance().getConfiguration().getString("database.prefix", ""); if (prefix == null) { prefix = ""; } }
/** @return the path where the database file should be saved */ public String getDatabasePath() { Configuration lwcConfiguration = LWC.getInstance().getConfiguration(); if (currentType == Type.MySQL) { return "//" + lwcConfiguration.getString("database.host") + "/" + lwcConfiguration.getString("database.database"); } return lwcConfiguration.getString("database.path"); }
/** * Checks if a player has reached their protection limit * * @param player * @param material the material type the player has interacted with * @return */ public boolean hasReachedLimit(Player player, Material material) { LWC lwc = LWC.getInstance(); Limit limit = getEffectiveLimit(player, material); // if they don't have a limit it's not possible to reach it ^^ // ... but if it's null, what the hell did the server owner do? if (limit == null) { return false; } // Get the effective limit placed upon them int neverPassThisNumber = limit.getLimit(); // get the amount of protections the player has int protections = limit.getProtectionCount(player, material); return protections >= neverPassThisNumber; }
/** * Gets the list of limits that may apply to the player. For group limits, it uses the highest one * found. * * @param player * @return */ public List<Limit> getPlayerLimits(Player player) { LWC lwc = LWC.getInstance(); List<Limit> limits = new LinkedList<Limit>(); // get all of their own limits String playerName = player.getName().toLowerCase(); if (playerLimits.containsKey(playerName)) { limits.addAll(playerLimits.get(playerName)); } // Look over the group limits for (String group : lwc.getPermissions().getGroups(player)) { if (groupLimits.containsKey(group)) { for (Limit limit : groupLimits.get(group)) { // try to match one already inside what we found Limit matched = findLimit(limits, limit); if (matched != null) { // Is our limit better? if (limit.getLimit() > matched.getLimit()) { limits.remove(matched); limits.add(limit); } } else { limits.add(limit); } } } } // Look at the default limits for (Limit limit : defaultLimits) { // try to match one already inside what we found Limit matched = findLimit(limits, limit); if (matched == null) { limits.add(limit); } } return limits; }
/** * Sends the list of limits to the player * * @param sender the commandsender to send the limits to * @param target the player limits are being shown for, can be null * @param limits */ public void sendLimits(CommandSender sender, Player target, List<Limit> limits) { LWC lwc = LWC.getInstance(); for (Limit limit : limits) { if (limit == null) { continue; } String stringLimit = limit.getLimit() == UNLIMITED ? "Unlimited" : Integer.toString(limit.getLimit()); String colour = Colors.Yellow; if (target != null) { boolean reachedLimit = hasReachedLimit( target, ((limit instanceof BlockLimit) ? ((BlockLimit) limit).getMaterial() : null)); colour = reachedLimit ? Colors.Red : Colors.Green; } if (limit instanceof DefaultLimit) { String currentProtected = target != null ? (Integer.toString(limit.getProtectionCount(target, null)) + "/") : ""; sender.sendMessage("Default: " + colour + currentProtected + stringLimit); } else if (limit instanceof BlockLimit) { BlockLimit blockLimit = (BlockLimit) limit; String currentProtected = target != null ? (Integer.toString(limit.getProtectionCount(target, blockLimit.getMaterial())) + "/") : ""; sender.sendMessage( lwc.materialToString(blockLimit.getMaterial()) + ": " + colour + currentProtected + stringLimit); } else { sender.sendMessage(limit.getClass().getSimpleName() + ": " + Colors.Yellow + stringLimit); } } }
public void init() { LWC lwc = LWC.getInstance(); updateBranch = UpdateBranch.match(lwc.getConfiguration().getString("updater.branch", "STABLE")); updateMethod = UpdateMethod.match(lwc.getConfiguration().getString("updater.method", "MANUAL")); if (updateMethod == UpdateMethod.AUTOMATIC) { this.loadVersions( true, new Runnable() { public void run() { tryAutoUpdate(false); logger.info("LWC: Latest version: " + latestVersion); } }); } // verify we have local files (e.g sqlite.jar, etc) this.verifyFiles(); this.downloadFiles(); }
@Override public void onBlockInteract(LWCBlockInteractEvent event) { if (event.getResult() != Result.DEFAULT) { return; } if (!event.hasAction("create")) { return; } LWC lwc = event.getLWC(); Block block = event.getBlock(); LWCPlayer player = lwc.wrapPlayer(event.getPlayer()); if (!lwc.isProtectable(block)) { return; } PhysDB physDb = lwc.getPhysicalDatabase(); Action action = player.getAction("create"); String actionData = action.getData(); String[] split = actionData.split(" "); String protectionType = split[0].toLowerCase(); String protectionData = StringUtil.join(split, 1); // check permissions again (DID THE LITTLE SHIT MOVE WORLDS??!?!?!?!?!?) if (!lwc.hasPermission( event.getPlayer(), "lwc.create." + protectionType, "lwc.create", "lwc.protect")) { lwc.sendLocale(player, "protection.accessdenied"); lwc.removeModes(player); event.setResult(Result.CANCEL); return; } // misc data we'll use later String playerName = player.getName(); String worldName = block.getWorld().getName(); int blockX = block.getX(); int blockY = block.getY(); int blockZ = block.getZ(); lwc.removeModes(player); LWCProtectionRegisterEvent evt = new LWCProtectionRegisterEvent(player.getBukkitPlayer(), block); lwc.getModuleLoader().dispatchEvent(evt); // another plugin cancelled the registration if (evt.isCancelled()) { return; } // The created protection Protection protection = null; if (protectionType.equals("public")) { protection = physDb.registerProtection( block.getTypeId(), Protection.Type.PUBLIC, worldName, player.getUniqueId().toString(), "", blockX, blockY, blockZ); lwc.sendLocale(player, "protection.interact.create.finalize"); } else if (protectionType.equals("password")) { String password = lwc.encrypt(protectionData); protection = physDb.registerProtection( block.getTypeId(), Protection.Type.PASSWORD, worldName, player.getUniqueId().toString(), password, blockX, blockY, blockZ); player.addAccessibleProtection(protection); lwc.sendLocale(player, "protection.interact.create.finalize"); lwc.sendLocale(player, "protection.interact.create.password"); } else if (protectionType.equals("private") || protectionType.equals("donation")) { String[] rights = protectionData.split(" "); protection = physDb.registerProtection( block.getTypeId(), Protection.Type.matchType(protectionType), worldName, player.getUniqueId().toString(), "", blockX, blockY, blockZ); lwc.sendLocale(player, "protection.interact.create.finalize"); lwc.processRightsModifications(player, protection, rights); } // tell the modules that a protection was registered if (protection != null) { // Fix the blocks that match it protection.removeCache(); LWC.getInstance().getProtectionCache().addProtection(protection); lwc.getModuleLoader().dispatchEvent(new LWCProtectionRegistrationPostEvent(protection)); } event.setResult(Result.CANCEL); }
/** * Send a performance report to a Console Sender * * @param sender */ public static void sendReport(CommandSender sender) { LWC lwc = LWC.getInstance(); sender.sendMessage(" "); sender.sendMessage(Colors.Red + "LWC Report"); sender.sendMessage(" Version: " + Colors.Green + LWCInfo.FULL_VERSION); sender.sendMessage( " Running time: " + Colors.Green + TimeUtil.timeToString(getTimeRunningSeconds())); sender.sendMessage( " Players: " + Colors.Green + Bukkit.getServer().getOnlinePlayers().length + "/" + Bukkit.getServer().getMaxPlayers()); sender.sendMessage( " Item entities: " + Colors.Green + getEntityCount(Item.class) + "/" + getEntityCount(null)); sender.sendMessage(" "); sender.sendMessage(Colors.Red + " ==== Modules ===="); for (Map.Entry<Plugin, List<MetaData>> entry : lwc.getModuleLoader().getRegisteredModules().entrySet()) { Plugin plugin = entry.getKey(); List<MetaData> modules = entry.getValue(); // Why? if (plugin == null) { continue; } sender.sendMessage( " " + Colors.Green + plugin.getDescription().getName() + " v" + plugin.getDescription().getVersion() + Colors.Yellow + " -> " + Colors.Green + modules.size() + Colors.Yellow + " registered modules"); } sender.sendMessage(" "); sender.sendMessage(Colors.Red + " ==== Database ===="); sender.sendMessage(" Engine: " + Colors.Green + Database.DefaultType); sender.sendMessage( " Protections: " + Colors.Green + formatNumber(lwc.getPhysicalDatabase().getProtectionCount())); sender.sendMessage( " Queries: " + Colors.Green + formatNumber(queries) + " | " + String.format("%.2f", getAverage(queries)) + " / second"); sender.sendMessage(" "); sender.sendMessage(Colors.Red + " ==== Cache ==== "); ProtectionCache cache = lwc.getProtectionCache(); sender.sendMessage(" Refs: " + cache.size() + "/" + cache.capacity()); sender.sendMessage( " Reads: " + formatNumber(cache.getReads()) + " | " + String.format("%.2f", getAverage(cache.getReads())) + " / second"); sender.sendMessage( " Writes: " + formatNumber(cache.getWrites()) + " | " + String.format("%.2f", getAverage(cache.getWrites())) + " / second"); }
/** * Log a string to stdout * * @param str The string to log */ public void log(String str) { LWC.getInstance().log(str); }
/** * Connect to MySQL * * @return if the connection was succesful */ public boolean connect() throws Exception { if (connection != null) { return true; } if (currentType == null || currentType == Type.NONE) { log("Invalid database engine"); return false; } // load the database jar ClassLoader classLoader; if (currentType == Type.SQLite) { classLoader = new URLClassLoader( new URL[] { new URL( "jar:file:" + new File(Updater.DEST_LIBRARY_FOLDER + currentType.getDriver()).getPath() + "!/") }); } else { classLoader = Bukkit.getServer().getClass().getClassLoader(); } // What class should we try to load? String className = ""; if (currentType == Type.MySQL) { className = "com.mysql.jdbc.Driver"; } else { className = "org.sqlite.JDBC"; } // Load the driver class Driver driver = (Driver) classLoader.loadClass(className).newInstance(); // Create the properties to pass to the driver Properties properties = new Properties(); // if we're using mysql, append the database info if (currentType == Type.MySQL) { LWC lwc = LWC.getInstance(); properties.put("autoReconnect", "true"); properties.put("user", lwc.getConfiguration().getString("database.username")); properties.put("password", lwc.getConfiguration().getString("database.password")); } // Connect to the database try { connection = driver.connect( "jdbc:" + currentType.toString().toLowerCase() + ":" + getDatabasePath(), properties); connected = true; return true; } catch (SQLException e) { log("Failed to connect to " + currentType); e.printStackTrace(); return false; } }
@Override public int getProtectionCount(Player player, Material material) { return LWC.getInstance().getPhysicalDatabase().getProtectionCount(player.getName()); }