LiteLoader / LiteLoader · Commits

Commit 3fb6dc861087ed3d2ded6c6e14660fc6fd5b773f

Authored by Mumfrey
1 parent 81beb05d

Add WebPrefs framework, detail: https://github.com/Mumfrey/webprefs

Inline Side-by-side
Showing 33 changed files with 2734 additions and 0 deletions
src/client/java/com/mumfrey/webprefs/WebPreferences.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs;
  2 +
  3 +import java.util.HashMap;
  4 +import java.util.HashSet;
  5 +import java.util.Map;
  6 +import java.util.Set;
  7 +import java.util.concurrent.ConcurrentHashMap;
  8 +import java.util.regex.Pattern;
  9 +
  10 +import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
  11 +import com.mumfrey.webprefs.exceptions.InvalidKeyException;
  12 +import com.mumfrey.webprefs.exceptions.InvalidValueException;
  13 +import com.mumfrey.webprefs.exceptions.ReadOnlyPreferencesException;
  14 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  15 +import com.mumfrey.webprefs.interfaces.IWebPreferences;
  16 +import com.mumfrey.webprefs.interfaces.IWebPreferencesClient;
  17 +import com.mumfrey.webprefs.interfaces.IWebPreferencesProvider;
  18 +
  19 +class WebPreferences implements IWebPreferences
  20 +{
  21 + /**
  22 + * The update frequency to use when operating normally, this is the
  23 + * frequency that new requests will be submitted to the remote request queue
  24 + */
  25 + private static final int UPDATE_FREQUENCY_TICKS = 20; // 1 second
  26 +
  27 + /**
  28 + * Number of ticks to wait before a request is assumed to have timed out
  29 + */
  30 + private static final int REQUEST_TIMEOUT_TICKS = 20 * 60; // 1 minute
  31 +
  32 + /**
  33 + * Number of ticks to wait on any communication error (request failed at the
  34 + * server, request failed to be submitted, request timed out, etc.)
  35 + */
  36 + private static final int UPDATE_ERROR_SUSPEND_TICKS = 20 * 60; // 1 minute
  37 +
  38 + /**
  39 + * Pattern for validating keys
  40 + */
  41 + private static final Pattern keyPattern = Pattern.compile("^[a-z0-9_\\-\\.]{1,32}$");
  42 +
  43 + /**
  44 + * Preferences client, this is a delegate which is used to communicate with
  45 + * the preferences provider
  46 + *
  47 + * @author Adam Mummery-Smith
  48 + */
  49 + class Client implements IWebPreferencesClient
  50 + {
  51 + @Override
  52 + public void onGetRequestSuccess(String uuid, Map<String, String> values)
  53 + {
  54 + if (!WebPreferences.this.uuid.equals(uuid))
  55 + {
  56 + throw new RuntimeException("Received unsolicited response");
  57 + }
  58 +
  59 + WebPreferences.this.onGetRequestSuccess(values);
  60 + }
  61 +
  62 + @Override
  63 + public void onSetRequestSuccess(String uuid, Set<String> keys)
  64 + {
  65 + if (!WebPreferences.this.uuid.equals(uuid))
  66 + {
  67 + throw new RuntimeException("Received unsolicited response");
  68 + }
  69 +
  70 + WebPreferences.this.onSetRequestSuccess(keys);
  71 + }
  72 +
  73 + @Override
  74 + public void onGetRequestFailed(String uuid, Set<String> keys, RequestFailureReason reason)
  75 + {
  76 + if (!WebPreferences.this.uuid.equals(uuid))
  77 + {
  78 + throw new RuntimeException("Received unsolicited response");
  79 + }
  80 +
  81 + WebPreferences.this.onGetRequestFailed(keys, reason);
  82 + }
  83 +
  84 + @Override
  85 + public void onSetRequestFailed(String uuid, Set<String> keys, RequestFailureReason reason)
  86 + {
  87 + if (!WebPreferences.this.uuid.equals(uuid))
  88 + {
  89 + throw new RuntimeException("Received unsolicited response");
  90 + }
  91 +
  92 + WebPreferences.this.onSetRequestFailed(keys, reason);
  93 + }
  94 + }
  95 +
  96 + /**
  97 + * Preferences provider
  98 + */
  99 + private final IWebPreferencesProvider provider;
  100 +
  101 + /**
  102 + * Preferences delegate
  103 + */
  104 + private final IWebPreferencesClient client;
  105 +
  106 + /**
  107 + * Our UUID
  108 + */
  109 + protected final String uuid;
  110 +
  111 + /**
  112 + * True if we are a private settings set
  113 + */
  114 + protected final boolean isPrivate;
  115 +
  116 + protected final boolean isReadOnly;
  117 +
  118 + /**
  119 + * Current key/value pairs
  120 + */
  121 + protected final Map<String, String> prefs = new ConcurrentHashMap<String, String>();
  122 +
  123 + /**
  124 + * Keys which have been requested by a consumer but not requested from the
  125 + * server yet
  126 + */
  127 + protected final Set<String> requestedPrefs = new HashSet<String>();
  128 +
  129 + /**
  130 + * Keys which have been requested from the server but not received yet
  131 + */
  132 + protected final Set<String> pendingPrefs = new HashSet<String>();
  133 +
  134 + /**
  135 + * Keys which have been set by a consumer but not sent to the server yet
  136 + */
  137 + protected final Set<String> dirtyPrefs = new HashSet<String>();
  138 +
  139 + /**
  140 + * Concurrency lock
  141 + */
  142 + protected final Object lock = new Object();
  143 +
  144 + /**
  145 + * True when any kind of
  146 + */
  147 + protected volatile boolean dirty = false;
  148 +
  149 + private volatile int updateCheckTimer = 1;
  150 +
  151 + protected int requestTimeoutTimer = 0;
  152 +
  153 + WebPreferences(IWebPreferencesProvider provider, String uuid, boolean isPrivate, boolean isReadOnly)
  154 + {
  155 + this.provider = provider;
  156 + this.uuid = uuid;
  157 + this.isPrivate = isPrivate;
  158 + this.isReadOnly = isReadOnly;
  159 + this.client = new Client();
  160 + }
  161 +
  162 + /* (non-Javadoc)
  163 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences#getUUID()
  164 + */
  165 + @Override
  166 + public String getUUID()
  167 + {
  168 + return this.uuid;
  169 + }
  170 +
  171 + /* (non-Javadoc)
  172 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences#isPrivate()
  173 + */
  174 + @Override
  175 + public boolean isPrivate()
  176 + {
  177 + return this.isPrivate;
  178 + }
  179 +
  180 + /* (non-Javadoc)
  181 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences#isReadOnly()
  182 + */
  183 + @Override
  184 + public boolean isReadOnly()
  185 + {
  186 + return this.isReadOnly;
  187 + }
  188 +
  189 + void onTick()
  190 + {
  191 + if (this.updateCheckTimer > 0)
  192 + {
  193 + this.updateCheckTimer--;
  194 + if (this.updateCheckTimer < 1)
  195 + {
  196 + this.update();
  197 + }
  198 + }
  199 +
  200 + if (this.requestTimeoutTimer > 0)
  201 + {
  202 + this.requestTimeoutTimer--;
  203 + if (this.requestTimeoutTimer < 1)
  204 + {
  205 + this.handleTimeout();
  206 + }
  207 + }
  208 + }
  209 +
  210 + /**
  211 + * Handle server requests on a periodic basis
  212 + */
  213 + private void update()
  214 + {
  215 + this.updateCheckTimer = WebPreferences.UPDATE_FREQUENCY_TICKS;
  216 +
  217 + if (!this.dirty || !this.provider.isActive())
  218 + {
  219 + return;
  220 + }
  221 +
  222 + synchronized (this.lock)
  223 + {
  224 + this.dirty = false;
  225 +
  226 + if (this.requestedPrefs.size() > 0)
  227 + {
  228 + LiteLoaderLogger.debug("Preferences for " + this.uuid + " is submitting a request for "
  229 + + this.requestedPrefs.size() + " requested preferences");
  230 + if (this.provider.requestGet(this.client, this.uuid, new HashSet<String>(this.requestedPrefs), this.isPrivate))
  231 + {
  232 + this.requestTimeoutTimer = WebPreferences.REQUEST_TIMEOUT_TICKS;
  233 + this.pendingPrefs.addAll(this.requestedPrefs);
  234 + this.requestedPrefs.clear();
  235 + }
  236 + else
  237 + {
  238 + this.dirty = true;
  239 + }
  240 + }
  241 +
  242 + }
  243 +
  244 + this.commit(false);
  245 + }
  246 +
  247 + /**
  248 + * Called when a pending request is deemed to have timed out
  249 + */
  250 + private void handleTimeout()
  251 + {
  252 + this.updateCheckTimer = WebPreferences.UPDATE_ERROR_SUSPEND_TICKS;
  253 +
  254 + synchronized (this.lock)
  255 + {
  256 + this.requestedPrefs.addAll(this.pendingPrefs);
  257 + this.pendingPrefs.clear();
  258 + this.dirty = true;
  259 + }
  260 + }
  261 +
  262 + /* (non-Javadoc)
  263 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  264 + * #request(java.lang.String)
  265 + */
  266 + @Override
  267 + public void request(String key)
  268 + {
  269 + WebPreferences.validateKey(key);
  270 +
  271 + synchronized (this.lock)
  272 + {
  273 + this.dirty |= this.addRequestedKey(key);
  274 + }
  275 + }
  276 +
  277 + /* (non-Javadoc)
  278 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  279 + * #request(java.lang.String[])
  280 + */
  281 + @Override
  282 + public void request(String... keys)
  283 + {
  284 + if (keys.length < 1) return;
  285 + if (keys.length == 1) this.request(keys[0]);
  286 +
  287 + synchronized (this.lock)
  288 + {
  289 + boolean dirty = false;
  290 +
  291 + for (String key : keys)
  292 + {
  293 + WebPreferences.validateKey(key);
  294 + dirty |= this.addRequestedKey(key);
  295 + }
  296 +
  297 + this.dirty |= dirty;
  298 + }
  299 + }
  300 +
  301 + /* (non-Javadoc)
  302 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  303 + * #request(java.util.Set)
  304 + */
  305 + @Override
  306 + public void request(Set<String> keys)
  307 + {
  308 + if (keys == null || keys.size() < 1) return;
  309 +
  310 + synchronized (this.lock)
  311 + {
  312 + boolean dirty = false;
  313 +
  314 + for (String key : keys)
  315 + {
  316 + WebPreferences.validateKey(key);
  317 + dirty |= this.addRequestedKey(key);
  318 + }
  319 +
  320 + this.dirty |= dirty;
  321 + }
  322 + }
  323 +
  324 + /* (non-Javadoc)
  325 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences#poll()
  326 + */
  327 + @Override
  328 + public void poll()
  329 + {
  330 + synchronized (this.lock)
  331 + {
  332 + this.requestedPrefs.addAll(this.prefs.keySet());
  333 + this.requestedPrefs.removeAll(this.pendingPrefs);
  334 + this.dirty = true;
  335 + }
  336 + }
  337 +
  338 + /* (non-Javadoc)
  339 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences#commit(boolean)
  340 + */
  341 + @Override
  342 + public void commit(boolean force)
  343 + {
  344 + synchronized (this.lock)
  345 + {
  346 + // Permanent error condition
  347 + if (this.updateCheckTimer < 0)
  348 + {
  349 + return;
  350 + }
  351 +
  352 + if (force)
  353 + {
  354 + this.dirtyPrefs.addAll(this.prefs.keySet());
  355 + }
  356 +
  357 + if (this.dirtyPrefs.size() > 0)
  358 + {
  359 + Map<String, String> outgoingPrefs = new HashMap<String, String>();
  360 + for (String key : this.dirtyPrefs)
  361 + {
  362 + outgoingPrefs.put(key, this.prefs.get(key));
  363 + }
  364 +
  365 + LiteLoaderLogger.debug("Preferences for " + this.uuid + " is submitting a SET for " + outgoingPrefs.size() + " dirty preferences");
  366 + if (this.provider.requestSet(this.client, this.uuid, outgoingPrefs, this.isPrivate))
  367 + {
  368 + this.dirtyPrefs.clear();
  369 + }
  370 + else
  371 + {
  372 + this.dirty = true;
  373 + }
  374 + }
  375 + }
  376 + }
  377 +
  378 + /* (non-Javadoc)
  379 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  380 + * #has(java.lang.String)
  381 + */
  382 + @Override
  383 + public boolean has(String key)
  384 + {
  385 + WebPreferences.validateKey(key);
  386 +
  387 + return this.get(key) != null;
  388 + }
  389 +
  390 + /* (non-Javadoc)
  391 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  392 + * #get(java.lang.String)
  393 + */
  394 + @Override
  395 + public String get(String key)
  396 + {
  397 + WebPreferences.validateKey(key);
  398 +
  399 + // .get() can be outside of the synchronisation lock because we are using ConcurrentHashSet
  400 + String value = this.prefs.get(key);
  401 +
  402 + if (value == null)
  403 + {
  404 + synchronized (this.lock)
  405 + {
  406 + this.dirty |= this.addRequestedKey(key);
  407 + }
  408 + }
  409 +
  410 + return value;
  411 + }
  412 +
  413 + /* (non-Javadoc)
  414 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  415 + * #get(java.lang.String, java.lang.String)
  416 + */
  417 + @Override
  418 + public String get(String key, String defaultValue)
  419 + {
  420 + WebPreferences.validateKey(key);
  421 +
  422 + String value = this.get(key);
  423 + return value != null ? value : defaultValue;
  424 + }
  425 +
  426 + /* (non-Javadoc)
  427 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  428 + * #set(java.lang.String, java.lang.String)
  429 + */
  430 + @Override
  431 + public void set(String key, String value)
  432 + {
  433 + if (this.isReadOnly())
  434 + {
  435 + throw new ReadOnlyPreferencesException("Preference collection for " + this.uuid + " is read-only");
  436 + }
  437 +
  438 + WebPreferences.validateKV(key, value);
  439 +
  440 + synchronized (this.lock)
  441 + {
  442 + String oldValue = this.prefs.get(key);
  443 + if (value.equals(oldValue)) return;
  444 +
  445 + this.prefs.put(key, value);
  446 + this.dirtyPrefs.add(key);
  447 + this.requestedPrefs.remove(key);
  448 + this.dirty = true;
  449 + }
  450 + }
  451 +
  452 + /* (non-Javadoc)
  453 + * @see com.mumfrey.webprefs.interfaces.IWebPreferences
  454 + * #remove(java.lang.String)
  455 + */
  456 + @Override
  457 + public void remove(String key)
  458 + {
  459 + this.set(key, "");
  460 + }
  461 +
  462 + /**
  463 + * Add a key to the current request set, the key will be requested from the
  464 + * server on the next {@link #update()}
  465 + *
  466 + * @param key
  467 + * @return
  468 + */
  469 + private boolean addRequestedKey(String key)
  470 + {
  471 + if (key != null && !this.pendingPrefs.contains(key))
  472 + {
  473 + this.requestedPrefs.add(key);
  474 + return true;
  475 + }
  476 +
  477 + return false;
  478 + }
  479 +
  480 + /**
  481 + * Callback from the preferences provider
  482 + */
  483 + void onGetRequestSuccess(Map<String, String> values)
  484 + {
  485 + this.requestTimeoutTimer = 0;
  486 +
  487 + synchronized (this.lock)
  488 + {
  489 + this.prefs.putAll(values);
  490 +
  491 + Set<String> keys = values.keySet();
  492 + this.dirtyPrefs.removeAll(keys);
  493 + this.pendingPrefs.removeAll(keys);
  494 + this.requestedPrefs.removeAll(keys);
  495 + }
  496 + }
  497 +
  498 + /**
  499 + * Callback from the preferences provider
  500 + */
  501 + void onSetRequestSuccess(Set<String> keys)
  502 + {
  503 + this.requestTimeoutTimer = 0;
  504 +
  505 + synchronized (this.lock)
  506 + {
  507 + this.dirtyPrefs.removeAll(keys);
  508 + this.requestedPrefs.removeAll(keys);
  509 + this.dirty = (this.dirtyPrefs.size() > 0 || this.requestedPrefs.size() > 0);
  510 + }
  511 + }
  512 +
  513 + /**
  514 + * Callback from the preferences provider
  515 + * @param reason
  516 + */
  517 + void onGetRequestFailed(Set<String> keys, RequestFailureReason reason)
  518 + {
  519 + this.requestTimeoutTimer = 0;
  520 + this.handleFailedRequest(reason);
  521 +
  522 + synchronized (this.lock)
  523 + {
  524 + this.dirtyPrefs.addAll(keys);
  525 + this.pendingPrefs.removeAll(keys);
  526 + this.dirty = true;
  527 + }
  528 + }
  529 +
  530 + /**
  531 + * Callback from the preferences provider
  532 + * @param reason
  533 + */
  534 + void onSetRequestFailed(Set<String> keys, RequestFailureReason reason)
  535 + {
  536 + this.requestTimeoutTimer = 0;
  537 + this.handleFailedRequest(reason);
  538 +
  539 + synchronized (this.lock)
  540 + {
  541 + this.requestedPrefs.addAll(keys);
  542 + this.pendingPrefs.removeAll(keys);
  543 + this.dirty = true;
  544 + }
  545 + }
  546 +
  547 + /**
  548 + * @param reason
  549 + */
  550 + private void handleFailedRequest(RequestFailureReason reason)
  551 + {
  552 + if (reason.isPermanent())
  553 + {
  554 + LiteLoaderLogger.debug("Halting update of preferences for " + this.uuid + " permanently because " + reason);
  555 + this.updateCheckTimer = -1;
  556 + }
  557 +
  558 + int suspendUpdateFor = WebPreferences.UPDATE_ERROR_SUSPEND_TICKS * Math.max(1, reason.getSeverity());
  559 + LiteLoaderLogger.debug("Suspending update of preferences for " + this.uuid + " for " + suspendUpdateFor + " because " + reason);
  560 + this.updateCheckTimer = suspendUpdateFor;
  561 + }
  562 +
  563 + /**
  564 + * @param key
  565 + */
  566 + protected static final void validateKey(String key)
  567 + {
  568 + if (key == null || !WebPreferences.keyPattern.matcher(key).matches())
  569 + {
  570 + throw new InvalidKeyException("The specified key [" + key + "] is not valid");
  571 + }
  572 + }
  573 +
  574 + /**
  575 + * @param key
  576 + * @param value
  577 + */
  578 + protected static final void validateKV(String key, String value)
  579 + {
  580 + WebPreferences.validateKey(key);
  581 +
  582 + if (value == null || value.length() > 255)
  583 + {
  584 + throw new InvalidValueException("The specified value [" + value + "] for key [" + key + "] is not valid");
  585 + }
  586 + }
  587 +}
src/client/java/com/mumfrey/webprefs/WebPreferencesManager.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs;
  2 +
  3 +import java.io.File;
  4 +import java.net.Proxy;
  5 +import java.net.URI;
  6 +import java.net.URISyntaxException;
  7 +import java.util.HashMap;
  8 +import java.util.LinkedHashMap;
  9 +import java.util.LinkedList;
  10 +import java.util.List;
  11 +import java.util.Map;
  12 +import java.util.UUID;
  13 +import java.util.regex.Matcher;
  14 +import java.util.regex.Pattern;
  15 +
  16 +import com.mojang.authlib.GameProfile;
  17 +import com.mojang.realmsclient.dto.RealmsServer;
  18 +import com.mumfrey.liteloader.JoinGameListener;
  19 +import com.mumfrey.liteloader.Tickable;
  20 +import com.mumfrey.liteloader.core.LiteLoader;
  21 +import com.mumfrey.webprefs.exceptions.InvalidServiceException;
  22 +import com.mumfrey.webprefs.exceptions.InvalidUUIDException;
  23 +import com.mumfrey.webprefs.framework.WebPreferencesProvider;
  24 +import com.mumfrey.webprefs.interfaces.IWebPreferences;
  25 +
  26 +import net.minecraft.client.Minecraft;
  27 +import net.minecraft.client.multiplayer.ServerData;
  28 +import net.minecraft.entity.player.EntityPlayer;
  29 +import net.minecraft.network.INetHandler;
  30 +import net.minecraft.network.play.server.SPacketJoinGame;
  31 +import net.minecraft.util.Session;
  32 +
  33 +/**
  34 + * WebPreferences Service Manager, acts as a central registry for all web
  35 + * preference collections.
  36 + *
  37 + * <p>To access preferences on a service, first request the service using
  38 + * {@link #get(String)} or {@link #getDefault()}, you can then request
  39 + * preferences objects from the service by calling the various overloads of
  40 + * {@link #getPreferences}.</p>
  41 + *
  42 + * @author Adam Mummery-Smith
  43 + */
  44 +public final class WebPreferencesManager
  45 +{
  46 + /**
  47 + * WebPreferences Manager Update Daemon is injected into LiteLoader to
  48 + * facilitate passing events to the WebPreferences Manager without having to
  49 + * expose public callback methods.
  50 + *
  51 + * @author Adam Mummery-Smith
  52 + */
  53 + static class WebPreferencesUpdateDeamon implements Tickable, JoinGameListener
  54 + {
  55 + @Override
  56 + public String getName()
  57 + {
  58 + return "Web Preferences Update Daemon";
  59 + }
  60 +
  61 + @Override
  62 + public String getVersion()
  63 + {
  64 + return "N/A";
  65 + }
  66 +
  67 + @Override
  68 + public void init(File configPath)
  69 + {
  70 + }
  71 +
  72 + @Override
  73 + public void upgradeSettings(String version, File configPath, File oldConfigPath)
  74 + {
  75 + }
  76 +
  77 + @Override
  78 + public void onTick(Minecraft minecraft, float partialTicks, boolean inGame, boolean clock)
  79 + {
  80 + if (clock)
  81 + {
  82 + for (WebPreferencesManager manager : WebPreferencesManager.managers.values())
  83 + {
  84 + manager.onTick();
  85 + }
  86 + }
  87 + }
  88 +
  89 + @Override
  90 + public void onJoinGame(INetHandler netHandler, SPacketJoinGame joinGamePacket, ServerData serverData, RealmsServer realmsServer)
  91 + {
  92 + for (WebPreferencesManager manager : WebPreferencesManager.managers.values())
  93 + {
  94 + manager.onJoinGame();
  95 + }
  96 + }
  97 + }
  98 +
  99 + /**
  100 + * Default KV api hostname to connect to
  101 + */
  102 + private static final String DEFAULT_HOSTNAME = "kv.liteloader.com";
  103 +
  104 + /**
  105 + * Regex for validating UUIDs
  106 + */
  107 + private static final Pattern uuidPattern = Pattern.compile("^[a-f0-9]{32}$");
  108 +
  109 + /**
  110 + * Mapping of hostnames to managers
  111 + */
  112 + static final Map<String, WebPreferencesManager> managers = new LinkedHashMap<String, WebPreferencesManager>();
  113 +
  114 + /**
  115 + * Update daemon
  116 + */
  117 + private static WebPreferencesUpdateDeamon updateDeamon;
  118 +
  119 + /**
  120 + * Session for this instance
  121 + */
  122 + private final Session session;
  123 +
  124 + /**
  125 + * Preference provider, manages queueing requests and passing responses back
  126 + * to clients
  127 + */
  128 + private final WebPreferencesProvider provider;
  129 +
  130 + /**
  131 + * All preference sets, for iteration purposes
  132 + */
  133 + private final List<WebPreferences> allPreferences = new LinkedList<WebPreferences>();
  134 +
  135 + /**
  136 + * All public preference sets, mapped by UUID
  137 + */
  138 + private final Map<String, IWebPreferences> preferencesPublic = new HashMap<String, IWebPreferences>();
  139 +
  140 + /**
  141 + * All private preference sets, mapped by UUID
  142 + */
  143 + private final Map<String, IWebPreferences> preferencesPrivate = new HashMap<String, IWebPreferences>();
  144 +
  145 + private WebPreferencesManager(Proxy proxy, Session session, String hostName)
  146 + {
  147 + this.session = session;
  148 + this.provider = new WebPreferencesProvider(proxy, session, hostName, 50);
  149 + }
  150 +
  151 + void onTick()
  152 + {
  153 + this.provider.onTick();
  154 +
  155 + for (WebPreferences prefs : this.allPreferences)
  156 + {
  157 + try
  158 + {
  159 + prefs.onTick();
  160 + }
  161 + catch (Exception ex) {}
  162 + }
  163 + }
  164 +
  165 + void onJoinGame()
  166 + {
  167 + for (WebPreferences prefs : this.allPreferences)
  168 + {
  169 + try
  170 + {
  171 + prefs.poll();
  172 + }
  173 + catch (Exception ex) {}
  174 + }
  175 + }
  176 +
  177 +
  178 + /**
  179 + * Get a public or private preferences collection for the local player
  180 + *
  181 + * @param privatePrefs true to fetch the player's private preferences, false
  182 + * to fetch public preferences
  183 + * @return player's preference collection, creates if necessary
  184 + */
  185 + public IWebPreferences getLocalPreferences(boolean privatePrefs)
  186 + {
  187 + return this.getPreferences(this.session.getPlayerID(), privatePrefs);
  188 + }
  189 +
  190 + /**
  191 + * Get a public preferences collection for the specified player.
  192 + *
  193 + * @param player Player to fetch preferences for
  194 + * @param privatePrefs True to fetch the player's private preferences, false
  195 + * to fetch the public preferences
  196 + * @return Preference collection or <tt>null</tt> if the player's profile
  197 + * cannot be retrieved
  198 + */
  199 + public IWebPreferences getPreferences(EntityPlayer player)
  200 + {
  201 + return this.getPreferences(player, false);
  202 + }
  203 +
  204 + /**
  205 + * Get a public or private preferences collection for the specified player,
  206 + * note that accessing a private collection for another player is likely
  207 + * to be prohibited by the service.
  208 + *
  209 + * @param player Player to fetch preferences for
  210 + * @param privatePrefs True to fetch the player's private preferences, false
  211 + * to fetch the public preferences
  212 + * @return Preference collection or <tt>null</tt> if the player's profile
  213 + * cannot be retrieved
  214 + */
  215 + public IWebPreferences getPreferences(EntityPlayer player, boolean privatePrefs)
  216 + {
  217 + GameProfile gameProfile = player.getGameProfile();
  218 + return gameProfile != null ? this.getPreferences(gameProfile, privatePrefs) : null;
  219 + }
  220 +
  221 + /**
  222 + * Get a public preferences collection for the specified game profile.
  223 + *
  224 + * @param gameProfile game profile to fetch preferences for
  225 + * @return Preference collection or <tt>null</tt> if the supplied profile is
  226 + * null
  227 + */
  228 + public IWebPreferences getPreferences(GameProfile gameProfile)
  229 + {
  230 + return gameProfile != null ? this.getPreferences(gameProfile, false) : null;
  231 + }
  232 +
  233 + /**
  234 + * Get a public or private preferences collection for the specified game
  235 + * profile, note that accessing a private collection for another player is
  236 + * likely to be prohibited by the service.
  237 + *
  238 + * @param gameProfile game profile to fetch preferences for
  239 + * @param privatePrefs True to fetch the player's private preferences, false
  240 + * to fetch the public preferences
  241 + * @return Preference collection or <tt>null</tt> if the supplied profile is
  242 + * null
  243 + */
  244 + public IWebPreferences getPreferences(GameProfile gameProfile, boolean privatePrefs)
  245 + {
  246 + return gameProfile != null ? this.getPreferences(gameProfile.getId(), privatePrefs) : null;
  247 + }
  248 +
  249 + /**
  250 + * Get a public preferences collection for the specified player UUID.
  251 + *
  252 + * @param uuid UUID to fetch preferences for
  253 + * @return Preference collection or <tt>null</tt> if the supplied UUID is
  254 + * null
  255 + */
  256 + public IWebPreferences getPreferences(UUID uuid)
  257 + {
  258 + return uuid != null ? this.getPreferences(uuid, false) : null;
  259 + }
  260 +
  261 + /**
  262 + * Get a public or private preferences collection for the specified player
  263 + * UUID, note that accessing a private collection for another player is
  264 + * likely to be prohibited by the service.
  265 + *
  266 + * @param uuid UUID to fetch preferences for
  267 + * @param privatePrefs True to fetch the player's private preferences, false
  268 + * to fetch the public preferences
  269 + * @return Preference collection or <tt>null</tt> if the supplied UUID is
  270 + * null
  271 + */
  272 + public IWebPreferences getPreferences(UUID uuid, boolean privatePrefs)
  273 + {
  274 + return uuid != null ? this.getPreferences(uuid.toString(), privatePrefs) : null;
  275 + }
  276 +
  277 + public IWebPreferences getPreferences(String uuid, boolean privatePrefs)
  278 + {
  279 + uuid = this.sanitiseUUID(uuid);
  280 +
  281 + Map<String, IWebPreferences> preferences = privatePrefs ? this.preferencesPrivate : this.preferencesPublic;
  282 +
  283 + IWebPreferences prefs = preferences.get(uuid);
  284 +
  285 + if (prefs == null)
  286 + {
  287 + WebPreferences newPrefs = new WebPreferences(this.provider, uuid, privatePrefs, !uuid.equals(this.session.getPlayerID()));
  288 + this.allPreferences.add(newPrefs);
  289 + preferences.put(uuid, newPrefs);
  290 + prefs = newPrefs;
  291 + }
  292 +
  293 + return prefs;
  294 + }
  295 +
  296 + private String sanitiseUUID(String uuid)
  297 + {
  298 + if (uuid == null)
  299 + {
  300 + throw new InvalidUUIDException("The UUID was null");
  301 + }
  302 +
  303 + uuid = uuid.toLowerCase().replace("-", "").trim();
  304 + Matcher uuidPatternMatcher = WebPreferencesManager.uuidPattern.matcher(uuid);
  305 + if (!uuidPatternMatcher.matches())
  306 + {
  307 + throw new InvalidUUIDException("The specified string [" + uuid + "] is not a valid UUID");
  308 + }
  309 +
  310 + return uuid;
  311 + }
  312 +
  313 + /**
  314 + * Get the default preferences manager (kv.liteloader.com)
  315 + *
  316 + * @return default preferences manager
  317 + */
  318 + public static WebPreferencesManager getDefault()
  319 + {
  320 + return WebPreferencesManager.get(WebPreferencesManager.DEFAULT_HOSTNAME);
  321 + }
  322 +
  323 + /**
  324 + * Get a preferences manager for the specified service hostname
  325 + *
  326 + * @param hostName service hostname (bare hostname only, no protocol)
  327 + * @return preferences manager
  328 + * @throws InvalidServiceException if the specified host name is invalid
  329 + */
  330 + @SuppressWarnings("unused")
  331 + public static WebPreferencesManager get(String hostName) throws InvalidServiceException
  332 + {
  333 + try
  334 + {
  335 + new URI(String.format("http://%s/", hostName));
  336 + }
  337 + catch (URISyntaxException ex)
  338 + {
  339 + throw new InvalidServiceException("The specified service host was not valid: " + hostName, ex);
  340 + }
  341 +
  342 + if (WebPreferencesManager.updateDeamon == null)
  343 + {
  344 + WebPreferencesManager.updateDeamon = new WebPreferencesUpdateDeamon();
  345 + LiteLoader.getInterfaceManager().registerListener(WebPreferencesManager.updateDeamon);
  346 + }
  347 +
  348 + WebPreferencesManager manager = WebPreferencesManager.managers.get(hostName);
  349 +
  350 + if (manager == null)
  351 + {
  352 + Minecraft minecraft = Minecraft.getMinecraft();
  353 +
  354 + Proxy proxy = minecraft.getProxy();
  355 + Session session = minecraft.getSession();
  356 +
  357 + manager = new WebPreferencesManager(proxy, session, hostName);
  358 + WebPreferencesManager.managers.put(hostName, manager);
  359 + }
  360 +
  361 + return manager;
  362 + }
  363 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidKeyException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +public class InvalidKeyException extends RuntimeException
  4 +{
  5 + private static final long serialVersionUID = 1L;
  6 +
  7 + public InvalidKeyException()
  8 + {
  9 + }
  10 +
  11 + public InvalidKeyException(String message)
  12 + {
  13 + super(message);
  14 + }
  15 +
  16 + public InvalidKeyException(Throwable cause)
  17 + {
  18 + super(cause);
  19 + }
  20 +
  21 + public InvalidKeyException(String message, Throwable cause)
  22 + {
  23 + super(message, cause);
  24 + }
  25 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidPreferenceOperationException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +public class InvalidPreferenceOperationException extends RuntimeException
  4 +{
  5 + private static final long serialVersionUID = 1L;
  6 +
  7 + public InvalidPreferenceOperationException()
  8 + {
  9 + }
  10 +
  11 + public InvalidPreferenceOperationException(String message)
  12 + {
  13 + super(message);
  14 + }
  15 +
  16 + public InvalidPreferenceOperationException(Throwable cause)
  17 + {
  18 + super(cause);
  19 + }
  20 +
  21 + public InvalidPreferenceOperationException(String message, Throwable cause)
  22 + {
  23 + super(message, cause);
  24 + }
  25 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidRequestException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  4 +
  5 +public class InvalidRequestException extends RuntimeException
  6 +{
  7 + private static final long serialVersionUID = 1L;
  8 +
  9 + private final RequestFailureReason reason;
  10 +
  11 + public InvalidRequestException(RequestFailureReason reason)
  12 + {
  13 + this.reason = reason;
  14 + }
  15 +
  16 + public InvalidRequestException(RequestFailureReason reason, String message)
  17 + {
  18 + super(message);
  19 + this.reason = reason;
  20 + }
  21 +
  22 + public InvalidRequestException(RequestFailureReason reason, Throwable cause)
  23 + {
  24 + super(cause);
  25 + this.reason = reason;
  26 + }
  27 +
  28 + public InvalidRequestException(RequestFailureReason reason, String message, Throwable cause)
  29 + {
  30 + super(message, cause);
  31 + this.reason = reason;
  32 + }
  33 +
  34 + public RequestFailureReason getReason()
  35 + {
  36 + return this.reason;
  37 + }
  38 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidRequestKeyException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  4 +
  5 +public class InvalidRequestKeyException extends InvalidRequestException
  6 +{
  7 + private static final long serialVersionUID = 1L;
  8 +
  9 + public InvalidRequestKeyException()
  10 + {
  11 + super(RequestFailureReason.BAD_PARAMS);
  12 + }
  13 +
  14 + public InvalidRequestKeyException(String message)
  15 + {
  16 + super(RequestFailureReason.BAD_PARAMS, message);
  17 + }
  18 +
  19 + public InvalidRequestKeyException(Throwable cause)
  20 + {
  21 + super(RequestFailureReason.BAD_PARAMS, cause);
  22 + }
  23 +
  24 + public InvalidRequestKeyException(String message, Throwable cause)
  25 + {
  26 + super(RequestFailureReason.BAD_PARAMS, message, cause);
  27 + }
  28 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidRequestValueException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  4 +
  5 +public class InvalidRequestValueException extends InvalidRequestException
  6 +{
  7 + private static final long serialVersionUID = 1L;
  8 +
  9 + public InvalidRequestValueException()
  10 + {
  11 + super(RequestFailureReason.BAD_PARAMS);
  12 + }
  13 +
  14 + public InvalidRequestValueException(String message)
  15 + {
  16 + super(RequestFailureReason.BAD_PARAMS, message);
  17 + }
  18 +
  19 + public InvalidRequestValueException(Throwable cause)
  20 + {
  21 + super(RequestFailureReason.BAD_PARAMS, cause);
  22 + }
  23 +
  24 + public InvalidRequestValueException(String message, Throwable cause)
  25 + {
  26 + super(RequestFailureReason.BAD_PARAMS, message, cause);
  27 + }
  28 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidResponseException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  4 +
  5 +public class InvalidResponseException extends RuntimeException
  6 +{
  7 + private static final long serialVersionUID = 1L;
  8 +
  9 + private final RequestFailureReason response;
  10 +
  11 + public InvalidResponseException(RequestFailureReason response)
  12 + {
  13 + this.response = response;
  14 + }
  15 +
  16 + public InvalidResponseException(RequestFailureReason response, String message)
  17 + {
  18 + super(message);
  19 + this.response = response;
  20 + }
  21 +
  22 + public InvalidResponseException(RequestFailureReason response, Throwable cause)
  23 + {
  24 + super(cause);
  25 + this.response = response;
  26 + }
  27 +
  28 + public InvalidResponseException(RequestFailureReason response, String message, Throwable cause)
  29 + {
  30 + super(message, cause);
  31 + this.response = response;
  32 + }
  33 +
  34 + public RequestFailureReason getReason()
  35 + {
  36 + return this.response;
  37 + }
  38 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidServiceException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +public class InvalidServiceException extends RuntimeException
  4 +{
  5 + private static final long serialVersionUID = 1L;
  6 +
  7 + public InvalidServiceException()
  8 + {
  9 + }
  10 +
  11 + public InvalidServiceException(String message)
  12 + {
  13 + super(message);
  14 + }
  15 +
  16 + public InvalidServiceException(Throwable cause)
  17 + {
  18 + super(cause);
  19 + }
  20 +
  21 + public InvalidServiceException(String message, Throwable cause)
  22 + {
  23 + super(message, cause);
  24 + }
  25 +
  26 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidUUIDException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +public class InvalidUUIDException extends RuntimeException
  4 +{
  5 + private static final long serialVersionUID = 1L;
  6 +
  7 + public InvalidUUIDException()
  8 + {
  9 + }
  10 +
  11 + public InvalidUUIDException(String message)
  12 + {
  13 + super(message);
  14 + }
  15 +
  16 + public InvalidUUIDException(Throwable cause)
  17 + {
  18 + super(cause);
  19 + }
  20 +
  21 + public InvalidUUIDException(String message, Throwable cause)
  22 + {
  23 + super(message, cause);
  24 + }
  25 +}
src/client/java/com/mumfrey/webprefs/exceptions/InvalidValueException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +public class InvalidValueException extends RuntimeException
  4 +{
  5 + private static final long serialVersionUID = 1L;
  6 +
  7 + public InvalidValueException()
  8 + {
  9 + }
  10 +
  11 + public InvalidValueException(String message)
  12 + {
  13 + super(message);
  14 + }
  15 +
  16 + public InvalidValueException(Throwable cause)
  17 + {
  18 + super(cause);
  19 + }
  20 +
  21 + public InvalidValueException(String message, Throwable cause)
  22 + {
  23 + super(message, cause);
  24 + }
  25 +}
src/client/java/com/mumfrey/webprefs/exceptions/ReadOnlyPreferencesException.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.exceptions;
  2 +
  3 +public class ReadOnlyPreferencesException extends InvalidPreferenceOperationException
  4 +{
  5 + private static final long serialVersionUID = 1L;
  6 +
  7 + public ReadOnlyPreferencesException()
  8 + {
  9 + }
  10 +
  11 + public ReadOnlyPreferencesException(String message)
  12 + {
  13 + super(message);
  14 + }
  15 +
  16 + public ReadOnlyPreferencesException(Throwable cause)
  17 + {
  18 + super(cause);
  19 + }
  20 +
  21 + public ReadOnlyPreferencesException(String message, Throwable cause)
  22 + {
  23 + super(message, cause);
  24 + }
  25 +}
src/client/java/com/mumfrey/webprefs/framework/RequestFailureReason.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +public enum RequestFailureReason
  4 +{
  5 + UNKNOWN(1),
  6 + BAD_PARAMS(1),
  7 + NO_SESSION(100),
  8 + SERVER_ERROR(3),
  9 + UNAUTHORISED(5),
  10 + THROTTLED(2),
  11 + UUID_MISMATCH(10),
  12 + BAD_DATA(1);
  13 +
  14 + private final int severity;
  15 +
  16 + private RequestFailureReason(int severity)
  17 + {
  18 + this.severity = severity;
  19 + }
  20 +
  21 + public int getSeverity()
  22 + {
  23 + return this.severity;
  24 + }
  25 +
  26 + public boolean isPermanent()
  27 + {
  28 + return this.severity > 99;
  29 + }
  30 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesProvider.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.net.Proxy;
  4 +import java.util.Map;
  5 +import java.util.Set;
  6 +import java.util.concurrent.BlockingQueue;
  7 +import java.util.concurrent.LinkedBlockingQueue;
  8 +
  9 +import net.minecraft.util.Session;
  10 +
  11 +import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
  12 +import com.mumfrey.webprefs.interfaces.IWebPreferencesClient;
  13 +import com.mumfrey.webprefs.interfaces.IWebPreferencesProvider;
  14 +import com.mumfrey.webprefs.interfaces.IWebPreferencesService;
  15 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceMonitor;
  16 +
  17 +public class WebPreferencesProvider extends Thread implements IWebPreferencesProvider, IWebPreferencesServiceMonitor
  18 +{
  19 + private final IWebPreferencesService service;
  20 +
  21 + private final String hostName;
  22 +
  23 + private final Session session;
  24 +
  25 + private final int failureThreshold;
  26 +
  27 + private int failureCount = 0;
  28 +
  29 + private volatile boolean active = true;
  30 +
  31 + private final BlockingQueue<WebPreferencesServiceTask> tasks = new LinkedBlockingQueue<WebPreferencesServiceTask>(2048);
  32 +
  33 + public WebPreferencesProvider(Proxy proxy, Session session, String hostName, int maxFailedRequestsCount)
  34 + {
  35 + this.service = new WebPreferencesService(proxy, session);
  36 + this.service.addMonitor(this);
  37 +
  38 + this.hostName = hostName;
  39 + this.session = session;
  40 + this.failureThreshold = maxFailedRequestsCount;
  41 +
  42 + this.setName("WebPreferencesProvider daemon thread [" + hostName + "]");
  43 + this.setDaemon(true);
  44 + this.start();
  45 + }
  46 +
  47 + @Override
  48 + public boolean isActive()
  49 + {
  50 + return this.active;
  51 + }
  52 +
  53 + public void onTick()
  54 + {
  55 + }
  56 +
  57 + @Override
  58 + public void run()
  59 + {
  60 + try
  61 + {
  62 + while (this.active)
  63 + {
  64 + WebPreferencesServiceTask task = this.tasks.take();
  65 + try
  66 + {
  67 + LiteLoaderLogger.debug("WebPreferencesProvider [%s] is processing %s for %s", this.hostName,
  68 + task.getClass().getSimpleName(), task.getRequest().getUUID());
  69 + this.service.submit(task.getRequest());
  70 + }
  71 + catch (Throwable th)
  72 + {
  73 + if (th instanceof InterruptedException) throw (InterruptedException)th;
  74 + th.printStackTrace();
  75 +
  76 + this.onRequestFailed(th, 1);
  77 + }
  78 + }
  79 + }
  80 + catch (InterruptedException ex)
  81 + {
  82 + ex.printStackTrace();
  83 + }
  84 + }
  85 +
  86 + @Override
  87 + public void onKeyRequestFailed()
  88 + {
  89 + this.registerError(this.failureThreshold / 2);
  90 + }
  91 +
  92 + @Override
  93 + public void onRequestFailed(Throwable th, int severity)
  94 + {
  95 + this.registerError(severity);
  96 + }
  97 +
  98 + private void registerError(int severity)
  99 + {
  100 + this.failureCount += severity;
  101 + if (this.failureCount >= this.failureThreshold)
  102 + {
  103 + LiteLoaderLogger.warning("WebPreferencesProvider for " + this.hostName + " is terminating. Too many failed requests.");
  104 + this.active = false;
  105 + this.tasks.clear();
  106 + this.interrupt();
  107 + }
  108 + }
  109 +
  110 + @Override
  111 + public boolean requestGet(IWebPreferencesClient client, String uuid, Set<String> keys, boolean getPrivate)
  112 + {
  113 + if (!this.isActive())
  114 + {
  115 + return false;
  116 + }
  117 +
  118 + WebPreferencesServiceTask task = new WebPreferencesServiceTaskGet(this, client);
  119 + task.setRequest(new WebPreferencesRequestGet(task, uuid, keys, getPrivate));
  120 + return this.tasks.offer(task);
  121 + }
  122 +
  123 + @Override
  124 + public boolean requestSet(IWebPreferencesClient client, String uuid, Map<String, String> values, boolean setPrivate)
  125 + {
  126 + if (!this.isActive())
  127 + {
  128 + return false;
  129 + }
  130 +
  131 + WebPreferencesServiceTask task = new WebPreferencesServiceTaskSet(this, client);
  132 + task.setRequest(new WebPreferencesRequestSet(task, uuid, values, setPrivate));
  133 + return this.tasks.offer(task);
  134 + }
  135 +
  136 + @Override
  137 + public String getHostName()
  138 + {
  139 + return this.hostName;
  140 + }
  141 +
  142 + @Override
  143 + public Session getSession()
  144 + {
  145 + return this.session;
  146 + }
  147 +
  148 + @Override
  149 + public IWebPreferencesService getService()
  150 + {
  151 + return this.service;
  152 + }
  153 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesRequestAbstract.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.net.URI;
  4 +import java.util.HashMap;
  5 +import java.util.Map;
  6 +import java.util.regex.Pattern;
  7 +
  8 +import net.minecraft.util.Session;
  9 +
  10 +import com.google.gson.Gson;
  11 +import com.mumfrey.webprefs.exceptions.InvalidRequestException;
  12 +import com.mumfrey.webprefs.exceptions.InvalidRequestKeyException;
  13 +import com.mumfrey.webprefs.exceptions.InvalidRequestValueException;
  14 +import com.mumfrey.webprefs.exceptions.InvalidResponseException;
  15 +import com.mumfrey.webprefs.interfaces.IWebPreferencesRequest;
  16 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  17 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceDelegate;
  18 +
  19 +abstract class WebPreferencesRequestAbstract implements IWebPreferencesRequest
  20 +{
  21 + private static final long serialVersionUID = 1L;
  22 +
  23 + private static final Pattern keyPattern = Pattern.compile("^[a-z0-9_\\-\\.]{1,32}$");
  24 +
  25 + private static final Gson gson = new Gson();
  26 +
  27 + private final transient URI uri;
  28 +
  29 + private final transient IWebPreferencesServiceDelegate delegate;
  30 +
  31 + private final transient String uuid;
  32 +
  33 + public WebPreferencesRequestAbstract(IWebPreferencesServiceDelegate delegate, String uuid)
  34 + {
  35 + if (delegate == null)
  36 + {
  37 + throw new IllegalArgumentException("Attempted to create a request with no delegate");
  38 + }
  39 +
  40 + this.uri = URI.create(String.format("http://%s%s", delegate.getHostName(), this.getPath()));
  41 +
  42 + this.delegate = delegate;
  43 + this.uuid = uuid;
  44 + }
  45 +
  46 + protected abstract String getPath();
  47 +
  48 + @Override
  49 + public IWebPreferencesServiceDelegate getDelegate()
  50 + {
  51 + return this.delegate;
  52 + }
  53 +
  54 + @Override
  55 + public URI getRequestURI()
  56 + {
  57 + return this.uri;
  58 + }
  59 +
  60 + @Override
  61 + public String getUUID()
  62 + {
  63 + return this.uuid;
  64 + }
  65 +
  66 + @Override
  67 + public Map<String, String> getPostVars()
  68 + {
  69 + Map<String, String> params = new HashMap<String, String>();
  70 + this.addParams(params);
  71 + return params;
  72 + }
  73 +
  74 + protected void addParams(Map<String, String> params)
  75 + {
  76 + if (this.isValidationRequired())
  77 + {
  78 + Session session = this.getDelegate().getSession();
  79 + if (session == null)
  80 + {
  81 + throw new InvalidRequestException(RequestFailureReason.NO_SESSION, "Request has no session");
  82 + }
  83 +
  84 + params.put("u", session.getUsername());
  85 + }
  86 +
  87 + params.put("i", this.uuid);
  88 + params.put("j", this.toJson());
  89 + }
  90 +
  91 + @Override
  92 + public final void onReceivedResponse(IWebPreferencesResponse response)
  93 + {
  94 + if (response == null)
  95 + {
  96 + throw new InvalidResponseException(null, "Error reading server response");
  97 + }
  98 +
  99 + if (response.getResponse().startsWith("500"))
  100 + {
  101 + throw new InvalidResponseException(RequestFailureReason.SERVER_ERROR,
  102 + "The server returned an invalid resonse: " + response.getResponse(), response.getThrowable());
  103 + }
  104 +
  105 + if (!response.getResponse().startsWith("200"))
  106 + {
  107 + RequestFailureReason reason = RequestFailureReason.UNKNOWN;
  108 +
  109 + if (response.getResponse().startsWith("429")) reason = RequestFailureReason.THROTTLED;
  110 + if (response.getResponse().startsWith("401")) reason = RequestFailureReason.UNAUTHORISED;
  111 +
  112 + String message = response.getMessage();
  113 + throw new InvalidResponseException(reason,
  114 + "The server responsed with " + response.getResponse() + (message != null ? " \"" + message + "\"" : ""));
  115 + }
  116 +
  117 + if (!this.getUUID().equals(response.getUUID()))
  118 + {
  119 + throw new InvalidResponseException(RequestFailureReason.UUID_MISMATCH, "The response UUID did not match the request");
  120 + }
  121 +
  122 + this.validateResponse(response);
  123 + }
  124 +
  125 + protected abstract void validateResponse(IWebPreferencesResponse response);
  126 +
  127 + protected final void validateKey(String key)
  128 + {
  129 + if (key == null || !WebPreferencesRequestAbstract.keyPattern.matcher(key).matches())
  130 + {
  131 + throw new InvalidRequestKeyException("The specified key [" + key + "] is not valid");
  132 + }
  133 + }
  134 +
  135 + protected final void validateValue(String key, String value)
  136 + {
  137 + if (value == null || value.length() > 255)
  138 + {
  139 + throw new InvalidRequestValueException("The specified value [" + value + "] for key [" + key + "] is not valid");
  140 + }
  141 + }
  142 +
  143 + public String toJson()
  144 + {
  145 + return WebPreferencesRequestAbstract.gson.toJson(this);
  146 + }
  147 +
  148 + @Override
  149 + public String toString()
  150 + {
  151 + try
  152 + {
  153 + return WebPreferencesRequestAbstract.gson.toJson(this);
  154 + }
  155 + catch (Throwable th)
  156 + {
  157 + return "{\"Invalid JSON\"}";
  158 + }
  159 + }
  160 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesRequestGet.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.util.HashSet;
  4 +import java.util.Set;
  5 +
  6 +import com.google.gson.annotations.Expose;
  7 +import com.google.gson.annotations.SerializedName;
  8 +import com.mumfrey.webprefs.exceptions.InvalidRequestException;
  9 +import com.mumfrey.webprefs.exceptions.InvalidResponseException;
  10 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  11 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceDelegate;
  12 +
  13 +class WebPreferencesRequestGet extends WebPreferencesRequestAbstract
  14 +{
  15 + private static final long serialVersionUID = 1L;
  16 +
  17 + @Expose @SerializedName("get")
  18 + private final Set<String> keys = new HashSet<String>();
  19 +
  20 + @Expose @SerializedName("private")
  21 + private boolean isPrivate;
  22 +
  23 + public WebPreferencesRequestGet(IWebPreferencesServiceDelegate delegate, String uuid, Set<String> keys)
  24 + {
  25 + this(delegate, uuid, keys, false);
  26 + }
  27 +
  28 + public WebPreferencesRequestGet(IWebPreferencesServiceDelegate delegate, String uuid, Set<String> keys, boolean isPrivate)
  29 + {
  30 + super(delegate, uuid);
  31 +
  32 + if (isPrivate && delegate.getSession() == null)
  33 + {
  34 + throw new InvalidRequestException(RequestFailureReason.NO_SESSION, "Cannot request private values without supplying a session");
  35 + }
  36 +
  37 + this.validate(keys);
  38 +
  39 + this.keys.addAll(keys);
  40 + this.isPrivate = isPrivate;
  41 + }
  42 +
  43 + @Override
  44 + protected String getPath()
  45 + {
  46 + return "/get";
  47 + }
  48 +
  49 + @Override
  50 + public boolean isValidationRequired()
  51 + {
  52 + return this.isPrivate;
  53 + }
  54 +
  55 + @Override
  56 + public Set<String> getKeys()
  57 + {
  58 + return this.keys;
  59 + }
  60 +
  61 + @Override
  62 + protected void validateResponse(IWebPreferencesResponse response)
  63 + {
  64 + if (response.hasValues())
  65 + {
  66 + Set<String> responseKeys = response.getValues().keySet();
  67 + for (String key : this.keys)
  68 + {
  69 + if (!responseKeys.contains(key))
  70 + {
  71 + throw new InvalidResponseException(RequestFailureReason.BAD_DATA,
  72 + "The server responded with an incomplete key set, missing key [" + key + "]");
  73 + }
  74 + }
  75 + }
  76 + }
  77 +
  78 + private void validate(Set<String> keys)
  79 + {
  80 + if (keys == null || keys.isEmpty())
  81 + {
  82 + throw new InvalidRequestException(RequestFailureReason.BAD_PARAMS, "Cannot request an empty set");
  83 + }
  84 +
  85 + for (String key : keys)
  86 + {
  87 + this.validateKey(key);
  88 + }
  89 + }
  90 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesRequestKey.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.util.HashSet;
  4 +import java.util.Set;
  5 +
  6 +import net.minecraft.util.Session;
  7 +
  8 +import com.mumfrey.webprefs.interfaces.IWebPreferencesRequest;
  9 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  10 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceDelegate;
  11 +
  12 +public class WebPreferencesRequestKey extends WebPreferencesRequestAbstract
  13 +{
  14 + private static final long serialVersionUID = 1L;
  15 +
  16 + protected final transient WebPreferencesService server;
  17 +
  18 + public WebPreferencesRequestKey(final WebPreferencesService server, final Session session, final String hostName)
  19 + {
  20 + super(new IWebPreferencesServiceDelegate()
  21 + {
  22 + @Override
  23 + public void onRequestFailed(IWebPreferencesRequest request, Throwable th, RequestFailureReason reason)
  24 + {
  25 + server.handleKeyRequestFailed(th);
  26 + }
  27 +
  28 + @Override
  29 + public void onReceivedResponse(IWebPreferencesRequest request, IWebPreferencesResponse response)
  30 + {
  31 + server.handleKeyRequestCompleted(response);
  32 + }
  33 +
  34 + @Override
  35 + public Session getSession()
  36 + {
  37 + return session;
  38 + }
  39 +
  40 + @Override
  41 + public String getHostName()
  42 + {
  43 + return hostName;
  44 + }
  45 + }, session.getPlayerID());
  46 +
  47 + this.server = server;
  48 + }
  49 +
  50 + @Override
  51 + public boolean isValidationRequired()
  52 + {
  53 + return true;
  54 + }
  55 +
  56 + @Override
  57 + protected String getPath()
  58 + {
  59 + return "/key";
  60 + }
  61 +
  62 + @Override
  63 + protected void validateResponse(IWebPreferencesResponse response)
  64 + {
  65 + }
  66 +
  67 + @Override
  68 + public Set<String> getKeys()
  69 + {
  70 + return new HashSet<String>();
  71 + }
  72 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesRequestSet.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.util.HashMap;
  4 +import java.util.Map;
  5 +import java.util.Map.Entry;
  6 +import java.util.Set;
  7 +
  8 +import com.google.gson.annotations.Expose;
  9 +import com.google.gson.annotations.SerializedName;
  10 +import com.mumfrey.webprefs.exceptions.InvalidRequestException;
  11 +import com.mumfrey.webprefs.exceptions.InvalidResponseException;
  12 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  13 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceDelegate;
  14 +
  15 +class WebPreferencesRequestSet extends WebPreferencesRequestAbstract
  16 +{
  17 + private static final long serialVersionUID = 1L;
  18 +
  19 + @Expose @SerializedName("set")
  20 + private final Map<String, String> map = new HashMap<String, String>();
  21 +
  22 + @Expose @SerializedName("private")
  23 + private boolean isPrivate;
  24 +
  25 + public WebPreferencesRequestSet(IWebPreferencesServiceDelegate delegate, String uuid, Map<String, String> values)
  26 + {
  27 + this(delegate, uuid, values, false);
  28 + }
  29 +
  30 + public WebPreferencesRequestSet(IWebPreferencesServiceDelegate delegate, String uuid, Map<String, String> values, boolean isPrivate)
  31 + {
  32 + super(delegate, uuid);
  33 +
  34 + if (isPrivate && delegate.getSession() == null)
  35 + {
  36 + throw new InvalidRequestException(RequestFailureReason.NO_SESSION, "Cannot request private values without supplying a session");
  37 + }
  38 +
  39 + this.validate(values);
  40 +
  41 + this.map.putAll(values);
  42 + this.isPrivate = isPrivate;
  43 + }
  44 +
  45 + @Override
  46 + protected String getPath()
  47 + {
  48 + return "/set";
  49 + }
  50 +
  51 + @Override
  52 + public boolean isValidationRequired()
  53 + {
  54 + return true;
  55 + }
  56 +
  57 + @Override
  58 + public Set<String> getKeys()
  59 + {
  60 + return this.map.keySet();
  61 + }
  62 +
  63 + public Map<String, String> getMap()
  64 + {
  65 + return this.map;
  66 + }
  67 +
  68 + @Override
  69 + protected void validateResponse(IWebPreferencesResponse response)
  70 + {
  71 + if (response.hasSetters())
  72 + {
  73 + Set<String> responseKeys = response.getSetters();
  74 + for (String key : this.map.keySet())
  75 + {
  76 + if (!responseKeys.contains(key))
  77 + {
  78 + throw new InvalidResponseException(RequestFailureReason.BAD_DATA,
  79 + "The server responded with an incomplete key set, missing key [" + key + "]");
  80 + }
  81 + }
  82 + }
  83 + }
  84 +
  85 + private void validate(Map<String, String> set)
  86 + {
  87 + for (Entry<String, String> entry : set.entrySet())
  88 + {
  89 + this.validateKey(entry.getKey());
  90 + this.validateValue(entry.getKey(), entry.getValue());
  91 + }
  92 + }
  93 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesResponse.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.util.HashSet;
  4 +import java.util.List;
  5 +import java.util.Map;
  6 +import java.util.Set;
  7 +
  8 +import com.google.gson.Gson;
  9 +import com.google.gson.GsonBuilder;
  10 +import com.google.gson.JsonSyntaxException;
  11 +import com.google.gson.annotations.Expose;
  12 +import com.google.gson.annotations.SerializedName;
  13 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  14 +
  15 +class WebPreferencesResponse implements IWebPreferencesResponse
  16 +{
  17 + private static final long serialVersionUID = 1L;
  18 +
  19 + private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
  20 +
  21 + @Expose @SerializedName("response")
  22 + private String response;
  23 +
  24 + @Expose @SerializedName("message")
  25 + private String message;
  26 +
  27 + @Expose @SerializedName("uuid")
  28 + private String uuid;
  29 +
  30 + @Expose @SerializedName("serverid")
  31 + private String serverId;
  32 +
  33 + @Expose @SerializedName("rate")
  34 + private int rateLimit;
  35 +
  36 + @Expose @SerializedName("get")
  37 + private Map<String, String> get;
  38 +
  39 + @Expose @SerializedName("set")
  40 + private List<String> set;
  41 +
  42 + private transient Throwable th;
  43 +
  44 + public WebPreferencesResponse() {}
  45 +
  46 + private WebPreferencesResponse(String response, Throwable th)
  47 + {
  48 + this.response = response;
  49 + this.th = th;
  50 + }
  51 +
  52 + @Override
  53 + public String getResponse()
  54 + {
  55 + return this.response;
  56 + }
  57 +
  58 + @Override
  59 + public String getMessage()
  60 + {
  61 + return this.message;
  62 + }
  63 +
  64 + @Override
  65 + public Throwable getThrowable()
  66 + {
  67 + return this.th;
  68 + }
  69 +
  70 + @Override
  71 + public String getUUID()
  72 + {
  73 + return this.uuid;
  74 + }
  75 +
  76 + @Override
  77 + public String getServerId()
  78 + {
  79 + return this.serverId;
  80 + }
  81 +
  82 + @Override
  83 + public boolean hasValues()
  84 + {
  85 + return this.get != null;
  86 + }
  87 +
  88 + @Override
  89 + public Map<String, String> getValues()
  90 + {
  91 + return this.get;
  92 + }
  93 +
  94 + @Override
  95 + public boolean hasSetters()
  96 + {
  97 + return this.set != null;
  98 + }
  99 +
  100 + @Override
  101 + public Set<String> getSetters()
  102 + {
  103 + return new HashSet<String>(this.set);
  104 + }
  105 +
  106 + public static IWebPreferencesResponse fromJson(String json)
  107 + {
  108 + try
  109 + {
  110 + return WebPreferencesResponse.gson.fromJson(json, WebPreferencesResponse.class);
  111 + }
  112 + catch (JsonSyntaxException ex)
  113 + {
  114 + return new WebPreferencesResponse("500 Invalid JSON", ex);
  115 + }
  116 + catch (Throwable th)
  117 + {
  118 + return new WebPreferencesResponse("500 Invalid JSON", th);
  119 + }
  120 + }
  121 +
  122 + @Override
  123 + public String toString()
  124 + {
  125 + try
  126 + {
  127 + return WebPreferencesResponse.gson.toJson(this);
  128 + }
  129 + catch (Throwable th)
  130 + {
  131 + return "{\"Invalid JSON\"}";
  132 + }
  133 + }
  134 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesService.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import java.io.BufferedReader;
  4 +import java.io.IOException;
  5 +import java.io.InputStream;
  6 +import java.io.InputStreamReader;
  7 +import java.io.OutputStream;
  8 +import java.io.UnsupportedEncodingException;
  9 +import java.net.HttpURLConnection;
  10 +import java.net.Proxy;
  11 +import java.net.URI;
  12 +import java.net.URL;
  13 +import java.net.URLEncoder;
  14 +import java.util.ArrayList;
  15 +import java.util.HashMap;
  16 +import java.util.List;
  17 +import java.util.Map;
  18 +import java.util.Map.Entry;
  19 +
  20 +import net.minecraft.util.Session;
  21 +
  22 +import org.apache.commons.io.IOUtils;
  23 +
  24 +import com.google.common.base.Charsets;
  25 +import com.google.gson.Gson;
  26 +import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
  27 +import com.mumfrey.webprefs.exceptions.InvalidRequestException;
  28 +import com.mumfrey.webprefs.exceptions.InvalidResponseException;
  29 +import com.mumfrey.webprefs.interfaces.IWebPreferencesRequest;
  30 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  31 +import com.mumfrey.webprefs.interfaces.IWebPreferencesService;
  32 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceMonitor;
  33 +
  34 +class WebPreferencesService implements IWebPreferencesService
  35 +{
  36 + private static final int TIMEOUT_MSEC = 5000;
  37 +
  38 + private final Proxy proxy;
  39 +
  40 + private final Session session;
  41 +
  42 + private final Map<String, String> serverKeys = new HashMap<String, String>();
  43 +
  44 + private final List<IWebPreferencesServiceMonitor> monitors = new ArrayList<IWebPreferencesServiceMonitor>();
  45 +
  46 + private long lastMojangAuth = 0L;
  47 +
  48 + WebPreferencesService(Proxy proxy, Session session)
  49 + {
  50 + this.proxy = proxy;
  51 + this.session = session;
  52 + }
  53 +
  54 + @Override
  55 + public void addMonitor(IWebPreferencesServiceMonitor monitor)
  56 + {
  57 + if (!this.monitors.contains(monitor))
  58 + {
  59 + this.monitors.add(monitor);
  60 + }
  61 + }
  62 +
  63 + void handleKeyRequestFailed(Throwable th)
  64 + {
  65 + LiteLoaderLogger.debug(th, "Key request failed with message %s", th.getMessage());
  66 +
  67 + for (IWebPreferencesServiceMonitor monitor : this.monitors)
  68 + {
  69 + monitor.onKeyRequestFailed();
  70 + }
  71 + }
  72 +
  73 + void handleKeyRequestCompleted(IWebPreferencesResponse response)
  74 + {
  75 + }
  76 +
  77 + @Override
  78 + public void submit(IWebPreferencesRequest request)
  79 + {
  80 + try
  81 + {
  82 + this.beginProcessingRequest(request);
  83 + }
  84 + catch (InvalidRequestException ex)
  85 + {
  86 + request.getDelegate().onRequestFailed(request, ex, ex.getReason());
  87 + }
  88 + }
  89 +
  90 + private IWebPreferencesResponse beginProcessingRequest(IWebPreferencesRequest request) throws InvalidRequestException
  91 + {
  92 + LiteLoaderLogger.debug("WebPreferencesService is processing %s for %s", request.getClass().getSimpleName(), request.getUUID());
  93 +
  94 + if (request.isValidationRequired())
  95 + {
  96 + String requestClass = request.getClass().getSimpleName();
  97 +
  98 + Session session = request.getDelegate().getSession();
  99 + if (session == null)
  100 + {
  101 + throw new InvalidRequestException(RequestFailureReason.NO_SESSION,
  102 + "Validation is required for " + requestClass + " but no session was provided.");
  103 + }
  104 +
  105 + String serverId = this.getServerIdForRequest(request);
  106 +
  107 + if (!this.registerServerConnection(session, serverId))
  108 + {
  109 + throw new InvalidRequestException(RequestFailureReason.NO_SESSION,
  110 + "Validation is required for " + requestClass + " but no session was provided or session validation failed");
  111 + }
  112 + }
  113 +
  114 + return this.processRequest(request);
  115 + }
  116 +
  117 + private IWebPreferencesResponse processRequest(IWebPreferencesRequest request)
  118 + {
  119 + try
  120 + {
  121 + String data = this.httpPost(request.getRequestURI(), request.getPostVars());
  122 + IWebPreferencesResponse response = WebPreferencesResponse.fromJson(data);
  123 +
  124 + LiteLoaderLogger.debug("Response: %s", response);
  125 + request.onReceivedResponse(response);
  126 +
  127 + request.getDelegate().onReceivedResponse(request, response);
  128 + return response;
  129 + }
  130 + catch (InvalidResponseException ex)
  131 + {
  132 + request.getDelegate().onRequestFailed(request, ex, ex.getReason());
  133 +
  134 + for (IWebPreferencesServiceMonitor monitor : this.monitors)
  135 + {
  136 + monitor.onRequestFailed(ex, ex.getReason().getSeverity());
  137 + }
  138 + }
  139 + catch (IOException ex)
  140 + {
  141 + request.getDelegate().onRequestFailed(request, ex, RequestFailureReason.SERVER_ERROR);
  142 +
  143 + for (IWebPreferencesServiceMonitor monitor : this.monitors)
  144 + {
  145 + monitor.onRequestFailed(ex, RequestFailureReason.SERVER_ERROR.getSeverity());
  146 + }
  147 + }
  148 + catch (Exception ex)
  149 + {
  150 + for (IWebPreferencesServiceMonitor monitor : this.monitors)
  151 + {
  152 + monitor.onRequestFailed(ex, RequestFailureReason.UNKNOWN.getSeverity());
  153 + }
  154 + }
  155 +
  156 + return null;
  157 + }
  158 +
  159 + private String getServerIdForRequest(IWebPreferencesRequest request)
  160 + {
  161 + if (request.getDelegate().getSession() == null)
  162 + {
  163 + return null;
  164 + }
  165 +
  166 + String hostName = request.getDelegate().getHostName();
  167 + String serverId = this.serverKeys.get(hostName);
  168 +
  169 + if (serverId == null)
  170 + {
  171 + LiteLoaderLogger.info("Looking up server ID for " + hostName);
  172 + WebPreferencesRequestKey keyRequest = new WebPreferencesRequestKey(this, this.session, hostName);
  173 + IWebPreferencesResponse response = this.processRequest(keyRequest);
  174 + if (response == null || response.getServerId() == null)
  175 + {
  176 + throw new InvalidRequestException(RequestFailureReason.SERVER_ERROR, "Could not retrieve server ID for " + hostName);
  177 + }
  178 +
  179 + serverId = response.getServerId();
  180 + this.serverKeys.put(hostName, serverId);
  181 +
  182 + LiteLoaderLogger.info("Got server ID for " + hostName + " [" + serverId + "]");
  183 + }
  184 +
  185 + return serverId;
  186 + }
  187 +
  188 + public String httpPost(URI uri, Map<String, String> params) throws IOException
  189 + {
  190 + String query = this.buildQuery(params);
  191 + byte[] queryBytes = query.getBytes(Charsets.UTF_8);
  192 +
  193 + LiteLoaderLogger.debug("Connecting to " + uri);
  194 + HttpURLConnection http = (HttpURLConnection)uri.toURL().openConnection(this.proxy);
  195 + http.setConnectTimeout(WebPreferencesService.TIMEOUT_MSEC);
  196 + http.setReadTimeout(WebPreferencesService.TIMEOUT_MSEC);
  197 + http.setUseCaches(false);
  198 + http.setDoOutput(true);
  199 +
  200 + http.addRequestProperty("Content-type", "application/x-www-form-urlencoded");
  201 + http.setRequestProperty("Content-Length", "" + queryBytes.length);
  202 +
  203 + OutputStream outputStream = null;
  204 +
  205 + try
  206 + {
  207 + outputStream = http.getOutputStream();
  208 + IOUtils.write(queryBytes, outputStream);
  209 + }
  210 + finally
  211 + {
  212 + IOUtils.closeQuietly(outputStream);
  213 + }
  214 +
  215 + try
  216 + {
  217 + String debugMessages = http.getHeaderField("X-Debug-Message");
  218 + if (debugMessages != null)
  219 + {
  220 + String[] messages = new Gson().fromJson(debugMessages, String[].class);
  221 + for (String message : messages)
  222 + {
  223 + LiteLoaderLogger.debug("[SERVER] %s", message);
  224 + }
  225 + }
  226 + }
  227 + catch (Exception ex) {}
  228 +
  229 + InputStream inputStream = null;
  230 +
  231 + try
  232 + {
  233 + try
  234 + {
  235 + inputStream = http.getInputStream();
  236 + String response = IOUtils.toString(inputStream, Charsets.UTF_8);
  237 + return response;
  238 + }
  239 + catch (IOException ex)
  240 + {
  241 + IOUtils.closeQuietly(inputStream);
  242 + inputStream = http.getErrorStream();
  243 + if (inputStream == null)
  244 + {
  245 + return this.formatErrorAsJson(http.getResponseCode() + " " + http.getResponseMessage(), ex.getMessage());
  246 + }
  247 +
  248 + String response = IOUtils.toString(inputStream, Charsets.UTF_8);
  249 +
  250 + String contentType = http.getHeaderField("Content-type");
  251 + if (!"application/json".equals(contentType))
  252 + {
  253 + System.err.println(response);
  254 + return this.formatErrorAsJson(http.getResponseCode() + " " + http.getResponseMessage(), "Invalid content type " + contentType);
  255 + }
  256 +
  257 + return response;
  258 + }
  259 + }
  260 + finally
  261 + {
  262 + IOUtils.closeQuietly(inputStream);
  263 + }
  264 + }
  265 +
  266 + private String formatErrorAsJson(String response, String message)
  267 + {
  268 + return String.format("{\"response\":\"%s\",\"message\":\"%s\"}", response, message);
  269 + }
  270 +
  271 + private String buildQuery(Map<String, String> params)
  272 + {
  273 + StringBuilder sb = new StringBuilder();
  274 +
  275 + try
  276 + {
  277 + String separator = "";
  278 + for (Entry<String, String> postValue : params.entrySet())
  279 + {
  280 + sb.append(separator).append(postValue.getKey()).append("=").append(URLEncoder.encode(postValue.getValue(), "UTF-8"));
  281 + separator = "&";
  282 + }
  283 + }
  284 + catch (UnsupportedEncodingException ex)
  285 + {
  286 + ex.printStackTrace();
  287 + }
  288 +
  289 + return sb.toString();
  290 + }
  291 +
  292 + private boolean registerServerConnection(Session session, String serverId)
  293 + {
  294 + if (session == null || serverId == null)
  295 + {
  296 + return false;
  297 + }
  298 +
  299 + if (System.currentTimeMillis() - this.lastMojangAuth < 300000L)
  300 + {
  301 + LiteLoaderLogger.debug("Mojang connection is still fresh, using existing ticket");
  302 + return true;
  303 + }
  304 +
  305 + try
  306 + {
  307 + LiteLoaderLogger.debug("Creating Mojang session ticket...");
  308 + URL checkServerUrl = new URL("http://session.minecraft.net/game/joinserver.jsp?user=" + URLEncoder.encode(session.getUsername(), "UTF-8") + "&sessionId=" + URLEncoder.encode(session.getSessionID(), "UTF-8") + "&serverId=" + URLEncoder.encode(serverId, "UTF-8"));
  309 + BufferedReader responseReader = new BufferedReader(new InputStreamReader(checkServerUrl.openStream()));
  310 + String response = responseReader.readLine();
  311 + responseReader.close();
  312 + boolean joinSuccess = "OK".equals(response);
  313 + if (joinSuccess)
  314 + {
  315 + this.lastMojangAuth = System.currentTimeMillis();
  316 + return true;
  317 + }
  318 + }
  319 + catch (IOException ex)
  320 + {
  321 + ex.printStackTrace();
  322 + LiteLoaderLogger.debug("Failed to log on to invoke joinserver, connection to mojang failed");
  323 + throw new InvalidRequestException(RequestFailureReason.SERVER_ERROR, "Failed registering server connection with Mojang");
  324 + }
  325 +
  326 + return false;
  327 + }
  328 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesServiceTask.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import net.minecraft.util.Session;
  4 +
  5 +import com.mumfrey.webprefs.interfaces.IWebPreferencesClient;
  6 +import com.mumfrey.webprefs.interfaces.IWebPreferencesProvider;
  7 +import com.mumfrey.webprefs.interfaces.IWebPreferencesRequest;
  8 +import com.mumfrey.webprefs.interfaces.IWebPreferencesServiceDelegate;
  9 +
  10 +abstract class WebPreferencesServiceTask implements IWebPreferencesServiceDelegate
  11 +{
  12 + private final IWebPreferencesProvider provider;
  13 +
  14 + private final IWebPreferencesClient client;
  15 +
  16 + private IWebPreferencesRequest request;
  17 +
  18 + WebPreferencesServiceTask(IWebPreferencesProvider provider, IWebPreferencesClient client)
  19 + {
  20 + this.provider = provider;
  21 + this.client = client;
  22 + }
  23 +
  24 + public IWebPreferencesClient getClient()
  25 + {
  26 + return this.client;
  27 + }
  28 +
  29 + public IWebPreferencesRequest getRequest()
  30 + {
  31 + return this.request;
  32 + }
  33 +
  34 + public void setRequest(IWebPreferencesRequest request)
  35 + {
  36 + this.request = request;
  37 + }
  38 +
  39 + @Override
  40 + public String getHostName()
  41 + {
  42 + return this.provider.getHostName();
  43 + }
  44 +
  45 + @Override
  46 + public Session getSession()
  47 + {
  48 + return this.provider.getSession();
  49 + }
  50 +
  51 + @Override
  52 + public String toString()
  53 + {
  54 + return String.format("%s[%s]", this.getClass().getSimpleName(), this.request);
  55 + }
  56 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesServiceTaskGet.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import com.mumfrey.webprefs.interfaces.IWebPreferencesClient;
  4 +import com.mumfrey.webprefs.interfaces.IWebPreferencesProvider;
  5 +import com.mumfrey.webprefs.interfaces.IWebPreferencesRequest;
  6 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  7 +
  8 +class WebPreferencesServiceTaskGet extends WebPreferencesServiceTask
  9 +{
  10 + WebPreferencesServiceTaskGet(IWebPreferencesProvider provider, IWebPreferencesClient client)
  11 + {
  12 + super(provider, client);
  13 + }
  14 +
  15 + @Override
  16 + public void onReceivedResponse(IWebPreferencesRequest request, IWebPreferencesResponse response)
  17 + {
  18 + IWebPreferencesClient client = this.getClient();
  19 + if (client != null && response.hasValues())
  20 + {
  21 + client.onGetRequestSuccess(response.getUUID(), response.getValues());
  22 + }
  23 + }
  24 +
  25 + @Override
  26 + public void onRequestFailed(IWebPreferencesRequest request, Throwable th, RequestFailureReason reason)
  27 + {
  28 + IWebPreferencesClient client = this.getClient();
  29 + if (client != null)
  30 + {
  31 + client.onGetRequestFailed(request.getUUID(), request.getKeys(), reason);
  32 + }
  33 + }
  34 +}
src/client/java/com/mumfrey/webprefs/framework/WebPreferencesServiceTaskSet.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.framework;
  2 +
  3 +import com.mumfrey.webprefs.interfaces.IWebPreferencesClient;
  4 +import com.mumfrey.webprefs.interfaces.IWebPreferencesProvider;
  5 +import com.mumfrey.webprefs.interfaces.IWebPreferencesRequest;
  6 +import com.mumfrey.webprefs.interfaces.IWebPreferencesResponse;
  7 +
  8 +class WebPreferencesServiceTaskSet extends WebPreferencesServiceTask
  9 +{
  10 + WebPreferencesServiceTaskSet(IWebPreferencesProvider provider, IWebPreferencesClient client)
  11 + {
  12 + super(provider, client);
  13 + }
  14 +
  15 + @Override
  16 + public void onReceivedResponse(IWebPreferencesRequest request, IWebPreferencesResponse response)
  17 + {
  18 + IWebPreferencesClient client = this.getClient();
  19 + if (client != null && response.hasSetters())
  20 + {
  21 + client.onSetRequestSuccess(response.getUUID(), response.getSetters());
  22 + }
  23 + }
  24 +
  25 + @Override
  26 + public void onRequestFailed(IWebPreferencesRequest request, Throwable th, RequestFailureReason reason)
  27 + {
  28 + IWebPreferencesClient client = this.getClient();
  29 + if (client != null)
  30 + {
  31 + client.onSetRequestFailed(request.getUUID(), request.getKeys(), reason);
  32 + }
  33 + }
  34 +}
src/client/java/com/mumfrey/webprefs/interfaces/IReliableWebPreferences.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +/**
  4 + * Reliable WebPreferences, no this isn't implemented yet
  5 + *
  6 + * @author Adam Mummery-Smith
  7 + */
  8 +public interface IReliableWebPreferences extends IWebPreferences
  9 +{
  10 + public void isSynchronised(String key);
  11 +
  12 + public void setWithNotify(String key, String value, IWebPreferencesListener listener);
  13 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferences.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import java.util.Set;
  4 +
  5 +/**
  6 + * Web-based preferences, objects implementing this interface represent a remote
  7 + * asychronous Key/Value store which fetches and commits values on a best-effort
  8 + * basis.
  9 + *
  10 + * <p>Values in this store are not guaranteed to be correct, nor are values
  11 + * written to the store guaranteed to be successfully written to the store.
  12 + *
  13 + * <p>In general, consumers should call {@link #get} and {@link #set} with the
  14 + * assumption that reads and writes will happen asynchronously, eg. they should
  15 + * continually poll {@link #get} rather than caching any responses returned
  16 + * from the preferences object.</p>
  17 + *
  18 + * <p>Behaviour is such that any call to {@link #has} or {@link #get} will
  19 + * trigger asynchronous retrieval of properties from the backend server.
  20 + * Likewise calls to {@link #set} will trigger asychronous commit of dirty
  21 + * values (both reads and sets are batched and sent to the server as a single
  22 + * request where possible).</p>
  23 + *
  24 + * <p>Keys in the collection are restricted to lowercase letters and the period
  25 + * symbol only, failure to adhere to this format will cause any accessor methods
  26 + * to throw InvalidKeyException. Values in the collection are strings and are
  27 + * limited to 255 characters and must not be null, failure to adhere to these
  28 + * restrictions will cause accessors to throw {@link InvalidValueException}.</p>
  29 + *
  30 + * <p>Consumers can trigger synchronisation events on the collection using
  31 + * convenience methods, these methods do not ensure propagation of settings but
  32 + * act can be used to alter the normal behaviour of the set when necessary, for
  33 + * example to poll for updated values periodically. The methods request(),
  34 + * poll() and commit() can be used to trigger synchronisation events, consult
  35 + * the javadoc for each method for more details.</p>
  36 + *
  37 + * @author Adam Mummery-Smith
  38 + */
  39 +public interface IWebPreferences
  40 +{
  41 + /**
  42 + * Get the UUID assoicated with this preference collection
  43 + */
  44 + public abstract String getUUID();
  45 +
  46 + /**
  47 + * Get whether this collection is private or public
  48 + */
  49 + public abstract boolean isPrivate();
  50 +
  51 + /**
  52 + * Get whether this collection is read-only. Only the player's local
  53 + * preferences are writable. Any attempt to write to a read-only collection
  54 + * will throw a ReadOnlyPreferencesException.
  55 + */
  56 + public abstract boolean isReadOnly();
  57 +
  58 + /**
  59 + * Indicate to the set that the value specified by key is required an
  60 + * should be fetched from the server in the next batch. In general,
  61 + * consumers should use get() or has() to access the values in this
  62 + * collection, and expect that the collection will manage fetching the
  63 + * values from the server as part of the normal update cycle. However this
  64 + * method has two uses:</p>
  65 + *
  66 + * <ul>
  67 + * <li>You may choose to call {@link #request} when a handle to a
  68 + * preferences set is obtained, to indicate to the preferences set that
  69 + * you will require the value in the future and it should attempt to fetch
  70 + * the value so that it is ready for queries against the set later.</li>
  71 + * <li>You may wish to indicate to the set that it should request an
  72 + * updated value from the server for a key which it already has (normally
  73 + * values are cached indefinitely).</li>
  74 + * </ul>
  75 + *
  76 + * <p>In both cases, calls to request() should generally be limited to
  77 + * periodic request for values, to avoid constantly polling the server for
  78 + * values, and potentially running foul of request throttling at the server
  79 + * side</p>
  80 + *
  81 + * @param key key to request from the server
  82 + */
  83 + public abstract void request(String key);
  84 +
  85 + /**
  86 + * Works exactly as {@link IWebPreferences#request(String)} but allows
  87 + * multiple values to be requested in a single invocation
  88 + *
  89 + * @param keys keys to request
  90 + */
  91 + public abstract void request(String... keys);
  92 +
  93 + /**
  94 + * Works exactly as {@link IWebPreferences#request(String)} but allows
  95 + * multiple values to be requested in a single invocation
  96 + *
  97 + * @param keys keys to request
  98 + */
  99 + public abstract void request(Set<String> keys);
  100 +
  101 + /**
  102 + * Calling <tt>poll()</tt> is essentially the same as calling
  103 + * {@link #request} for every key currently in the collection, this method
  104 + * can essentially be used to refresh the entire collection and should be
  105 + * called only in exceptional circumstances. It is called automatically by
  106 + * the preferences manager when connecting to a server.
  107 + *
  108 + * <p>Invoking <tt>poll()</tt> causes all of the values in the collection to
  109 + * be requested as a single batch</p>
  110 + */
  111 + public abstract void poll();
  112 +
  113 + /**
  114 + * Similar to {@link poll} except for property writes instead of property
  115 + * reads. Under normal circumstances it should not be necessary to call this
  116 + * method, since commits are handled asychronously by the update loop.
  117 + * However it can be used to forcibly commit even "clean" values to the
  118 + * server. This is useful if you wish to ensure that values on the server be
  119 + * set to match the current values in the collection, regardless of
  120 + * comodification elsewhere.
  121 + *
  122 + * @param force If set to false, only dirty properties are batched. If true,
  123 + * all properties are batched.
  124 + */
  125 + public abstract void commit(boolean force);
  126 +
  127 + /**
  128 + * Get whether this collection has a value for the specified key, and
  129 + * triggers asnchronous retrieval if not
  130 + *
  131 + * @param key Key to check for
  132 + * @return
  133 + */
  134 + public abstract boolean has(String key);
  135 +
  136 + /**
  137 + * Get the value for the specified key from this collection. Invoking this
  138 + * method causes asynchronous retrieval of the specified key if it is not
  139 + * found in the collection and returns null. If the key is found, then the
  140 + * value is returned and the collection remains unchanged.
  141 + *
  142 + * @param key
  143 + * @return
  144 + */
  145 + public abstract String get(String key);
  146 +
  147 + /**
  148 + * Works exactly like get(String), including triggering asynchronous
  149 + * retrieval of the property if the property is not found in the collection,
  150 + * except that if the property is not found the specified defaultValue is
  151 + * returned instead of returning null.
  152 + *
  153 + * @param key
  154 + * @param defaultValue
  155 + * @return
  156 + */
  157 + public abstract String get(String key, String defaultValue);
  158 +
  159 + /**
  160 + * Sets a value in the collection and marks it for asynchronous commit to
  161 + * the server.
  162 + *
  163 + * @param key
  164 + * @param value
  165 + */
  166 + public abstract void set(String key, String value);
  167 +
  168 + /**
  169 + * Remove a key from this collection. Marks the key to be deleted from the
  170 + * server as well.
  171 + *
  172 + * @param key
  173 + */
  174 + public abstract void remove(String key);
  175 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesClient.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import java.util.Map;
  4 +import java.util.Set;
  5 +
  6 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  7 +
  8 +public interface IWebPreferencesClient
  9 +{
  10 + public abstract void onGetRequestSuccess(String uuid, Map<String, String> values);
  11 +
  12 + public abstract void onSetRequestSuccess(String uuid, Set<String> keys);
  13 +
  14 + public abstract void onGetRequestFailed(String uuid, Set<String> keys, RequestFailureReason reason);
  15 +
  16 + public abstract void onSetRequestFailed(String uuid, Set<String> keys, RequestFailureReason reason);
  17 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesListener.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import java.util.Set;
  4 +
  5 +public interface IWebPreferencesListener
  6 +{
  7 + public abstract void onCommitSuccess(IReliableWebPreferences preferences, Set<String> keys);
  8 +
  9 + public abstract void onCommitFailed(IReliableWebPreferences preferences, Set<String> keys);
  10 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesProvider.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import java.util.Map;
  4 +import java.util.Set;
  5 +
  6 +import net.minecraft.util.Session;
  7 +
  8 +public interface IWebPreferencesProvider
  9 +{
  10 + public abstract boolean isActive();
  11 +
  12 + public abstract String getHostName();
  13 +
  14 + public abstract Session getSession();
  15 +
  16 + public abstract IWebPreferencesService getService();
  17 +
  18 + public boolean requestGet(IWebPreferencesClient client, String uuid, Set<String> keys, boolean getPrivate);
  19 +
  20 + public boolean requestSet(IWebPreferencesClient client, String uuid, Map<String, String> values, boolean setPrivate);
  21 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesRequest.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import java.io.Serializable;
  4 +import java.net.URI;
  5 +import java.util.Map;
  6 +import java.util.Set;
  7 +
  8 +public interface IWebPreferencesRequest extends Serializable
  9 +{
  10 + public abstract IWebPreferencesServiceDelegate getDelegate();
  11 +
  12 + public abstract boolean isValidationRequired();
  13 +
  14 + public abstract URI getRequestURI();
  15 +
  16 + public abstract String getUUID();
  17 +
  18 + public abstract Set<String> getKeys();
  19 +
  20 + public abstract Map<String, String> getPostVars();
  21 +
  22 + public abstract void onReceivedResponse(IWebPreferencesResponse response);
  23 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesResponse.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import java.io.Serializable;
  4 +import java.util.Map;
  5 +import java.util.Set;
  6 +
  7 +public interface IWebPreferencesResponse extends Serializable
  8 +{
  9 + public abstract String getResponse();
  10 +
  11 + public abstract String getMessage();
  12 +
  13 + public abstract Throwable getThrowable();
  14 +
  15 + public abstract String getUUID();
  16 +
  17 + public abstract String getServerId();
  18 +
  19 + public abstract boolean hasSetters();
  20 +
  21 + public abstract Set<String> getSetters();
  22 +
  23 + public abstract boolean hasValues();
  24 +
  25 + public abstract Map<String, String> getValues();
  26 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesService.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +public interface IWebPreferencesService
  4 +{
  5 + public abstract void addMonitor(IWebPreferencesServiceMonitor monitor);
  6 +
  7 + public abstract void submit(IWebPreferencesRequest request);
  8 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesServiceDelegate.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +import net.minecraft.util.Session;
  4 +
  5 +import com.mumfrey.webprefs.framework.RequestFailureReason;
  6 +
  7 +public interface IWebPreferencesServiceDelegate
  8 +{
  9 + public abstract String getHostName();
  10 +
  11 + public abstract Session getSession();
  12 +
  13 + public abstract void onReceivedResponse(IWebPreferencesRequest request, IWebPreferencesResponse response);
  14 +
  15 + public abstract void onRequestFailed(IWebPreferencesRequest request, Throwable th, RequestFailureReason reason);
  16 +}
src/client/java/com/mumfrey/webprefs/interfaces/IWebPreferencesServiceMonitor.java 0 → 100644
  View file @3fb6dc8
  1 +package com.mumfrey.webprefs.interfaces;
  2 +
  3 +public interface IWebPreferencesServiceMonitor
  4 +{
  5 + public abstract void onKeyRequestFailed();
  6 +
  7 + public abstract void onRequestFailed(Throwable th, int severity);
  8 +}