worldofcraft/LuckPerms-DBA
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Catch and ignore exceptions thrown when migrating a specific entity

Browse Source
This commit is contained in:
Luck 2017-11-22 16:59:19 +00:00
parent e71ef834c0
commit 211fb219a7
No known key found for this signature in database
GPG Key ID: EFA9B3EC5FD90F8B
10 changed files with 193 additions and 185 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationBPermissions.java
View File

@ -47,6 +47,7 @@ import me.lucko.luckperms.common.model.User;
import me.lucko.luckperms.common.node.NodeFactory;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
@ -124,13 +125,14 @@ public class MigrationBPermissions extends SubCommand<Object> {
// Migrate one world at a time.
log.log("Starting world migration.");
for (World world : worldManager.getAllWorlds()) {
SafeIterator.iterate(worldManager.getAllWorlds(), world -> {
log.log("Migrating world: " + world.getName());
// Migrate all groups
log.log("Starting group migration in world " + world.getName() + ".");
AtomicInteger groupCount = new AtomicInteger(0);
for (Calculable group : world.getAll(CalculableType.GROUP)) {
SafeIterator.iterate(world.getAll(CalculableType.GROUP), group -> {
String groupName = MigrationUtils.standardizeName(group.getName());
if (group.getName().equalsIgnoreCase(world.getDefaultGroup())) {
groupName = "default";
@ -146,18 +148,18 @@ public class MigrationBPermissions extends SubCommand<Object> {
plugin.getStorage().saveGroup(lpGroup);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups in world " + world.getName() + ".");
// Migrate all users
log.log("Starting user migration in world " + world.getName() + ".");
AtomicInteger userCount = new AtomicInteger(0);
for (Calculable user : world.getAll(CalculableType.USER)) {
SafeIterator.iterate(world.getAll(CalculableType.USER), user -> {
// There is no mention of UUIDs in the API. I assume that name = uuid. idk?
UUID uuid = BukkitMigrationUtils.lookupUuid(log, user.getName());
if (uuid == null) {
continue;
return;
}
// Make a LuckPerms user for the one being migrated.
@ -170,10 +172,10 @@ public class MigrationBPermissions extends SubCommand<Object> {
plugin.getUserManager().cleanup(lpUser);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users in world " + world.getName() + ".");
}
});
log.log("Success! Migration complete.");
return CommandResult.SUCCESS;

78
bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationGroupManager.java
View File

@ -40,11 +40,10 @@ import me.lucko.luckperms.common.logging.ProgressLogger;
import me.lucko.luckperms.common.node.NodeFactory;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import org.anjocaido.groupmanager.GlobalGroups;
import org.anjocaido.groupmanager.GroupManager;
import org.anjocaido.groupmanager.data.Group;
import org.anjocaido.groupmanager.data.User;
import org.anjocaido.groupmanager.dataholder.WorldDataHolder;
import org.anjocaido.groupmanager.dataholder.worlds.WorldsHolder;
import org.bukkit.Bukkit;
@ -93,31 +92,24 @@ public class MigrationGroupManager extends SubCommand<Object> {
GlobalGroups gg = GroupManager.getGlobalGroups();
AtomicInteger globalGroupCount = new AtomicInteger(0);
for (Group g : gg.getGroupList()) {
SafeIterator.iterate(gg.getGroupList(), g -> {
String groupName = MigrationUtils.standardizeName(g.getName());
plugin.getStorage().createAndLoadGroup(groupName, CreationCause.INTERNAL).join();
me.lucko.luckperms.common.model.Group group = plugin.getGroupManager().getIfLoaded(groupName);
for (String node : g.getPermissionList()) {
if (node.isEmpty()) {
continue;
}
if (node.isEmpty()) continue;
group.setPermission(MigrationUtils.parseNode(node, true).build());
}
for (String s : g.getInherits()) {
if (s.isEmpty()) {
continue;
}
if (s.isEmpty()) continue;
group.setPermission(NodeFactory.make("group." + MigrationUtils.standardizeName(s)));
}
plugin.getStorage().saveGroup(group);
log.logAllProgress("Migrated {} groups so far.", globalGroupCount.incrementAndGet());
}
});
log.log("Migrated " + globalGroupCount.get() + " global groups");
// Collect data
@ -129,47 +121,32 @@ public class MigrationGroupManager extends SubCommand<Object> {
// Collect data for all users and groups.
log.log("Collecting user and group data.");
for (String world : worlds) {
world = world.toLowerCase();
SafeIterator.iterate(worlds, String::toLowerCase, world -> {
log.log("Querying world " + world);
WorldDataHolder wdh = wh.getWorldData(world);
AtomicInteger groupWorldCount = new AtomicInteger(0);
for (Group group : wdh.getGroupList()) {
SafeIterator.iterate(wdh.getGroupList(), group -> {
String groupName = MigrationUtils.standardizeName(group.getName());
groups.putIfAbsent(groupName, new HashSet<>());
for (String node : group.getPermissionList()) {
if (node.isEmpty()) {
continue;
}
if (node.isEmpty()) continue;
groups.get(groupName).add(MigrationUtils.parseNode(node, true).setWorld(worldMappingFunc.apply(world)).build());
}
for (String s : group.getInherits()) {
if (s.isEmpty()) {
continue;
}
if (s.isEmpty()) continue;
groups.get(groupName).add(NodeFactory.make("group." + MigrationUtils.standardizeName(s), true, null, worldMappingFunc.apply(world)));
}
String[] metaKeys = group.getVariables().getVarKeyList();
for (String key : metaKeys) {
String value = group.getVariables().getVarString(key);
key = key.toLowerCase();
if (key.isEmpty() || value.isEmpty()) {
continue;
}
if (key.equals("build")) {
continue;
}
if (key.isEmpty() || value.isEmpty()) continue;
if (key.equals("build")) continue;
if (key.equals("prefix") || key.equals("suffix")) {
ChatMetaType type = ChatMetaType.valueOf(key.toUpperCase());
@ -180,23 +157,20 @@ public class MigrationGroupManager extends SubCommand<Object> {
}
log.logAllProgress("Migrated {} groups so far in world " + world, groupWorldCount.incrementAndGet());
}
});
log.log("Migrated " + groupWorldCount.get() + " groups in world " + world);
AtomicInteger userWorldCount = new AtomicInteger(0);
for (User user : wdh.getUserList()) {
SafeIterator.iterate(wdh.getUserList(), user -> {
UUID uuid = BukkitMigrationUtils.lookupUuid(log, user.getUUID());
if (uuid == null) {
continue;
return;
}
users.putIfAbsent(uuid, new HashSet<>());
for (String node : user.getPermissionList()) {
if (node.isEmpty()) {
continue;
}
if (node.isEmpty()) continue;
users.get(uuid).add(MigrationUtils.parseNode(node, true).setWorld(worldMappingFunc.apply(world)).build());
}
@ -216,14 +190,8 @@ public class MigrationGroupManager extends SubCommand<Object> {
for (String key : metaKeys) {
String value = user.getVariables().getVarString(key);
key = key.toLowerCase();
if (key.isEmpty() || value.isEmpty()) {
continue;
}
if (key.equals("build")) {
continue;
}
if (key.isEmpty() || value.isEmpty()) continue;
if (key.equals("build")) continue;
if (key.equals("prefix") || key.equals("suffix")) {
ChatMetaType type = ChatMetaType.valueOf(key.toUpperCase());
@ -234,16 +202,16 @@ public class MigrationGroupManager extends SubCommand<Object> {
}
log.logProgress("Migrated {} users so far in world " + world, userWorldCount.incrementAndGet());
}
});
log.log("Migrated " + userWorldCount.get() + " users in world " + world);
}
});
log.log("All data has now been processed, now starting the import process.");
log.log("Found a total of " + users.size() + " users and " + groups.size() + " groups.");
log.log("Starting group migration.");
AtomicInteger groupCount = new AtomicInteger(0);
for (Map.Entry<String, Set<Node>> e : groups.entrySet()) {
SafeIterator.iterate(groups.entrySet(), e -> {
plugin.getStorage().createAndLoadGroup(e.getKey(), CreationCause.INTERNAL).join();
me.lucko.luckperms.common.model.Group group = plugin.getGroupManager().getIfLoaded(e.getKey());
@ -253,12 +221,12 @@ public class MigrationGroupManager extends SubCommand<Object> {
plugin.getStorage().saveGroup(group);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
log.log("Starting user migration.");
AtomicInteger userCount = new AtomicInteger(0);
for (Map.Entry<UUID, Set<Node>> e : users.entrySet()) {
SafeIterator.iterate(users.entrySet(), e -> {
plugin.getStorage().loadUser(e.getKey(), null).join();
me.lucko.luckperms.common.model.User user = plugin.getUserManager().getIfLoaded(e.getKey());
@ -276,7 +244,7 @@ public class MigrationGroupManager extends SubCommand<Object> {
plugin.getStorage().saveUser(user);
plugin.getUserManager().cleanup(user);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");

39
bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPermissionsEx.java
View File

@ -41,17 +41,15 @@ import me.lucko.luckperms.common.model.User;
import me.lucko.luckperms.common.node.NodeFactory;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import org.bukkit.Bukkit;
import ru.tehkode.permissions.NativeInterface;
import ru.tehkode.permissions.PermissionEntity;
import ru.tehkode.permissions.PermissionGroup;
import ru.tehkode.permissions.PermissionManager;
import ru.tehkode.permissions.PermissionUser;
import ru.tehkode.permissions.bukkit.PermissionsEx;
import java.lang.reflect.Field;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@ -79,27 +77,17 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
PermissionsEx pex = (PermissionsEx) Bukkit.getPluginManager().getPlugin("PermissionsEx");
PermissionManager manager = pex.getPermissionsManager();
NativeInterface ni;
try {
Field f = manager.getClass().getDeclaredField("nativeI");
f.setAccessible(true);
ni = (NativeInterface) f.get(manager);
} catch (Throwable t) {
t.printStackTrace();
return CommandResult.FAILURE;
}
log.log("Calculating group weightings.");
int maxWeight = 0;
int i = 0;
for (PermissionGroup group : manager.getGroupList()) {
maxWeight = Math.max(maxWeight, group.getRank());
i = Math.max(i, group.getRank());
}
maxWeight += 5;
int maxWeight = i + 5;
// Migrate all groups.
log.log("Starting group migration.");
AtomicInteger groupCount = new AtomicInteger(0);
for (PermissionGroup group : manager.getGroupList()) {
SafeIterator.iterate(manager.getGroupList(), group -> {
int groupWeight = maxWeight - group.getRank();
final String groupName = MigrationUtils.standardizeName(group.getName());
@ -113,7 +101,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
plugin.getStorage().saveGroup(lpGroup);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
// Migrate all users
@ -121,12 +109,12 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
AtomicInteger userCount = new AtomicInteger(0);
// Increment the max weight from the group migrations. All user meta should override.
maxWeight += 5;
int userWeight = maxWeight + 5;
for (PermissionUser user : manager.getUsers()) {
SafeIterator.iterate(manager.getUsers(), user -> {
UUID u = BukkitMigrationUtils.lookupUuid(log, user.getIdentifier());
if (u == null) {
continue;
return;
}
// load in a user instance
@ -134,7 +122,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
User lpUser = plugin.getUserManager().getIfLoaded(u);
// migrate data
migrateEntity(user, lpUser, maxWeight);
migrateEntity(user, lpUser, userWeight);
// Lowest rank is the highest group #logic
String primary = null;
@ -155,7 +143,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
plugin.getUserManager().cleanup(lpUser);
plugin.getStorage().saveUser(lpUser);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");
@ -175,10 +163,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
}
for (String node : worldData.getValue()) {
if (node.isEmpty()) {
continue;
}
if (node.isEmpty()) continue;
holder.setPermission(MigrationUtils.parseNode(node, true).setWorld(world).build());
}
}

44
bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationPowerfulPerms.java
View File

@ -25,8 +25,6 @@
package me.lucko.luckperms.bukkit.migration;
import lombok.SneakyThrows;
import com.github.cheesesoftware.PowerfulPermsAPI.CachedGroup;
import com.github.cheesesoftware.PowerfulPermsAPI.Group;
import com.github.cheesesoftware.PowerfulPermsAPI.Permission;
@ -53,6 +51,7 @@ import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.storage.StorageType;
import me.lucko.luckperms.common.utils.HikariSupplier;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import org.bukkit.Bukkit;
@ -66,6 +65,7 @@ import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;
@ -113,7 +113,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
try (Connection c = hikari.getConnection()) {
DatabaseMetaData meta = c.getMetaData();
try (ResultSet rs = meta.getTables(null, null, dbTable, null)) {
if (!rs.next()) {
log.log("Error - Couldn't find table.");
@ -125,7 +124,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
try (Connection c = hikari.getConnection()) {
try (PreparedStatement ps = c.prepareStatement("SELECT COLUMN_NAME, COLUMN_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME=?")) {
ps.setString(1, dbTable);
try (ResultSet rs = ps.executeQuery()) {
log.log("Found table: " + dbTable);
while (rs.next()) {
@ -133,7 +131,6 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
}
}
}
try (PreparedStatement ps = c.prepareStatement("SELECT `uuid` FROM " + dbTable)) {
try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
@ -158,17 +155,17 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
Collection<Group> groups = pm.getGroups().values();
int maxWeight = 0;
AtomicInteger maxWeight = new AtomicInteger(0);
// Groups first.
log.log("Starting group migration.");
AtomicInteger groupCount = new AtomicInteger(0);
for (Group g : groups) {
maxWeight = Math.max(maxWeight, g.getRank());
SafeIterator.iterate(groups, g -> {
maxWeight.set(Math.max(maxWeight.get(), g.getRank()));
final String groupName = MigrationUtils.standardizeName(g.getName());
String groupName = MigrationUtils.standardizeName(g.getName());
plugin.getStorage().createAndLoadGroup(groupName, CreationCause.INTERNAL).join();
final me.lucko.luckperms.common.model.Group group = plugin.getGroupManager().getIfLoaded(groupName);
me.lucko.luckperms.common.model.Group group = plugin.getGroupManager().getIfLoaded(groupName);
MigrationUtils.setGroupWeight(group, g.getRank());
@ -182,9 +179,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
// server --> prefix afaik
for (Map.Entry<String, String> prefix : g.getPrefixes().entrySet()) {
if (prefix.getValue().isEmpty()) {
continue;
}
if (prefix.getValue().isEmpty()) continue;
String server = prefix.getKey().toLowerCase();
if (prefix.getKey().equals("*") || prefix.getKey().equals("all")) {
@ -199,9 +194,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
}
for (Map.Entry<String, String> suffix : g.getSuffixes().entrySet()) {
if (suffix.getValue().isEmpty()) {
continue;
}
if (suffix.getValue().isEmpty()) continue;
String server = suffix.getKey().toLowerCase();
if (suffix.getKey().equals("*") || suffix.getKey().equals("all")) {
@ -217,7 +210,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
plugin.getStorage().saveGroup(group);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
// Migrate all users
@ -225,10 +218,10 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
AtomicInteger userCount = new AtomicInteger(0);
// Increment the max weight from the group migrations. All user meta should override.
maxWeight += 5;
maxWeight.addAndGet(5);
// Migrate all users and their groups
for (UUID uuid : uuids) {
SafeIterator.iterate(uuids, uuid -> {
// Create a LuckPerms user for the UUID
plugin.getStorage().loadUser(uuid, null).join();
@ -257,11 +250,11 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
String suffix = joinFuture(pm.getPlayerOwnSuffix(uuid));
if (prefix != null && !prefix.isEmpty()) {
user.setPermission(NodeFactory.makePrefixNode(maxWeight, prefix).build());
user.setPermission(NodeFactory.makePrefixNode(maxWeight.get(), prefix).build());
}
if (suffix != null && !suffix.isEmpty()) {
user.setPermission(NodeFactory.makeSuffixNode(maxWeight, suffix).build());
user.setPermission(NodeFactory.makeSuffixNode(maxWeight.get(), suffix).build());
}
Group primaryGroup = joinFuture(pm.getPlayerPrimaryGroup(uuid));
@ -276,7 +269,7 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
plugin.getUserManager().cleanup(user);
plugin.getStorage().saveUser(user);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");
@ -344,8 +337,11 @@ public class MigrationPowerfulPerms extends SubCommand<Object> {
holder.setPermission(nb.build());
}
@SneakyThrows
private static <T> T joinFuture(Future<T> future) {
return future.get();
try {
return future.get();
} catch (InterruptedException | ExecutionException e) {
throw new RuntimeException(e);
}
}
}

30
bukkit/src/main/java/me/lucko/luckperms/bukkit/migration/MigrationZPermissions.java
View File

@ -44,6 +44,7 @@ import me.lucko.luckperms.common.model.User;
import me.lucko.luckperms.common.node.NodeFactory;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import org.bukkit.Bukkit;
import org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService;
@ -103,14 +104,14 @@ public class MigrationZPermissions extends SubCommand<Object> {
Map<UUID, Set<Node>> userParents = new HashMap<>();
AtomicInteger groupCount = new AtomicInteger(0);
int maxWeight = 0;
for (PermissionEntity entity : internalService.getEntities(true)) {
AtomicInteger maxWeight = new AtomicInteger(0);
SafeIterator.iterate(internalService.getEntities(true), entity -> {
String groupName = MigrationUtils.standardizeName(entity.getDisplayName());
plugin.getStorage().createAndLoadGroup(groupName, CreationCause.INTERNAL).join();
Group group = plugin.getGroupManager().getIfLoaded(groupName);
int weight = entity.getPriority();
maxWeight = Math.max(maxWeight, weight);
maxWeight.set(Math.max(maxWeight.get(), weight));
migrateEntity(group, entity, weight);
MigrationUtils.setGroupWeight(group, weight);
@ -133,13 +134,13 @@ public class MigrationZPermissions extends SubCommand<Object> {
plugin.getStorage().saveGroup(group);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
// Migrate all tracks
log.log("Starting track migration.");
AtomicInteger trackCount = new AtomicInteger(0);
for (String t : service.getAllTracks()) {
SafeIterator.iterate(service.getAllTracks(), t -> {
String trackName = MigrationUtils.standardizeName(t);
plugin.getStorage().createAndLoadTrack(trackName, CreationCause.INTERNAL).join();
@ -148,18 +149,18 @@ public class MigrationZPermissions extends SubCommand<Object> {
plugin.getStorage().saveTrack(track);
log.logAllProgress("Migrated {} tracks so far.", trackCount.incrementAndGet());
}
});
log.log("Migrated " + trackCount.get() + " tracks");
// Migrate all users.
log.log("Starting user migration.");
maxWeight += 10;
maxWeight.addAndGet(10);
AtomicInteger userCount = new AtomicInteger(0);
Set<UUID> usersToMigrate = new HashSet<>(userParents.keySet());
usersToMigrate.addAll(service.getAllPlayersUUID());
for (UUID u : usersToMigrate) {
SafeIterator.iterate(usersToMigrate, u -> {
PermissionEntity entity = internalService.getEntity(null, u, false);
String username = null;
@ -172,7 +173,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
// migrate permissions & meta
if (entity != null) {
migrateEntity(user, entity, maxWeight);
migrateEntity(user, entity, maxWeight.get());
}
// migrate groups
@ -186,7 +187,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
plugin.getUserManager().cleanup(user);
plugin.getStorage().saveUser(user);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");
@ -195,9 +196,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
private void migrateEntity(PermissionHolder holder, PermissionEntity entity, int weight) {
for (Entry e : entity.getPermissions()) {
if (e.getPermission().isEmpty()) {
continue;
}
if (e.getPermission().isEmpty()) continue;
if (e.getWorld() != null && !e.getWorld().getName().equals("")) {
holder.setPermission(NodeFactory.newBuilder(e.getPermission()).setValue(e.isValue()).setWorld(e.getWorld().getName()).build());
@ -217,10 +216,7 @@ public class MigrationZPermissions extends SubCommand<Object> {
for (EntityMetadata metadata : entity.getMetadata()) {
String key = metadata.getName().toLowerCase();
if (key.isEmpty() || metadata.getStringValue().isEmpty()) {
continue;
}
if (key.isEmpty() || metadata.getStringValue().isEmpty()) continue;
if (key.equals("prefix") || key.equals("suffix")) {
ChatMetaType type = ChatMetaType.valueOf(key.toUpperCase());

42
bungee/src/main/java/me/lucko/luckperms/bungee/migration/MigrationBungeePerms.java
View File

@ -39,12 +39,12 @@ import me.lucko.luckperms.common.model.PermissionHolder;
import me.lucko.luckperms.common.node.NodeFactory;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import net.alpenblock.bungeeperms.BungeePerms;
import net.alpenblock.bungeeperms.Group;
import net.alpenblock.bungeeperms.PermEntity;
import net.alpenblock.bungeeperms.Server;
import net.alpenblock.bungeeperms.User;
import net.alpenblock.bungeeperms.World;
import java.util.List;
@ -74,16 +74,16 @@ public class MigrationBungeePerms extends SubCommand<Object> {
List<Group> groups = bp.getPermissionsManager().getBackEnd().loadGroups();
log.log("Calculating group weightings.");
int maxWeight = 0;
int i = 0;
for (Group group : groups) {
maxWeight = Math.max(maxWeight, group.getRank());
i = Math.max(i, group.getRank());
}
maxWeight += 5;
int maxWeight = i + 5;
// Migrate all groups.
log.log("Starting group migration.");
AtomicInteger groupCount = new AtomicInteger(0);
for (Group g : groups) {
SafeIterator.iterate(groups, g -> {
int groupWeight = maxWeight - g.getRank();
// Make a LuckPerms group for the one being migrated
@ -96,7 +96,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
plugin.getStorage().saveGroup(group);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
// Migrate all users.
@ -104,25 +104,25 @@ public class MigrationBungeePerms extends SubCommand<Object> {
AtomicInteger userCount = new AtomicInteger(0);
// Increment the max weight from the group migrations. All user meta should override.
maxWeight += 5;
int userWeight = maxWeight + 5;
for (User u : bp.getPermissionsManager().getBackEnd().loadUsers()) {
SafeIterator.iterate(bp.getPermissionsManager().getBackEnd().loadUsers(), u -> {
if (u.getUUID() == null) {
log.logErr("Could not parse UUID for user: " + u.getName());
continue;
return;
}
// Make a LuckPerms user for the one being migrated.
plugin.getStorage().loadUser(u.getUUID(), u.getName()).join();
me.lucko.luckperms.common.model.User user = plugin.getUserManager().getIfLoaded(u.getUUID());
migrateHolder(u, u.getGroupsString(), maxWeight, user);
migrateHolder(u, u.getGroupsString(), userWeight, user);
plugin.getStorage().saveUser(user);
plugin.getUserManager().cleanup(user);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");
@ -132,30 +132,21 @@ public class MigrationBungeePerms extends SubCommand<Object> {
private static void migrateHolder(PermEntity entity, List<String> parents, int weight, PermissionHolder holder) {
// Migrate global perms
for (String perm : entity.getPerms()) {
if (perm.isEmpty()) {
continue;
}
if (perm.isEmpty()) continue;
holder.setPermission(MigrationUtils.parseNode(perm, true).build());
}
// Migrate per-server perms
for (Map.Entry<String, Server> e : entity.getServers().entrySet()) {
for (String perm : e.getValue().getPerms()) {
if (perm.isEmpty()) {
continue;
}
if (perm.isEmpty()) continue;
holder.setPermission(MigrationUtils.parseNode(perm, true).setServer(e.getKey()).build());
}
// Migrate per-world perms
for (Map.Entry<String, World> we : e.getValue().getWorlds().entrySet()) {
for (String perm : we.getValue().getPerms()) {
if (perm.isEmpty()) {
continue;
}
if (perm.isEmpty()) continue;
holder.setPermission(MigrationUtils.parseNode(perm, true).setServer(e.getKey()).setWorld(we.getKey()).build());
}
}
@ -163,10 +154,7 @@ public class MigrationBungeePerms extends SubCommand<Object> {
// Migrate any parent groups
for (String inherit : parents) {
if (inherit.isEmpty()) {
continue;
}
if (inherit.isEmpty()) continue;
holder.setPermission(NodeFactory.make("group." + MigrationUtils.standardizeName(inherit)));
}

5
common/src/main/java/me/lucko/luckperms/common/utils/Predicates.java
View File

@ -35,19 +35,18 @@ import java.util.stream.IntStream;
/**
* A collection of predicate utilities used mostly in command classes
*/
@SuppressWarnings({"WeakerAccess", "unused"})
@UtilityClass
public class Predicates {
private static final Predicate FALSE = o -> false;
private static final Predicate TRUE = o -> true;
@SuppressWarnings("unchecked")
public static <T> Predicate<T> alwaysFalse() {
//noinspection unchecked
return FALSE;
}
@SuppressWarnings("unchecked")
public static <T> Predicate<T> alwaysTrue() {
//noinspection unchecked
return TRUE;
}

76
common/src/main/java/me/lucko/luckperms/common/utils/SafeIterator.java Normal file
View File

@ -0,0 +1,76 @@
/*
* This file is part of LuckPerms, licensed under the MIT License.
*
* Copyright (c) lucko (Luck) <luck@lucko.me>
* Copyright (c) contributors
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package me.lucko.luckperms.common.utils;
import lombok.experimental.UtilityClass;
import java.util.function.Consumer;
import java.util.function.Function;
@UtilityClass
public class SafeIterator {
public static <I> void iterate(Iterable<I> iterable, Consumer<I> action) {
for (I i : iterable) {
try {
action.accept(i);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static <I, O> void iterate(Iterable<I> iterable, Function<I, O> mapping, Consumer<O> action) {
for (I i : iterable) {
try {
action.accept(mapping.apply(i));
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static <I> void iterate(I[] array, Consumer<I> action) {
for (I i : array) {
try {
action.accept(i);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public static <I, O> void iterate(I[] array, Function<I, O> mapping, Consumer<O> action) {
for (I i : array) {
try {
action.accept(mapping.apply(i));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

17
sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionManager.java
View File

@ -40,14 +40,13 @@ import me.lucko.luckperms.common.model.Group;
import me.lucko.luckperms.common.model.User;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import me.lucko.luckperms.sponge.LPSpongePlugin;
import me.lucko.luckperms.sponge.service.LuckPermsService;
import org.spongepowered.api.Sponge;
import org.spongepowered.api.plugin.PluginContainer;
import org.spongepowered.api.service.permission.PermissionService;
import org.spongepowered.api.service.permission.Subject;
import org.spongepowered.api.service.permission.SubjectCollection;
import java.lang.reflect.Method;
import java.util.List;
@ -93,18 +92,18 @@ public class MigrationPermissionManager extends SubCommand<Object> {
// Migrate defaults
log.log("Migrating default subjects.");
for (SubjectCollection collection : pmService.getKnownSubjects().values()) {
SafeIterator.iterate(pmService.getKnownSubjects().values(), collection -> {
migrateSubjectData(
collection.getDefaults().getSubjectData(),
lpService.getCollection("defaults").loadSubject(collection.getIdentifier()).join().sponge().getSubjectData()
);
}
});
migrateSubjectData(pmService.getDefaults().getSubjectData(), lpService.getDefaults().sponge().getSubjectData());
// Migrate groups
log.log("Starting group migration.");
AtomicInteger groupCount = new AtomicInteger(0);
for (Subject pmGroup : pmService.getGroupSubjects().getAllSubjects()) {
SafeIterator.iterate(pmService.getGroupSubjects().getAllSubjects(), pmGroup -> {
String pmName = MigrationUtils.standardizeName(pmGroup.getIdentifier());
// Make a LuckPerms group for the one being migrated
@ -114,17 +113,17 @@ public class MigrationPermissionManager extends SubCommand<Object> {
plugin.getStorage().saveGroup(group);
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
// Migrate users
log.log("Starting user migration.");
AtomicInteger userCount = new AtomicInteger(0);
for (Subject pmUser : pmService.getUserSubjects().getAllSubjects()) {
SafeIterator.iterate(pmService.getUserSubjects().getAllSubjects(), pmUser -> {
UUID uuid = CommandUtils.parseUuid(pmUser.getIdentifier());
if (uuid == null) {
log.logErr("Could not parse UUID for user: " + pmUser.getIdentifier());
continue;
return;
}
// Make a LuckPerms user for the one being migrated
@ -138,7 +137,7 @@ public class MigrationPermissionManager extends SubCommand<Object> {
plugin.getUserManager().cleanup(user);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");

31
sponge/src/main/java/me/lucko/luckperms/sponge/migration/MigrationPermissionsEx.java
View File

@ -41,6 +41,7 @@ import me.lucko.luckperms.common.model.Track;
import me.lucko.luckperms.common.model.User;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.utils.Predicates;
import me.lucko.luckperms.common.utils.SafeIterator;
import me.lucko.luckperms.sponge.LPSpongePlugin;
import me.lucko.luckperms.sponge.service.LuckPermsService;
@ -48,7 +49,6 @@ import org.spongepowered.api.Sponge;
import org.spongepowered.api.plugin.PluginContainer;
import org.spongepowered.api.service.permission.PermissionService;
import org.spongepowered.api.service.permission.Subject;
import org.spongepowered.api.service.permission.SubjectCollection;
import java.util.Comparator;
import java.util.HashMap;
@ -89,33 +89,32 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
// Migrate defaults
log.log("Migrating default subjects.");
for (SubjectCollection collection : pexService.getKnownSubjects().values()) {
SafeIterator.iterate(pexService.getKnownSubjects().values(), collection -> {
migrateSubjectData(
collection.getDefaults().getSubjectData(),
lpService.getCollection("defaults").loadSubject(collection.getIdentifier()).join().sponge().getSubjectData()
);
}
});
migrateSubjectData(pexService.getDefaults().getSubjectData(), lpService.getDefaults().sponge().getSubjectData());
log.log("Calculating group weightings.");
int maxWeight = 0;
int i = 0;
for (Subject pexGroup : pexService.getGroupSubjects().getAllSubjects()) {
Optional<String> pos = pexGroup.getOption("rank");
if (pos.isPresent()) {
try {
int i = Integer.parseInt(pos.get());
maxWeight = Math.max(maxWeight, i);
i = Math.max(i, Integer.parseInt(pos.get()));
} catch (NumberFormatException ignored) {}
}
}
maxWeight += 5;
int maxWeight = i + 5;
Map<String, TreeMap<Integer, String>> tracks = new HashMap<>();
// Migrate groups
log.log("Starting group migration.");
AtomicInteger groupCount = new AtomicInteger(0);
for (Subject pexGroup : pexService.getGroupSubjects().getAllSubjects()) {
SafeIterator.iterate(pexService.getGroupSubjects().getAllSubjects(), pexGroup -> {
String pexName = MigrationUtils.standardizeName(pexGroup.getIdentifier());
Optional<String> rankString = pexGroup.getOption("rank");
@ -149,12 +148,12 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
}
log.logAllProgress("Migrated {} groups so far.", groupCount.incrementAndGet());
}
});
log.log("Migrated " + groupCount.get() + " groups");
// Migrate tracks
log.log("Starting track migration.");
for (Map.Entry<String, TreeMap<Integer, String>> e : tracks.entrySet()) {
SafeIterator.iterate(tracks.entrySet(), e -> {
plugin.getStorage().createAndLoadTrack(e.getKey(), CreationCause.INTERNAL).join();
Track track = plugin.getTrackManager().getIfLoaded(e.getKey());
for (String groupName : e.getValue().values()) {
@ -163,7 +162,7 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
track.appendGroup(group);
}
}
}
});
log.log("Migrated " + tracks.size() + " tracks");
// Migrate users
@ -171,13 +170,13 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
AtomicInteger userCount = new AtomicInteger(0);
// Increment the max weight from the group migrations. All user meta should override.
maxWeight += 5;
int userWeight = maxWeight + 5;
for (Subject pexUser : pexService.getUserSubjects().getAllSubjects()) {
SafeIterator.iterate(pexService.getUserSubjects().getAllSubjects(), pexUser -> {
UUID uuid = CommandUtils.parseUuid(pexUser.getIdentifier());
if (uuid == null) {
log.logErr("Could not parse UUID for user: " + pexUser.getIdentifier());
continue;
return;
}
// Make a LuckPerms user for the one being migrated
@ -186,12 +185,12 @@ public class MigrationPermissionsEx extends SubCommand<Object> {
if (user.getEnduringNodes().size() <= 1) {
user.clearNodes(false);
}
migrateSubject(pexUser, user, maxWeight);
migrateSubject(pexUser, user, userWeight);
plugin.getStorage().saveUser(user);
plugin.getUserManager().cleanup(user);
log.logProgress("Migrated {} users so far.", userCount.incrementAndGet());
}
});
log.log("Migrated " + userCount.get() + " users.");
log.log("Success! Migration complete.");