Clean up

.gitignore

@@ -41,6 +41,10 @@ _testmain.go
 *.test
 *.prof
 *.wasm
+*.aar
+*.jar
+*.framework
+*.xcframework
 
 # Generated keys
 *.pem
@@ -65,4 +69,7 @@ test/wasm/node_modules
 # Ignore complement folder when running locally
 complement/
 
+# Stuff from GitHub Pages
+docs/_site
+
 media_store/

docs/p2p.md

@@ -1,89 +0,0 @@
----
-title: P2P Matrix
-nav_exclude: true
----
-
-# P2P Matrix
-
-These are the instructions for setting up P2P Dendrite, current as of May 2020. There's both Go stuff and JS stuff to do to set this up.
-
-## Dendrite
-
-### Build
-
-- The `main` branch has a WASM-only binary for dendrite: `./cmd/dendritejs`.
-- Build it and copy assets to riot-web.
-
-```
-./build-dendritejs.sh
-cp bin/main.wasm ../riot-web/src/vector/dendrite.wasm
-```
-
-### Test
-
-To check that the Dendrite side is working well as Wasm, you can run the
-Wasm-specific tests:
-
-```
-./test-dendritejs.sh
-```
-
-## Rendezvous
-
-This is how peers discover each other and communicate.
-
-By default, Dendrite uses the Matrix-hosted websocket star relay server at TODO `/dns4/ws-star.discovery.libp2p.io/tcp/443/wss/p2p-websocket-star`.
-This is currently hard-coded in `./cmd/dendritejs/main.go` - you can also use a local one if you run your own relay:
-
-```
-npm install --global libp2p-websocket-star-rendezvous
-rendezvous --port=9090 --host=127.0.0.1
-```
-
-Then use `/ip4/127.0.0.1/tcp/9090/ws/p2p-websocket-star/`.
-
-## Riot-web
-
-You need to check out this repo:
-
-```
-git clone git@github.com:matrix-org/go-http-js-libp2p.git
-```
-
-Make sure to `yarn install` in the repo. Then:
-
-- `$ cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" ./src/vector/`
-- Comment out the lines in `wasm_exec.js` which contains:
-
-```
-if (!global.fs && global.require) {
-    global.fs = require("fs");
-}
-```
-
-- Add the diff at <https://github.com/vector-im/riot-web/compare/matthew/p2p?expand=1> - ignore the `package.json` stuff.
-- Add the following symlinks: they HAVE to be symlinks as the diff in `webpack.config.js` references specific paths.
-
-```
-cd node_modules
-ln -s ../../go-http-js-libp2p
-```
-
-NB: If you don't run the server with `yarn start` you need to make sure your server is sending the header `Service-Worker-Allowed: /`.
-
-TODO: Make a Docker image with all of this in it and a volume mount for `dendrite.wasm`.
-
-## Running
-
-You need a Chrome and a Firefox running to test locally as service workers don't work in incognito tabs.
-
-- For Chrome, use `chrome://serviceworker-internals/` to unregister/see logs.
-- For Firefox, use `about:debugging#/runtime/this-firefox` to unregister. Use the console window to see logs.
-
-Assuming you've `yarn start`ed Riot-Web, go to `http://localhost:8080` and register with `http://localhost:8080` as your HS URL.
-
-You can:
-
-- join rooms by room alias e.g `/join #foo:bar`.
-- invite specific users to a room.
-- explore the published room list. All members of the room can re-publish aliases (unlike Synapse).

docs/peeking.md

@@ -1,33 +0,0 @@
----
-nav_exclude: true
----
-
-## Peeking
-
-Local peeking is implemented as per [MSC2753](https://github.com/matrix-org/matrix-doc/pull/2753).
-
-Implementationwise, this means:
-
-* Users call `/peek` and `/unpeek` on the clientapi from a given device.
-* The clientapi delegates these via HTTP to the roomserver, which coordinates peeking in general for a given room
-* The roomserver writes an NewPeek event into the kafka log headed to the syncserver
-* The syncserver tracks the existence of the local peek in the syncapi_peeks table in its DB, and then starts waking up the peeking devices for the room in question, putting it in the `peek` section of the /sync response.
-
-Peeking over federation is implemented as per [MSC2444](https://github.com/matrix-org/matrix-doc/pull/2444).
-
-For requests to peek our rooms ("inbound peeks"):
-
-* Remote servers call `/peek` on federationapi
-  * The federationapi queries the federationsender to check if this is renewing an inbound peek or not.
-  * If not, it hits the PerformInboundPeek on the roomserver to ask it for the current state of the room.
-  * The roomserver atomically (in theory) adds a NewInboundPeek to its kafka stream to tell the federationserver to start peeking.
-  * The federationsender receives the event, tracks the inbound peek in the federationsender_inbound_peeks table, and starts sending events to the peeking server.
-  * The federationsender evicts stale inbound peeks which haven't been renewed.
-
-For peeking into other server's rooms ("outbound peeks"):
-
-* The `roomserver` will kick the `federationsender` much as it does for a federated `/join` in order to trigger a federated outbound `/peek`
-* The `federationsender` tracks the existence of the outbound peek in in its federationsender_outbound_peeks table.
-* The `federationsender` regularly renews the remote peek as long as there are still peeking devices syncing for it.
-* TBD: how do we tell if there are no devices currently syncing for a given peeked room?  The syncserver needs to tell the roomserver
-    somehow who then needs to warn the federationsender.