wtt

Author: 16BitS3G4l

.classpath

@@ -0,0 +1,109 @@
+package main.java.jswerve;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.file.Files;
+import java.nio.file.*;
+import java.util.HashMap;
+import java.io.File;
+import java.io.BufferedReader;
+import java.io.FileReader;
+
+public class BaseHTTPServer implements Runnable {
+	
+    private int port = 80; 
+    private ServerSocket ss;
+    private Socket s;
+    public static boolean isStopped = false;
+    private String serverPath  = "C:\\Users\\gitpu\\programming\\jswerve\\server"; // for other users it will be empty
+    private HashMap<String, String> routes;
+    
+    // structure of a server folder 
+    /* 
+        1. Routes file 
+         --- includes all the information on routes (from -> where)
+        2. Data files, etc
+        --- for most of this, I believe it will be inherit
+        3. Connections, mass communication
+        --- this is more of a inherit/just-in-time system based on more complex infrastructure 
+    */ 
+
+    private void initServerSocket() {
+        try { 
+            ss = new ServerSocket(port);
+        } catch(IOException e) {
+            System.out.println(e.getMessage()); // replace with logging utility
+        } 
+    }
+
+    private void acceptConectionsAndThrowToHandlers() {
+        try {
+            while (!isStopped) {
+                s = ss.accept();
+                
+                (new Thread(new ConnectionHandler(s))).start();
+            }			
+            
+        } catch(IOException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    public BaseHTTPServer(int port) {
+        this.port = port;
+
+        // parse the routes in the routes file
+        parseRoutes();
+    }
+    
+    public void parseRoutes() {
+        File routesFile = new File(serverPath + "\\" + "routes.txt");
+        
+        try {
+            BufferedReader br = new BufferedReader(new FileReader(routesFile));
+            String line;
+            String[] paths; 
+
+            while((line = br.readLine()) != null) {
+                 paths = line.split(" ");
+                 routes.put(paths[0], paths[1]);
+            }
+
+            System.out.println(routes.toString());
+
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }     
+    }
+
+    public void stop() {
+    	isStopped = true;
+    }
+    
+    public void setupOrigin(String path) {
+        serverPath = path;
+    }
+
+    public void run() {
+        // before starting the server, we have to get all the information regarding: 
+		/* 
+		 1. Routes - routes file
+		 2. Data (files, strings, etc) includes any html, js, css files etc.... (all srcs will originate from here I believe)
+		 3. Connections (just-in-time approach) bulk messaging, communication handling, etc
+		*/
+		
+		// for this version, we'll take in a file and parse it with all the routes, etc... 
+		// In later versions, perhaps we'll provide an option in doing this programmatically... 
+        
+
+        initServerSocket();
+            
+        try {
+            acceptConectionsAndThrowToHandlers();
+        } catch (Exception e) {
+            e.printStackTrace(); // replace with logging utility
+        }	
+    } 
+}
+

.project

@@ -0,0 +1,55 @@
+package main.java.jswerve;
+
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.PrintWriter;
+import java.net.Socket;
+import java.util.HashMap;
+
+public class ConnectionHandler implements Runnable {
+
+	StringBuilder reqFullContents;
+    BufferedReader br; 
+    PrintWriter pw;
+    Socket conn;
+
+	public ConnectionHandler(Socket s) {	
+    	this.conn  = s;
+	}
+	
+	public void run() {
+				try {
+					reqFullContents = new StringBuilder();
+					BufferedReader br = new BufferedReader( 
+						new InputStreamReader(conn.getInputStream()));
+					
+						// parse request 
+						RequestParser rp = new RequestParser();
+						rp.parseReq(br);
+
+						
+
+					} catch (IOException e) {
+					
+				}
+
+	            try {
+	    			pw = new PrintWriter(
+	    					conn.getOutputStream());
+	    		} catch (IOException e) {
+	    			e.printStackTrace();
+	    		}
+				
+				try {
+					ResponseWriter rw = new ResponseWriter(conn.getOutputStream());
+					rw.setConnectionType("close");
+					rw.setContentType("text/html");
+
+					rw.send();
+				} catch (IOException e) {
+
+				}
+
+	    }
+}

.settings/org.eclipse.jdt.core.prefs

@@ -0,0 +1,52 @@
+package main.java.jswerve;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.util.HashMap;
+
+public class RequestParser {
+    private String method = "";
+    private String path = "";
+    private String httpVersion = "";
+    private HashMap<String, String> headers;
+
+    public RequestParser() {
+        headers = new HashMap<String, String>();
+    }
+
+    public void parseReq(BufferedReader br) {
+            
+        try {
+            if(br.ready()) {
+                String[] arrOfStrings = br.readLine().split(" "); // should be the METHOD PATH HTTP VERSION 
+                
+                method = arrOfStrings[0];
+                path = arrOfStrings[1];
+                httpVersion = arrOfStrings[2];
+            }
+
+            while(br.ready()) {
+                String str = br.readLine();
+                String[] header = str.split(":", 2);
+                
+                if(header.length == 2) {
+                    headers.put(header[0], header[1]);
+                }
+            }
+        } catch (IOException e) {
+
+        }
+    }
+    
+    public String getMethod() {
+        return method;
+    }
+
+    public String getPath() {
+        return path;
+    }
+
+    public String getHttpVersion() {
+        return httpVersion;
+    }
+} 

BaseHTTPServer.java

@@ -0,0 +1,11 @@
+package main.java.jswerve;
+
+interface Response {
+	
+	StringBuilder respContents = new StringBuilder();
+	boolean bodyContentInserted = false;
+	
+	public void setContentType(String contentType);
+	public void setConnectionType(String connectionType);
+	public void insertContent(String content);
+}

ConnectionHandler.java

@@ -0,0 +1,36 @@
+package main.java.jswerve;
+
+import java.io.PrintWriter;
+import java.io.OutputStream;
+
+public class ResponseWriter extends PrintWriter implements Response {
+    private StringBuilder respContents; 
+    
+    public ResponseWriter(OutputStream os) {
+        super(os);
+		respContents = new StringBuilder();
+		
+		// add in default http information
+		respContents.append("HTTP 1.1/200" + "\n");
+    }
+
+	@Override
+	public void setContentType(String contentType) {
+        respContents.append("Content-type: " + contentType + "\n");
+	}
+
+	@Override
+	public void setConnectionType(String connectionType) {
+		respContents.append("Connection-type:" + connectionType + "\n");
+	}
+
+	@Override
+	public void insertContent(String content) {
+        respContents.append("\n" + content + "\n");
+	}
+
+	public void send() {
+		print(respContents.toString());
+		close();
+	}
+}

RequestParser.java

@@ -1,4 +1,4 @@
-package jswerve;
+package main.java.jswerve;
 
 public enum STATUS {
 	OK, 

Response.java

@@ -0,0 +1,13 @@
+package main.java.jswerve; 
+
+public class TestingServer {
+
+    public static void main(String[] args)  {
+
+		int port = args.length > 0 ? Integer.parseInt(args[0]) : 8080;
+    	System.out.println("Starting server at port: " + port);
+        
+		BaseHTTPServer bhs = new BaseHTTPServer(port);
+		(new Thread(bhs)).start();
+	}
+}