se.rupy.http

Interface Summary
Interface	Description
Daemon.ComListener	Receives COM port data.
Daemon.DNSListener	So that you can hot-deploy your DNS solution.
Daemon.ErrListener	Error listener, so you can for example send a warning mail and swallow certain exceptions to not be logged.
Daemon.JVMListener	Cross class-loader communication interface.
Daemon.SPIListener	Receives SPI interrupt.
Daemon.UDPListener	Cross cluster-node communication interface.
Event.Block	Non blocking IO requires some blocking logic to handle ethernet latency.

Class Summary
Class	Description
Async	High speed HTTP async NIO client. This exists because Apache HAC: - Can't handle Murphy's law. - Rarely blocks forever stuck in sun.misc.Unsafe.park(). - Is pretty slow and big (adds ~20-30 ms.
Async.Work	This is your Async callback.
Daemon	A tiny HTTP daemon.
Daemon.ComPort	COM port.
Daemon.SPIData	SPI data.
Deploy	Hot-deploys an application containing one or many service filters from disk with simplistic dynamic class loading, eventually after receiving it through a HTTP POST.
Deploy.Archive	This is our dynamic classloader.
Event	Asynchronous HTTP request/response, this virtually represents a client socket, but in the case where the server is behind a proxy we cannot depend on that fact since sockets will be reused by multiple different external clients. The hierarchy of the code is as follows: `Event -+-- Query <-- Input <--- +-----------+ \| \| \| X \| Browser \| \| \| \| +-> Reply --> Output --> +-----------+` Where X marks the potential Comet pause point.
Hash	Convenience class to avoid casting and parsing everywhere.
Input	Handles the incoming request data.
Output	Handles the outgoing response data.
Query	HTTP request and query in one.
Reply	HTTP response.
Root	Secure Unique Identity Cluster.
Root.Find
Root.Hash
Root.Link
Root.Meta
Root.Node
Root.Salt
Root.Tree
Service	The service filter is like a servlet which describes its own identifier.
Session	If you save a class that is hot-deployed here it will throw a ClassCastException if you re-deploy the application.
User
Worker	Worker gets the job done.

Exception Summary
Exception	Description
Async.Timeout	Thrown when `SocketChannel.read(ByteBuffer)` returns -1.
Failure	The failure, if thrown, does not display the error to the user but disconnects the client.
Root.KeyFail
Root.LinkFail
Root.MetaFail
Root.SortFail

Package se.rupy.http Description

Instructions: start Daemon, implement Service then Deploy.

Rupy is lightweight and fast.
It also consumes very few joules per request.

The hierarchy of the code is as follows: Event -+-- Query <-- Input <--- +-----------+ | | | X | Browser | | | | +-> Reply --> Output --> +-----------+ Where X marks the potential Comet pause point.

Failure, Hash, Session and Worker should be pretty self explanatory.

For more details on how to configure rupy, see the properties for Daemon.

----

Root is a distributed JSON database, unfortunately; if you can't figure it out from playing around with these forms then you are out of luck for now!

The only thing I can say simply is each node has a key (private) that allows you to write the node and an id (public) that allows you to read it.

User is a privileged node, because you don't want that to be readable without some kind of authentication; we use double round-trip server salt password hashing over plain HTTP, simple yet secure after registration as long as the connection between the backend and database is trusted because we send the permanent key back over that connection unencrypted.

Other than that, link is one-to-many and meta is many-to-many-to-tree (basically replacing cross reference tables and enabling tree structures in one go).

One use for meta is the inventory system in fuse: see drop, pick, save, load.