$23.99
Homework #6: Let's chat Solution
n this problem we'll use the `Lwt` concurrency library; you can find
the documentation [here](https://ocsigen.org/lwt/2.5.0/api/). To
interact with `Lwt` in `utop`, you'll need to `#require
"lwt.simple-top" ;;` (or add this line to your ocamlinit file) and to
build binaries using `Lwt`, you'll need to use `ocamlfind`. See [here](lwt_intro.md)
for the short introduction to using and building programs with `lwt`.
We're going to build a _server_ that allows people to (text) chat with
each other over the internet. The protocol will be similar to
[Internet Relay Chat (IRC)](https://en.wikipedia.org/wiki/Internet_Relay_Chat)
with a little less functionality. Since this is a class homework,
we'll use the command-line program `telnet` for a _client_ instead of
developing a fancier interface. The file `chatServer.ml` contains a
skeleton for the server we'll develop, and the code to run `chatServer` in in `srvmain.ml`.
Right now, it's pretty boring: if you build and run it using:
```
% ocamlfind ocamlc -package lwt -package lwt.unix -linkpkg -o server str.cma chatServer.ml srvmain.ml
% ./server
```
it will listen for and accept network connections, but won't do anything with the user's
input, or write anything at all.
Ultimately we want to be able to support interactions like the
following:
On the server:
```
hoppernj@atlas (/home/hoppernj/csci2041/repo-hoppernj/hw6) % ocamlfind ocamlc -package lwt -package lwt.unix -linkpkg -o server str.cma chatServer.ml srvmain.ml
hoppernj@atlas (/home/hoppernj/csci2041/repo-hoppernj/hw6) % ./server
```
On Alice's machine:
```
alice@remote06 (/home/alice) % telnet atlas.cselabs.umn.edu 16384
Trying 128.101.38.193...
Connected to atlas.cselabs.umn.edu.
Escape character is '^]'.
Enter initial nick:
alice
bob: <joined
carol: <joined
hi everyone!
bob: hi alice.
/n whiterabbit
/l
whiterabbit
carol
bob
bob: ooh nice.
carol: i'm outta here.
carol: <left chat
bob: rude.
well it's only an example.
/q
Connection closed by foreign host.
```
On Bob's machine:
```
bob@remote08 (/home/bob) % telnet atlas.cselabs.umn.edu 16384
Trying 128.101.38.193...
Connected to atlas.cselabs.umn.edu.
Escape character is '^]'.
Enter initial nick:
bob
carol: <joined
alice: hi everyone!
hi alice.
alice: <changed nick to whiterabbit
ooh nice.
carol: i'm outta here.
carol: <left chat
rude.
whiterabbit: well it's only an example.
whiterabbit: <left chat
/q
Connection closed by foreign host.
```
On Carol's machine:
```
carol@atlas (/home/carol) % telnet atlas.cselabs.umn.edu 16384
Trying 128.101.38.193...
Connected to atlas.cselabs.umn.edu.
Escape character is '^]'.
Enter initial nick:
carol
alice: hi everyone!
bob: hi alice.
/l
carol
bob
alice
alice: <changed nick to whiterabbit
bob: ooh nice.
i'm outta here.
/q
Connection closed by foreign host.
```
### `login_handler`
When a user connects to the chat server, srvmain.ml calls the function
`ChatServer.chat_handler` with a pair of `channel` values: the first (`inp`) is
an `input_channel` and the second (`outp`) is an `output_channel`.
The `main_loop` helper function inside the module uses the `Lwt`
*bind* operator `=` to read a line of input from `inp` (the user's
network connection) and call `handle_input` with this line when it is
available; whenever the actions initiated by `handle_input` complete,
`=` is used to call `main_loop` again. However, before
`chat_handler` invokes `main_loop`, a few set-up operations should
take place. Find the line `let _ = ()` in `chat_handler` and replace it
with a call to `login_handler` which will do the following:
+ Print a welcome message to `outp` (using one of the `Lwt_io.print`
functions) asking the user for a "nick"(name) they will use in the chat
session. (It's a technical term, honest!)
+ Read the user's nickname from `inp` using `Lwt_io.read_line`. Assign
the new value to the name `nick`.
+ The `ChatServer` module maintains a reference to an associative list, `sessions`
mapping each user's nicknames to her output channel (so that when a
message is sent to other users, she doesn't see her input twice)
Once we know the user's nickname, update `sessions` to include the
new user and output channel pair. (Since it represents shared state, your code should take measures to ensure that `sessions` is not modified by two threads simultaneously)
+ Finally, announce that the user has joined the chat (to any other
users) by calling `broadcast` with the user's nickname and the
message `"<joined"`. (We'll fill in the `broadcast` function next.)
### `broadcast`
Whenever a user enters a message, joins the chat, or leaves the chat,
we'll want to tell the other participants in the chat using the
`broadcast` function. We could step through the `sessions` list in
order, sending the message to each user once the previous message has
been sent, but this might take a considerable amount of time -- imagine
if one or more users is overseas or using dial-up internet.
Fortunately, `Lwt` provides the useful function `Lwt_list.iter_p`,
which takes a function, applies this function to every time in the
list in parallel "threads", and then waits for all of the threads to
finish before passing `()` to the next thread. Change `broadcast` to
use `Lwt_list.iter_p` to write a line of the form `sender: message` to
every user but the sender in the `!sessions` associative list. (The
function passed to `iter_p` should execute `Lwt.return ()` when the
session associated with the `sender` nick is encountered)
At this point we're starting to get a useful server: try building and
running `server`, and in separate terminals (but the same
machine) try `telnet localhost 16384`, entering distinct nicks. You
should be able to carry out a lively conversation with yourself.
(Recruit a friend if this feels too eccentric) One more tip: you can
end a telnet session on the client side by typing ctrl-] and then
entering q at the telnet prompt.
### Modify `handle_input` and associated helpers
The actual IRC protocol allows a wide variety of actions by users;
we'll support three: q(uit), n(ew nickname), and l(ist users). Modify
`handle_input` so that it checks to see if the input starts with one
of the following commands:
+ The `quit` command, `/q`: quitting should cause the user's thread to
close the input and output channels, then remove the user from the
`sessions` list. Note that `main_loop` is bound to the
`handle_input` thread, so you'll need to use a nonlocal control flow
mechanism here. (Hint: the main body of `chat_handler` calls the
`handle_error` function with any exceptions that are thrown in the
`main_loop` thread.)
+ The `newnick` command, `/n`: allows a user to change her `nick` to
the string following ``/n ``. You should add code that calls
`change_nn` with the correct inputs and modify `change_nn` to update
the session list, notify the other users, and update the `nick`
reference from `chat_handler`.
+ The list users command, `/l`: lists all users connected to the
server. Hint: the `Lwt_list.iter_s` function provides a convenient way to
iterate over the `!sessions` list and perform some action for each
`(nickname,channel)` pair.
(You might find the library functions `Str.string_after` and
`Str.string_before` useful for this portion of the assignment.)
### Do something fun!
You're almost done with the semester, it's time to do something for fun. Using
your completed `chatServer.ml` and `srvmain.ml` as a guide, create two
additional files: `funSrv.ml` and `funSrvMain.ml`. Add an
interesting/fun/useful piece of functionality to the server in `funSrv.ml`, and
include a comment at the top explaining what libraries your code needs (so we
can build and test it out) and what it does. (A few ideas: add timestamps to
messages and color-code different users' messages; add support for private
messages from one user to another; add connection logging on the server; support
multiple chat rooms; support registered nicknames...)
## All done!
Don't forget to commit all of your changes to the various files edited
for this homework, and push them to (the `hw6` directory in) your individual class repository
on UMN github:
+ `chatServer.ml`
+ `funSrv.ml`
+ `funSrvMain.ml`
You can always check that your changes have pushed
correctly by visiting the repository page on github.umn.edu.
