示例#1
0
 public Map<String, UUID> call() throws Exception {
   Map<String, UUID> uuidMap = new HashMap<String, UUID>();
   int requests = (int) Math.ceil(names.size() / PROFILES_PER_REQUEST);
   for (int i = 0; i < requests; i++) {
     HttpURLConnection connection = createConnection();
     String body =
         JSONArray.toJSONString(names.subList(i * 100, Math.min((i + 1) * 100, names.size())));
     writeBody(connection, body);
     JSONArray array =
         (JSONArray) jsonParser.parse(new InputStreamReader(connection.getInputStream()));
     for (Object profile : array) {
       JSONObject jsonProfile = (JSONObject) profile;
       String id = (String) jsonProfile.get("id");
       String name = (String) jsonProfile.get("name");
       UUID uuid = UUIDFetcher.getUUID(id);
       uuidMap.put(name, uuid);
     }
     if (rateLimiting && i != requests - 1) {
       Thread.sleep(100L);
     }
   }
   return uuidMap;
 }
示例#2
0
  public final UUID getTranslatedUuid(@NonNull String player, boolean expensiveLookups) {
    // If the player is online, give them their UUID.
    // Remember, local data > remote data.
    if (ProxyServer.getInstance().getPlayer(player) != null)
      return ProxyServer.getInstance().getPlayer(player).getUniqueId();

    // Check if it exists in the map
    CachedUUIDEntry cachedUUIDEntry = nameToUuidMap.get(player.toLowerCase());
    if (cachedUUIDEntry != null) {
      if (!cachedUUIDEntry.expired()) return cachedUUIDEntry.getUuid();
      else nameToUuidMap.remove(player);
    }

    // Check if we can exit early
    if (UUID_PATTERN.matcher(player).find()) {
      return UUID.fromString(player);
    }

    if (MOJANGIAN_UUID_PATTERN.matcher(player).find()) {
      // Reconstruct the UUID
      return UUIDFetcher.getUUID(player);
    }

    // If we are in offline mode, UUID generation is simple.
    // We don't even have to cache the UUID, since this is easy to recalculate.
    if (!plugin.getProxy().getConfig().isOnlineMode()) {
      return UUID.nameUUIDFromBytes(("OfflinePlayer:" + player).getBytes(Charsets.UTF_8));
    }

    // Let's try Redis.
    try (Jedis jedis = plugin.getPool().getResource()) {
      String stored = jedis.hget("uuid-cache", player.toLowerCase());
      if (stored != null) {
        // Found an entry value. Deserialize it.
        CachedUUIDEntry entry = RedisBungee.getGson().fromJson(stored, CachedUUIDEntry.class);

        // Check for expiry:
        if (entry.expired()) {
          jedis.hdel("uuid-cache", player.toLowerCase());
          // Doesn't hurt to also remove the UUID entry as well.
          jedis.hdel("uuid-cache", entry.getUuid().toString());
        } else {
          nameToUuidMap.put(player.toLowerCase(), entry);
          uuidToNameMap.put(entry.getUuid(), entry);
          return entry.getUuid();
        }
      }

      // That didn't work. Let's ask Mojang.
      if (!expensiveLookups || !ProxyServer.getInstance().getConfig().isOnlineMode()) return null;

      Map<String, UUID> uuidMap1;
      try {
        uuidMap1 = new UUIDFetcher(Collections.singletonList(player)).call();
      } catch (Exception e) {
        plugin.getLogger().log(Level.SEVERE, "Unable to fetch UUID from Mojang for " + player, e);
        return null;
      }
      for (Map.Entry<String, UUID> entry : uuidMap1.entrySet()) {
        if (entry.getKey().equalsIgnoreCase(player)) {
          persistInfo(entry.getKey(), entry.getValue(), jedis);
          return entry.getValue();
        }
      }
    } catch (JedisException e) {
      plugin.getLogger().log(Level.SEVERE, "Unable to fetch UUID for " + player, e);
    }

    return null; // Nope, game over!
  }