Add Gatling Simulation (#10)

Author: AnEmortalKid

.gitignore

@@ -28,3 +28,9 @@ pom.xml.versionsBackup
 # Eclipse Project files
 .metadata
 .recommenders
+
+# Intellij
+*.iml
+
+# dumps directory
+dumps/

java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/WorkshopApplication.java

@@ -1,7 +1,7 @@
 package cchesser.javaperf.workshop;
 
 import com.fasterxml.jackson.databind.SerializationFeature;
-import cchesser.javaperf.workshop.health.RemoveServiceHealthCheck;
+import cchesser.javaperf.workshop.health.RemoteServiceHealthCheck;
 import cchesser.javaperf.workshop.resources.WorkshopResource;
 import io.dropwizard.Application;
 import io.dropwizard.setup.Bootstrap;
@@ -26,7 +26,7 @@ public void initialize(Bootstrap<WorkshopConfiguration> bootstrap) {
     public void run(WorkshopConfiguration configuration, Environment environment) {
         final WorkshopResource resource = new WorkshopResource(configuration);
         environment.jersey().register(resource);
-        environment.healthChecks().register("remoteService", new RemoveServiceHealthCheck(configuration));
+        environment.healthChecks().register("remoteService", new RemoteServiceHealthCheck(configuration));
         environment.getObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
     }
 }

java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/WorkshopConfiguration.java

@@ -1,15 +1,18 @@
 package cchesser.javaperf.workshop;
 
-import org.hibernate.validator.constraints.NotEmpty;
-
+import cchesser.javaperf.workshop.cache.CacheConfiguration;
 import com.fasterxml.jackson.annotation.JsonProperty;
 import io.dropwizard.Configuration;
+import org.hibernate.validator.constraints.NotEmpty;
 
 public class WorkshopConfiguration extends Configuration {
 
     @NotEmpty
     private String conferenceServiceHost = "localhost:9090";
 
+    @JsonProperty
+    private CacheConfiguration historicalCache = new CacheConfiguration();
+
     @JsonProperty
     public String getConferenceServiceHost() {
         return conferenceServiceHost;
@@ -20,4 +23,13 @@ public void setSonferenceServiceHost(String host) {
         this.conferenceServiceHost = host;
     }
 
+    @JsonProperty
+    public CacheConfiguration getHistoricalCache() {
+        return historicalCache;
+    }
+
+    @JsonProperty
+    public void setHistoricalCache(CacheConfiguration historicalCache) {
+        this.historicalCache = historicalCache;
+    }
 }

java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/cache/CacheConfiguration.java

@@ -0,0 +1,39 @@
+package cchesser.javaperf.workshop.cache;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+import javax.validation.constraints.Max;
+import javax.validation.constraints.Min;
+
+public class CacheConfiguration {
+
+    @Min(32)
+    @Max(65536)
+    @JsonProperty
+    private int cacheLimit = 10000;
+
+    @Min(1024)
+    @Max(65536)
+    @JsonProperty
+    private int discardLimit = 65536;
+
+    @JsonProperty
+    public int getCacheLimit() {
+        return cacheLimit;
+    }
+
+    @JsonProperty
+    public void setCacheLimit(int cacheLimit) {
+        this.cacheLimit = cacheLimit;
+    }
+
+    @JsonProperty
+    public int getDiscardLimit() {
+        return discardLimit;
+    }
+
+    @JsonProperty
+    public void setDiscardLimit(int discardLimit) {
+        this.discardLimit = discardLimit;
+    }
+}

java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/cache/HistoricalCache.java

@@ -0,0 +1,92 @@
+package cchesser.javaperf.workshop.cache;
+
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+
+/**
+ * An LFU Cache with history tracking, modified
+ * from Stack Overflow: https://stackoverflow.com/a/23668899 (used as a basis).
+ *
+ * @author JMonterrubio
+ */
+public class HistoricalCache<K, V> {
+
+    private Map<K, CacheEntry<V>> innerCache = new LinkedHashMap<>();
+    private int cacheLimit;
+
+    private Deque<String> historyLog = new LinkedList<>();
+    private int historyLimit;
+
+    public HistoricalCache(int cacheLimit, int historyLimit) {
+        this.cacheLimit = cacheLimit;
+        this.historyLimit = historyLimit;
+    }
+
+    /**
+     * Stores the given key value pair in the cache
+     *
+     * @param key   the unique identifier associated with the given value
+     * @param value the value mapped to the given key
+     */
+    public void store(K key, V value) {
+        if (isFull()) {
+            K keyToRemove = getLFUKey();
+            HistoricalCache<K, V>.CacheEntry<V> removedEntry = innerCache.remove(keyToRemove);
+
+            if (historyLog.size() >= historyLimit) {
+                historyLog.removeLast();
+            }
+            historyLog.add(removedEntry.toString());
+        }
+
+        CacheEntry<V> newEntry = new CacheEntry<V>();
+        newEntry.data = value;
+        newEntry.frequency = 0;
+
+        innerCache.put(key, newEntry);
+    }
+
+    /**
+     * Retrieves the value associated with the given key from the cache.
+     *
+     * @param key the key that maps to that value
+     * @return the value mapped to the key
+     * @throws NullPointerException if the key doesn't exist
+     */
+    public V fetch(K key) {
+        if (innerCache.containsKey(key)) {
+            innerCache.get(key).frequency++;
+        }
+
+        return innerCache.get(key).data;
+    }
+
+    /**
+     * Indicates whether a key exists in the cache or not
+     *
+     * @param key the key to check
+     * @return <code>true</code> if the key is in the cache, <code>false</code>
+     * otherwise.
+     */
+    public boolean exists(K key) {
+        return innerCache.containsKey(key);
+    }
+
+    private boolean isFull() {
+        return innerCache.size() == cacheLimit;
+    }
+
+    private K getLFUKey() {
+        Optional<Entry<K, HistoricalCache<K, V>.CacheEntry<V>>> lfuEntry = innerCache.entrySet().stream()
+                .collect(Collectors.minBy(Comparator.comparingInt(entry -> entry.getValue().frequency)));
+
+        return lfuEntry.get().getKey();
+    }
+
+    private class CacheEntry<T> {
+        private T data;
+        private int frequency;
+    }
+
+}

…erf/workshop/data/AsciiArtConvertor.java …erf/workshop/data/AsciiArtConverter.javajava-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/data/AsciiArtConvertor.java renamed to java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/data/AsciiArtConverter.java java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/data/AsciiArtConvertor.java renamed to java-perf-workshop-server/src/main/java/cchesser/javaperf/workshop/data/AsciiArtConverter.java

@@ -1,20 +1,18 @@
 package cchesser.javaperf.workshop.data;
 
-import java.awt.Font;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.RenderingHints;
+import javax.imageio.ImageIO;
+import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
-
-import javax.imageio.ImageIO;
+import java.nio.file.Files;
+import java.nio.file.Path;
 
 /**
  * This is a trival example of doing something unnecessary in the service and using up some heap.
  * Example was obtained from StackOverflow: http://stackoverflow.com/questions/7098972/ascii-art-java
  */
-class AsciiArtConvertor  {
+class AsciiArtConverter {
 
     static String convert(String text) {
 
@@ -28,7 +26,11 @@ static String convert(String text) {
 
         StringBuilder rendered = new StringBuilder();
         try {
-            ImageIO.write(image, "png", new File("text.png"));
+            Path tempFilePath = Files.createTempFile("text", "png");
+            File tempFile = tempFilePath.toFile();
+            tempFile.deleteOnExit();
+
+            ImageIO.write(image, "png", tempFile);
 
             for (int y = 0; y < 32; y++) {
                 StringBuilder sb = new StringBuilder();