Basic server skeleton

Author: mveytsman

README.md

@@ -7,21 +7,30 @@ This is a skeleton project for a chat server we'll use to build a chat client an
 
 To start we'll work in groups on implementing a very basic server that listens on a socket and routes messages, and a client that can talk to it.
 
-Start by implementing the protocol below. Don't worry about concurrency yet! The library included in this skeleton project `clj-sockets` is synchronous, so no need to read up on Clojure concurrency primitives or core.async channels. Start with a synchronous server, and we'll make it async next week.
+Start by implementing the protocol below. We are using a single `ref` to handle shared state. In the future, we will port this code over to use `core.async`
 
 ### The Protocol
 - It's a line based protocol. Newline signifies end of message
-- channel and nicknames can contain only `[a-z|A-Z|0-9|-+]`,
-- channel names must begin with #,
+- nicknames can contain only `[a-z|A-Z|0-9|-+]`,
 - usernames can begin with any character other then #
 - After connecting, each user sends `USER nickname` as their first command
-- At first there's only one channel, `#general`, we'll add more later!
-- Messaging a user is done with `MSG nickanme message`
-- Messaging a channel is done with `MSG #channel message`
+- Messaging is done with `MSG message`
+
 
 ### Goals for Week 1
-- Get a feel for working with a project larger then one function
-- Write a couple of tests (either with [clojure.test](https://clojure.github.io/clojure/clojure.test-api.html) or [midje](https://github.com/marick/Midje)).
-- Try to practice REPL-driven development
-- Think about how to organize code into namespaces
-- Have fun!!!
+The skeleton code implements a simple chat server. This week you should:
+- Understand the server code (we'll go over it together)
+- Talk to the server using [netcat](http://en.wikipedia.org/wiki/Netcat)
+- Start by writing a separate program to function as a client. It should allow the user to specify a server/port and nickname as command line args (Run `lein new app chat-client` to create a new app skeleton)
+- Implement private messaging in the server
+- Bonus points if the client can connect to multiple servers at once
+
+
+## Goals for the future
+- Add support for channels, which start with #
+- Automatically place users in #general and allow users to join and leave channels with `JOIN #channel` and `LEAVE #channel`
+- Update messaging syntax to be `MSG #channel message`
+- Devise a mechanism for the client to be on multiple channels at once
+- Add support for changing nicknames
+- Migrate to core.aync
+- Replace sockets with websockets and write a web UI in cljs

src/chat_server/.#.gitignore

@@ -1,8 +1,45 @@
 (ns chat-server.core
-  (:require [clj-sockets.core :as socket :refer []])
+  (:require [clj-sockets.core :as socket])
   (:gen-class))
 
+(def clients (ref {}))
+
+
+(defn serve-client
+  [nick client]
+  (doseq [line (socket/read-lines client)]
+    (let [other-clients (vals (dissoc @clients nick))]
+      (case (first (clojure.string/split line #" "))
+        ;; Instructor Note: explain why a doall is needed here
+        "MSG" (doall (map #(socket/write-line % (str nick ": " (subs line 4))) other-clients))
+
+        ;;TODO: Process other kinds of command here 
+        
+        ;; else
+        (socket/write-line client "ERROR: I don't understand")))))
+
+(defn new-client
+  [client]
+  (let [command (socket/read-line client)]
+    (if-let [[_ nick] (re-matches #"USER (.*)" command)]
+      ;; Instructor note: explain why we have to use a transaction here to make sure checking if user exists and adding them happens atomically
+      (if (dosync
+           (when-not (get @clients nick)
+             (alter clients assoc nick client)))
+        
+        (serve-client nick client)
+        
+        (do
+          (socket/write-line client "ERROR: Nick already taken")
+          (socket/close-socket client))))))
+
 (defn -main
-  "I don't do a whole lot ... yet."
+  "The hello world of chat servers"
   [& args]
-  (println "Hello, World!"))
+  (let [port 1234
+        server-socket (socket/create-server port)]
+    (println "Listening on port" port)
+    (loop [client (socket/listen server-socket)]
+      ;; TODO: improve debugging inside this future
+      (future (new-client client))
+      (recur (socket/listen server-socket)))))