Add GET request

Author: grohith327

.gitignore

@@ -1 +1,2 @@
-*.class
+*.class
+*.bin

BTree.java

@@ -68,7 +68,7 @@ public Optional<String> search(String key) {
                 i++;
             }
 
-            if (i < this.keySize && key == this.keys[i].key) {
+            if (i < this.keySize && key.equals(this.keys[i].key)) {
                 return Optional.of(this.keys[i].path);
             }
 

FileManager.java

@@ -0,0 +1,46 @@
+import java.io.RandomAccessFile;
+import java.nio.charset.StandardCharsets;
+import java.util.logging.Logger;
+import java.io.IOException;
+
+public class FileManager {
+    private static final Logger logger = Logger.getLogger(FileManager.class.getName());
+
+    private static final int BLOCK_SIZE = 4096;
+
+    public FileManager() {}
+
+    public void write(String filePath, String data) throws IOException {
+        try (RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "rw")) {
+            byte[] paddedData = padToBlockSize(data);
+            randomAccessFile.write(paddedData);
+            logger.info(String.format("Successfully persisted data to path: %s", filePath));
+        }
+    }
+
+    public String read(String filePath) throws IOException {
+        try (RandomAccessFile randomAccessFile = new RandomAccessFile(filePath, "r")) {
+            byte[] bytes = new byte[BLOCK_SIZE];
+            randomAccessFile.read(bytes);
+            return new String(bytes, StandardCharsets.UTF_8).trim();
+        }
+    }
+
+    // We pad to block size to ensure each string clearly takes one block.
+    // Not the most efficient way, you could also store multiple strings within a 
+    // single block and maintain its offset but we are not doing that here. 
+    private static byte[] padToBlockSize(String data) {
+        byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
+        if (bytes.length > BLOCK_SIZE) {
+            throw new RuntimeException(String.format("You shall not proceed, data is too big: %s - %s", bytes, bytes.length));
+        }
+
+        if (bytes.length == BLOCK_SIZE) {
+            return bytes;
+        }
+
+        byte[] paddedData = new byte[BLOCK_SIZE];
+        System.arraycopy(bytes, 0, paddedData, 0, bytes.length);
+        return paddedData;
+    }
+}

NotADataBase.java

@@ -0,0 +1,32 @@
+import java.io.IOException;
+import java.util.Optional;
+
+public class NotADataBase {
+    private BTree bTree;
+    private FileManager fileManager;
+
+    public NotADataBase() {
+        // Ideally you can choose the degree of the tree in such a way that each 
+        // tree node nicely fits into block. However, we are storing the tree
+        // in-memory and not to disk :( Therefore, we don't have to put too much thought
+        // into degree
+        bTree = new BTree(50);
+        fileManager = new FileManager();
+    }
+
+    public String query(String id) throws IOException {
+        Optional<String> path = bTree.search(id);
+        if (path.isEmpty()) {
+            return null;
+        }
+
+        String result = fileManager.read(path.get());
+        return result;
+    }
+
+    public void write(String id, String data) throws IOException {
+        String filePath = String.format("%s.bin", id);
+        bTree.insert(id, filePath);
+        fileManager.write(filePath, data);
+    }
+}

Server.java

@@ -17,6 +17,7 @@
 public class Server {
     private static final Logger logger = Logger.getLogger(Server.class.getName());
     private static final Encoder encoder = new Encoder();
+    private static final NotADataBase nDb = new NotADataBase();
     private static final AtomicLong counter = new AtomicLong(0);
 
     public static void main(String[] args) {
@@ -81,13 +82,29 @@ private static void handleRequest(Socket clientSocket) {
                             break;
                         }
 
-                        // TODO: Perform a validation if URL is already shortened before increementing
-                        long counterValue = counter.incrementAndGet();
-                        String shortenedUrl = encoder.encode(counterValue);
-                        responseBody.put("shortedUrl", shortenedUrl);
-                        response = createResponse(200, "OK", stringifyJson(responseBody));
+                        try {
+                            long counterValue = counter.incrementAndGet();
+                            String shortenedUrl = encoder.encode(counterValue);
+                            nDb.write(shortenedUrl, urlPath);
+                            responseBody.put("shortedUrl", shortenedUrl);
+                            response = createResponse(200, "OK", stringifyJson(responseBody));
+                        } catch (IOException e) {
+                            response = createResponse(500, "Failed to persist url", "");
+                        }
+                        break;
+                    }
+                case "GET":
+                    String url = path.split("/")[1];
+                    String result = nDb.query(url);
+                    if (result == null) {
+                        response = createResponse(400, "Invalid URL", "");
                         break;
                     }
+
+                    logger.info("Retrieved result is NOT null: " + result);
+                    responseBody.put("result", result);
+                    response = createResponse(200, "OK", stringifyJson(responseBody));
+                    break;
                 default:
                     responseBody.put("errorMessage", "Invalid request");
                     response = createResponse(400, "Bad Request", stringifyJson(responseBody));
@@ -110,13 +127,15 @@ private static void handleRequest(Socket clientSocket) {
     private final class Constants {
         public static int CORE_POOL_SIZE = 10;
         public static int MAX_POOL_SIZE = 10;
-        public static long KEEP_ALIVE_TIME = 300;
+        public static long KEEP_ALIVE_TIME = 1000;
         public static int QUEUE_SIZE = 10;
     }
 
     private static String createResponse(int statusCode, String message, String body) {
+        int contentLength = body.getBytes(StandardCharsets.UTF_8).length;
         return "HTTP/1.1 " + statusCode + " " + message + "\n" + 
         "Content-Type: application/json\n" + 
+        "Content-Length: " + contentLength + "\n" +
         "\n" + body;
     }