Documentation

Author: Katsute

src/main/java/com/kttdevelopment/simplehttpserver/handler/ConnectionThrottler.java

@@ -3,12 +3,37 @@
 import com.sun.net.httpserver.HttpExchange;
 
 /**
+ * Determines how connections are handled by the {@link ThrottledHandler}.
  *
+ * @see ServerThrottler
+ * @see SessionThrottler
+ * @since 03.03.00
+ * @version 03.03.00
+ * @author Ktt Development
  */
 abstract class ConnectionThrottler {
 
+    /**
+     * Adds a connection to the pool.
+     *
+     * @param exchange exchange to process
+     * @return if exchange was able to be added
+     *
+     * @see #deleteConnection(HttpExchange)
+     * @since 03.03.00
+     * @author Ktt Development
+     */
     abstract boolean addConnection(final HttpExchange exchange);
 
+    /**
+     * Removes a connection from the pool.
+     *
+     * @param exchange exchange to process
+     *
+     * @see #addConnection(HttpExchange)
+     * @since 03.03.00
+     * @author Ktt Development
+     */
     abstract void deleteConnection(final HttpExchange exchange);
 
 }

src/main/java/com/kttdevelopment/simplehttpserver/handler/RedirectHandler.java

@@ -40,7 +40,6 @@ public final void handle(final SimpleHttpExchange exchange) throws IOException{
 
 //
 
-
     @SuppressWarnings("StringBufferReplaceableByString")
     @Override
     public String toString(){

src/main/java/com/kttdevelopment/simplehttpserver/handler/SSEHandler.java

@@ -12,6 +12,14 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
+/**
+ * A SSE handler allows server to client events by using an <code>text/event-stream</code>. Events are sent using {@link #push(String)} or {@link #push(String, int, String)}.
+ *
+ * @see SimpleHttpHandler
+ * @since 03.01.00
+ * @version 03.03.00
+ * @author Ktt Development
+ */
 public class SSEHandler implements SimpleHttpHandler {
 
     private final List<OutputStream> listeners = new ArrayList<>();
@@ -48,10 +56,30 @@ public final void handle(final SimpleHttpExchange exchange) throws IOException{
         listeners.add(exchange.getOutputStream());
     }
 
+    /**
+     * Pushes an event to the stream.
+     *
+     * @param data data to send
+     *
+     * @see #push(String, int, String)
+     * @since 03.01.00
+     * @author Ktt Development
+     */
     public synchronized final void push(final String data){
         push(data,0,"");
     }
 
+    /**
+     * Pushes an event to the stream.
+     *
+     * @param data data to send
+     * @param retry how long to retry for
+     * @param event event type
+     *
+     * @see #push(String)
+     * @since 03.01.00
+     * @author Ktt Development
+     */
     public synchronized final void push(final String data, final int retry, final String event){
         eventId.addAndGet(1);
         final EventStreamRecord record = new EventStreamRecord(retry,event,data);

src/main/java/com/kttdevelopment/simplehttpserver/handler/ServerThrottler.java

@@ -5,37 +5,55 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 
+/**
+ * Limits connections for the server.
+ *
+ * @see ThrottledHandler
+ * @see SessionThrottler
+ * @since 03.03.00
+ * @version 03.03.00
+ * @author Ktt Development
+ */
 public class ServerThrottler extends ConnectionThrottler {
 
-    private final Predicate<HttpExchange> usesLimit;
+    private final Predicate<HttpExchange> countsTowardsLimit;
     private final AtomicInteger connections = new AtomicInteger(0);
 
-    private int maxConnections = 0;
+    private final AtomicInteger maxConnections = new AtomicInteger(0);
 
     public ServerThrottler(){
-        usesLimit = exchange -> true;
+        countsTowardsLimit = exchange -> true;
     }
 
     public ServerThrottler(final int maxConnections){
-        usesLimit = exchange -> true;
-        this.maxConnections = maxConnections;
+        countsTowardsLimit = exchange -> true;
+        this.maxConnections.set(maxConnections);
     }
 
-    public ServerThrottler(final Predicate<HttpExchange> counts){
-        this.usesLimit = counts;
+    public ServerThrottler(final Predicate<HttpExchange> countsTowardsLimit){
+        this.countsTowardsLimit = countsTowardsLimit;
     }
 
-    public ServerThrottler(final Predicate<HttpExchange> contributeToLimit, final int maxConnections){
-        this.usesLimit = contributeToLimit;
-        this.maxConnections = maxConnections;
+    public ServerThrottler(final Predicate<HttpExchange> countsTowardsLimit, final int maxConnections){
+        this.countsTowardsLimit = countsTowardsLimit;
+        this.maxConnections.set(maxConnections);
+    }
+
+    public final int getMaxConnections(){
+        return maxConnections.get();
+    }
+
+    public synchronized final void setMaxConnections(final int maxConnections){
+        if(maxConnections >= 0)
+            this.maxConnections.set(maxConnections);
     }
 
     final boolean addConnection(final HttpExchange exchange){
-        if(!usesLimit.test(exchange)){
+        if(!countsTowardsLimit.test(exchange)){
             return true;
         }else{
             synchronized(this){
-                if(connections.get() + 1 <= maxConnections){
+                if(connections.get() + 1 <= maxConnections.get()){
                     connections.incrementAndGet();
                     return true;
                 }
@@ -45,21 +63,23 @@ final boolean addConnection(final HttpExchange exchange){
     }
 
     final void deleteConnection(final HttpExchange exchange){
-        if(usesLimit.test(exchange))
+        if(countsTowardsLimit.test(exchange))
             synchronized(this){
                 connections.decrementAndGet();
             }
     }
 
     //
 
+    @SuppressWarnings("StringBufferReplaceableByString")
     @Override
     public String toString(){
         final StringBuilder OUT = new StringBuilder();
 
         OUT.append("ConnectionThrottler")   .append('{');
-        OUT.append("connections")           .append('=')    .append(connections)        .append(", ");
-        OUT.append("maxConnections")        .append('=')    .append(maxConnections);
+        OUT.append("condition")             .append('=')    .append(countsTowardsLimit)     .append(", ");
+        OUT.append("connections")           .append('=')    .append(connections.get())      .append(", ");
+        OUT.append("maxConnections")        .append('=')    .append(maxConnections.get());
         OUT.append('}');
 
         return OUT.toString();

src/main/java/com/kttdevelopment/simplehttpserver/handler/SessionThrottler.java

@@ -7,46 +7,65 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Predicate;
 
+/**
+ * Limits connections per http session.
+ *
+ * @see ThrottledHandler
+ * @see ServerThrottler
+ * @see HttpSession
+ * @since 03.03.00
+ * @version 03.03.00
+ * @author Ktt Development
+ */
 public class SessionThrottler extends ConnectionThrottler {
 
     private final HttpSessionHandler sessionHandler;
 
-    private final Predicate<HttpSession> usesLimit;
+    private final Predicate<HttpSession> countsTowardsLimit;
     private final Map<HttpSession, AtomicInteger> sessions = Collections.synchronizedMap(new HashMap<>());
 
-    private int maxConnections = 0;
+    private final AtomicInteger maxConnections = new AtomicInteger(0);
 
     public SessionThrottler(final HttpSessionHandler sessionHandler){
         this.sessionHandler = sessionHandler;
-        usesLimit = (exchange) -> true;
+        countsTowardsLimit = (exchange) -> true;
     }
 
     public SessionThrottler(final HttpSessionHandler sessionHandler, final int maxConnections){
         this.sessionHandler = sessionHandler;
-        usesLimit = (exchange) -> true;
-        this.maxConnections = maxConnections;
+        countsTowardsLimit = (exchange) -> true;
+        this.maxConnections.set(maxConnections);
     }
 
-    public SessionThrottler(final HttpSessionHandler sessionHandler, final Predicate<HttpSession> usesLimit){
+    public SessionThrottler(final HttpSessionHandler sessionHandler, final Predicate<HttpSession> countsTowardsLimit){
         this.sessionHandler = sessionHandler;
-        this.usesLimit = usesLimit;
+        this.countsTowardsLimit = countsTowardsLimit;
     }
 
-    public SessionThrottler(final HttpSessionHandler sessionHandler, final Predicate<HttpSession> usesLimit, final int maxConnections){
+    public SessionThrottler(final HttpSessionHandler sessionHandler, final Predicate<HttpSession> countsTowardsLimit, final int maxConnections){
         this.sessionHandler = sessionHandler;
-        this.usesLimit = usesLimit;
-        this.maxConnections = maxConnections;
+        this.countsTowardsLimit = countsTowardsLimit;
+        this.maxConnections.set(maxConnections);
+    }
+
+    public final int getMaxConnections(){
+        return maxConnections.get();
+    }
+
+    public synchronized final void setMaxConnections(final int maxConnections){
+        if(maxConnections >= 0)
+            this.maxConnections.set(maxConnections);
     }
 
     @Override
     final boolean addConnection(final HttpExchange exchange){
         final HttpSession session = sessionHandler.getSession(exchange);
-        if(!usesLimit.test(session)){
+        if(!countsTowardsLimit.test(session)){
             return true;
         }else{
             synchronized(this){
                 final AtomicInteger conn = sessions.get(session);
-                if(conn.get() + 1 <= maxConnections){
+                if(conn.get() + 1 <= maxConnections.get()){
                     conn.incrementAndGet();
                     return true;
                 }
@@ -58,10 +77,26 @@ final boolean addConnection(final HttpExchange exchange){
     @Override
     final void deleteConnection(final HttpExchange exchange){
         final HttpSession session = sessionHandler.getSession(exchange);
-        if(usesLimit.test(session))
+        if(countsTowardsLimit.test(session))
             synchronized(this){
                 sessions.get(session).decrementAndGet();
             }
     }
 
+    //
+
+    @SuppressWarnings("StringBufferReplaceableByString")
+    @Override
+    public String toString(){
+        final StringBuilder OUT = new StringBuilder();
+
+        OUT.append("SessionThrottler")  .append('{');
+        OUT.append("condition")         .append('=')    .append(countsTowardsLimit)     .append(", ");
+        OUT.append("sessions")          .append('=')    .append(sessions.toString())    .append(", ");
+        OUT.append("maxConnections")    .append('=')    .append(maxConnections.get());
+        OUT.append('}');
+
+        return OUT.toString();
+    }
+
 }

src/main/java/com/kttdevelopment/simplehttpserver/handler/ThrottledHandler.java

@@ -5,12 +5,33 @@
 
 import java.io.IOException;
 
+/**
+ * This handler limits the amount of active connections to a handler. This can be used to limit the amount of simultaneous downloads, or prevent duplicate connections by users.
+ *
+ * @see ServerThrottler
+ * @see SessionThrottler
+ * @since 03.03.00
+ * @version 03.03.00
+ * @author Ktt Development
+ */
 public class ThrottledHandler implements HttpHandler {
 
     private final HttpHandler     handler;
-    private final ServerThrottler throttler;
+    private final ConnectionThrottler throttler;
 
-    public ThrottledHandler(final HttpHandler handler, final ServerThrottler throttler){
+    /**
+     * Creates a throttled handler using a throttler.
+     *
+     * @param handler handler to use
+     * @param throttler how to throttle connections
+     *
+     * @see HttpHandler
+     * @see ServerThrottler
+     * @see SessionThrottler
+     * @since 03.03.00
+     * @author Ktt Development
+     */
+    public ThrottledHandler(final HttpHandler handler, final ConnectionThrottler throttler){
         this.handler = handler;
         this.throttler = throttler;
     }