user flags + partial offline users in whitelist and ops (#583)

Co-authored-by: Geoff Bourne <[email protected]>

Author: FedotCompot

README.md

@@ -761,15 +761,17 @@ Usage: mc-image-helper manage-users [-fh] [--existing=<existingFileBehavior>]
                                     >] -t=<type>
                                     [--user-api-provider=<userApiProvider>]
                                     [--version=<version>]
+                                    [--offline]
                                     [[--http-response-timeout=DURATION]
                                     [--tls-handshake-timeout=DURATION]
                                     [--connection-pool-pending-acquire-timeout=D
                                     URATION]
                                     [--connection-pool-max-idle-timeout=DURATION
                                     ]] [INPUT[,INPUT...]...]
       [INPUT[,INPUT...]...] One or more Mojang usernames, UUID, or ID (UUID
-                              without dashes); however, when offline, only
-                              UUID/IDs can be provided.
+                              without dashes); flags are listed after a colon
+                              separated by comma:
+                              <username/UUID/ID>:flag1,flag2
                             When input is a file, only one local file path or
                               URL can be provided
       --connection-pool-max-idle-timeout=DURATION
@@ -798,6 +800,8 @@ Usage: mc-image-helper manage-users [-fh] [--existing=<existingFileBehavior>]
                             Allowed: mojang, playerdb
       --version=<version>   Minecraft game version. If not provided, assumes
                               JSON format
+      --offline             Server is in offline mode, for users that have the
+                              offline flag the UUID is generated locally 
 ```
 
 ### maven-download

src/main/java/me/itzg/helpers/users/ManageUsersCommand.java

@@ -16,6 +16,8 @@
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.Callable;
+import java.util.stream.Collectors;
+
 import lombok.extern.slf4j.Slf4j;
 import me.itzg.helpers.errors.GenericException;
 import me.itzg.helpers.errors.InvalidParameterException;
@@ -26,6 +28,7 @@
 import me.itzg.helpers.json.ObjectMappers;
 import me.itzg.helpers.users.model.JavaOp;
 import me.itzg.helpers.users.model.JavaUser;
+import me.itzg.helpers.users.model.UserDef;
 
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.maven.artifact.versioning.ComparableVersion;
@@ -114,8 +117,9 @@ public Integer call() throws Exception {
     }
 
     private void processJavaUserIdList(SharedFetch sharedFetch, List<String> inputs) throws IOException {
+        List<UserDef> userDefs = inputs.stream().map(input -> new UserDef(input)).collect(Collectors.toList());
         if (usesTextUserList()) {
-            verifyNotUuids(inputs);
+            verifyNotUuids(userDefs);
 
             final Path resultFile = outputDirectory.resolve(
                 type == Type.JAVA_OPS ? "ops.txt" : "white-list.txt"
@@ -126,8 +130,9 @@ private void processJavaUserIdList(SharedFetch sharedFetch, List<String> inputs)
             }
 
             final Set<String> users = loadExistingTextUserList(resultFile);
-
-            users.addAll(inputs);
+            for (final UserDef user : userDefs) {
+                users.add(user.getName());
+            }
 
             log.debug("Writing users list to {}: {}", resultFile, users);
             Files.write(resultFile, users);
@@ -142,7 +147,7 @@ private void processJavaUserIdList(SharedFetch sharedFetch, List<String> inputs)
             }
 
             objectMapper.writeValue(resultFile.toFile(),
-                reconcile(sharedFetch, inputs,
+                reconcile(sharedFetch, userDefs,
                     loadExistingJavaJson(resultFile)
                 )
             );
@@ -158,7 +163,7 @@ private boolean handleSkipExistingFile(Path resultFile) {
         return false;
     }
 
-    private List<? extends JavaUser> reconcile(SharedFetch sharedFetch, List<String> inputs, List<? extends JavaUser> existing) {
+    private List<? extends JavaUser> reconcile(SharedFetch sharedFetch, List<UserDef> userDefs, List<? extends JavaUser> existing) {
 
         final List<JavaUser> reconciled;
         if (existingFileBehavior == ExistingFileBehavior.MERGE) {
@@ -168,8 +173,8 @@ private List<? extends JavaUser> reconcile(SharedFetch sharedFetch, List<String>
             reconciled = new ArrayList<>(inputs.size());
         }
 
-        for (final String input : inputs) {
-            final JavaUser resolvedUser = resolveJavaUserId(sharedFetch, existing, input.trim());
+        for (final UserDef userDef : userDefs) {
+            final JavaUser resolvedUser = resolveJavaUserId(sharedFetch, existing, userDef);
 
             if (existingFileBehavior == ExistingFileBehavior.SYNCHRONIZE
                     || !containsUserByUuid(reconciled, resolvedUser.getUuid())) {
@@ -203,18 +208,18 @@ private boolean containsUserByUuid(List<JavaUser> users, String uuid) {
         return false;
     }
 
-    private JavaUser resolveJavaUserId(SharedFetch sharedFetch, List<? extends JavaUser> existing, String input) {
+    private JavaUser resolveJavaUserId(SharedFetch sharedFetch, List<? extends JavaUser> existing, UserDef user) {
 
-        return UuidQuirks.ifIdOrUuid(input)
+        return UuidQuirks.ifIdOrUuid(user.getName())
             .map(uuid -> {
                 for (final JavaUser existingUser : existing) {
                     if (existingUser.getUuid().equalsIgnoreCase(uuid)) {
-                        log.debug("Resolved '{}' from existing user entry by UUID: {}", input, existingUser);
+                        log.debug("Resolved '{}' from existing user entry by UUID: {}", user.getName(), existingUser);
                         return existingUser;
                     }
                 }
 
-                log.debug("Resolved '{}' into new user entry", input);
+                log.debug("Resolved '{}' into new user entry", user.getName());
                 return JavaUser.builder()
                     .uuid(uuid)
                     // username needs to be present, but content doesn't matter
@@ -223,34 +228,46 @@ private JavaUser resolveJavaUserId(SharedFetch sharedFetch, List<? extends JavaU
 
             })
             .orElseGet(() -> {
+                // User to be used
+                JavaUser finalUser = null;
 
-                // ...or username
+                // Try to find user in existing users list
                 for (final JavaUser existingUser : existing) {
-                    if (existingUser.getName().equalsIgnoreCase(input)) {
-                        log.debug("Resolved '{}' from existing user entry by name: {}", input, existingUser);
-                        return existingUser;
+                    if (existingUser.getName().equalsIgnoreCase(user.getName())) {
+                        log.debug("Resolved '{}' from existing user entry by name: {}", user.getName(), existingUser);
+                        finalUser = existingUser;
                     }
                 }
 
+                // If existing user is not found, build a new one
+                if (finalUser == null) {
+                    finalUser = JavaUser.builder().name(user.getName()).build();
+                }
+
+                // User is not online, generating offline UUID
+                if (offline && user.getFlags().contains("offline")) {
+                    log.debug("Resolved '{}' as offline user", user.getName());
+                    // update UUID keeping the other fields in case of existing user
+                    return finalUser.setUuid(getOfflineUUID(user.getName()));
+                }
+
                 final Path userCacheFile = outputDirectory.resolve("usercache.json");
                 if (Files.exists(userCacheFile)) {
                     try {
                         final List<JavaUser> userCache = objectMapper.readValue(userCacheFile.toFile(), LIST_OF_JAVA_USER);
                         for (final JavaUser existingUser : userCache) {
-                            if (existingUser.getName().equalsIgnoreCase(input)) {
-                                log.debug("Resolved '{}' from user cache by name: {}", input, existingUser);
-                                return existingUser;
+                            if (existingUser.getName().equalsIgnoreCase(user.getName())) {
+                                log.debug("Resolved '{}' from user cache by name: {}", user.getName(), existingUser);
+                                // UUID from usercache.jsona are safe to use regardless of the user type
+                                // if a UUID is present here, user joined successfully with that UUID
+                                return finalUser.setUuid(existingUser.getUuid());
                             }
                         }
                     } catch (IOException e) {
                         log.error("Failed to parse usercache.json", e);
                     }
                 }
 
-                if (offline) {
-                    return getOfflineUUID(input);
-                }
-
                 final UserApi userApi;
                 switch (userApiProvider) {
                     case mojang:
@@ -262,8 +279,14 @@ private JavaUser resolveJavaUserId(SharedFetch sharedFetch, List<? extends JavaU
                     default:
                         throw new GenericException("User API provider was not specified");
                 }
-                return userApi.resolveUser(input);
+                JavaUser apiUser = userApi.resolveUser(user.getName());
 
+                if (finalUser != null) {
+                    return finalUser.setUuid(apiUser.getUuid());
+                }
+                else {
+                    return apiUser;
+                }
             });
 
     }
@@ -293,10 +316,10 @@ private Set<String> loadExistingTextUserList(Path resultFile) throws IOException
         return new HashSet<>();
     }
 
-    private void verifyNotUuids(List<String> inputs) {
-        for (final String input : inputs) {
-            if (UuidQuirks.isIdOrUuid(input)) {
-                throw new InvalidParameterException("UUID cannot be provided: " + input);
+    private void verifyNotUuids(List<UserDef> userDefs) {
+        for (final UserDef user : userDefs) {
+            if (UuidQuirks.isIdOrUuid(user.getName())) {
+                throw new InvalidParameterException("UUID cannot be provided: " + user.getName());
             }
         }
     }
@@ -341,8 +364,8 @@ private boolean usesTextUserList() {
         return version != null && new ComparableVersion(version).compareTo(MIN_VERSION_USES_JSON) < 0;
     }
 
-    private static JavaUser getOfflineUUID(String username) {
-        byte[] bytes = DigestUtils.md5("OfflinePlayer:"+username);
+    private static String getOfflineUUID(String username) {
+        byte[] bytes = DigestUtils.md5("OfflinePlayer:" + username);
 
         // Force version = 3 (bits 12-15 of time_hi_and_version)
         bytes[6] &= 0x0F;
@@ -363,9 +386,6 @@ private static JavaUser getOfflineUUID(String username) {
             lsb = (lsb << 8) | (bytes[i] & 0xFF);
         }
 
-        return JavaUser.builder()
-        .name(username)
-        .uuid(new UUID(msb, lsb).toString())
-        .build();
+        return new UUID(msb, lsb).toString();
     }
 }

src/main/java/me/itzg/helpers/users/model/JavaUser.java

@@ -1,13 +1,14 @@
 package me.itzg.helpers.users.model;
 
 import lombok.Data;
+import lombok.Setter;
 import lombok.experimental.SuperBuilder;
 import lombok.extern.jackson.Jacksonized;
 
-@Data @SuperBuilder
+@Data @Setter @SuperBuilder
 @Jacksonized
 public class JavaUser {
     final String name;
 
-    final String uuid;
+    String uuid;
 }

src/main/java/me/itzg/helpers/users/model/UserDef.java

@@ -0,0 +1,32 @@
+package me.itzg.helpers.users.model;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import lombok.Data;
+import lombok.experimental.SuperBuilder;
+import lombok.extern.jackson.Jacksonized;
+
+@Data
+@SuperBuilder
+@Jacksonized
+public class UserDef {
+    final String name;
+    final List<String> flags;
+
+    public UserDef(String input) {
+        final int colonIndex = input.trim().indexOf(':');
+        if (colonIndex < 0) {
+            name = input.trim();
+            flags = new ArrayList<>();
+            return;
+        }
+        name = input.substring(0, colonIndex).trim();
+        flags = Arrays.stream(input.substring(colonIndex + 1).split(","))
+                .map(String::trim)
+                .filter(flag -> !flag.isEmpty())
+                .collect(Collectors.toList());
+    }
+}