@@ 0,0 1,83 @@ 
+# Chatting on discord from 9front
+
+Sometimes you work with people who doesn't want to use the same communication
+tools as you do. A sad example is when your team members wants to use discord,
+and not something simpler like IRC. Oh well, gotta deal with it.
+
+This is the reason I wrote a "discord bot" (ugh) which can run on your 9front
+system and allow you to chat on discord anyways.
+
+## Example gif
+
+The example below just opens two chat windows with different channels in each.
+While it works both in acme and in the terminal, I like having everything
+together inside acme.
+
+[![An animated gif showing discord chats from 9front][1]][1]
+
+## The code
+
+The project is made of a few scripts and a go program. The only thing that
+actually communicates with discord is the go program, and the scripts just
+makes it easier to send and recieve on the correct channels. The code is
+available [here](https://git.sr.ht/~pmikkelsen/discordfront), and there is
+a precompiled version of the go program included (compiled for 9front amd64).
+
+## Usage
+
+To use the service, you must first create a bot on discord and get the
+access token. I personally found this step much more confusing then the
+actual coding itself, which either tells you something about my google
+skills, or about discord.. Oh, and then you must invite the bot to your
+discord server..
+
+Next, the server part of the bot must be started:
+
+	`discordsrv YOURTOKEN`
+
+This will post a pipe in /srv/discordfront, where messages can be send
+and recieved from, but you should not read from it directly. The
+`discordsrv` script does this for you as well, and it takes each line
+and dumps it in a nice readable format into 
+`$home/lib/discord/logs/$serverName/$channelName`
+where the server name is the name of a discord server (or guild?), and
+the channel name is, well, the name of the channel.
+
+Now that the server is started, you can either run `discordacme` which
+opens an acme with the file `$home/lib/discord/channels` open. This file
+is not handled by any of the scripts, so it is just a handy text file to
+keep shortcuts to various channels (see the gif for an example).
+Inside `discordacme`, the `openChat` command will open a new chat window,
+using the simpler `discord` script.
+
+The `discord` script simply runs `tail -f` on the given channel's logfile
+while it reads messages from standard input and sends them to
+/srv/discordfront at the same time.
+
+## Using remotely
+
+Since this program does not fetch previous messages, it might be a good
+idea to run the server part `discordsrv` on a machine that is always online,
+so that all messages gets logged. Since this is plan9, it is almost trivial
+to still use the client on your local machine, just by using `rimport` to
+import the relevant file trees from the server.
+
+Here is what I do (in a seperate script which is run at startup):
+
+	#!/bin/rc
+
+	rfork
+	rimport -ac -p $serverhost /srv
+	rimport -c -p $serverhost /usr/glenda/lib/discord
+	discordacme
+
+I don't even notice it is not running locally.
+
+## Notes
+
+* Yes, the names of the scripts suck.
+* Yes, there is a lot of missing functionality.
+* No, this has not been tested very much, it just seems to do the job
+well enough for now.
+
+[1]: /images/discordgif.gif

          

@@ 0,0 1,58 @@ 
+# Mounting a 9P connection over drawterm
+
+I sometimes use drawterm on linux to connect to my 9front server.
+While it is possible to access the host system's files under `/mnt/term`, there is no builtin way to access the remote system's file under linux.
+Now, why would anybody want to do this?
+In my case, I often want to write some code under 9front, but for languages which aren't supported such as prolog in this case, so there are three options as I see it:
+
+* Store the files on the host machine, and access them under `/mnt/term`.
+* Store the files on the server and somehow mount the server's filesystem on the host.
+* Store the files on a third machine that both the host and server can access.
+
+Option number two seems best for me, so I asked around and it seems like the best tool to mount a 9P connection on linux is [9pfs](https://github.com/bunny351/9pfs).
+
+## How it works
+
+Before I could mount the connection, I had to serve it somehow. Normally I already serve 9P directly from my server's filesystem, but that requires some
+authentication that 9pfs does not support, so I had to serve it without authentication.
+Serving directly to the internet without authentication is of course pretty dumb since everyone can then access my files, so thanks to a hint from hiro, I figured
+out that it is actually possible to use the host's network stack on the server by binding `/mnt/term/net` over `/net`.
+
+I'll just show the final script below and explain it afterwards:
+
+	#!/bin/rc
+	
+	rfork n
+	bind /mnt/term/net /net
+	aux/listen1 -t tcp!*!12335 /bin/exportfs -r / &
+	os mkdir -p /tmp/drawterm
+	os 9pfs localhost -p 12335 /tmp/drawterm
+
+So the first thing that happens is that I bind the host's network in, and from that point on, every network connection in this namespace actually goes out
+from the host instead of from the server!
+
+Then `exportfs` is started and it is serving the `/` directory over 9P at port 12335.
+The `os` command runs a command on the host, so it just creates the folder that the system will be mounted to, and then uses `9pfs` to actually mount it.
+The nice thing here is that `9pfs` just connects to localhost.
+
+## Using it
+
+As I said in the beginning, I did this to be able to edit files on the 9front server, and run compilers/interpreters on linux.
+The `os` command goes a long way, but the following script makes it even easier (I have this installed as `linux`):
+
+	#!/bin/rc
+	
+	dir=/tmp/drawterm/`{pwd}
+	os -d $dir $*
+
+This means I can just go into any directory on the server, type `linux ghci` and I get a haskell repl running in the correct directory, as seen in the gif below.
+
+[![An animated gif showing ghci loading a file on the 9front server][1]][1]
+
+
+## Final notes
+
+The bind net trick still blows my mind a bit, since it is so trivial, yet so powerful. It is also fun to think about how one would do this
+on other systems than plan9, which I can't even imagine.
+
+[1]: /images/linuxreverse.gif