|
O.P. Chunked Server-Side Hypertext Transfer Protocol
I got bored and invented a protocol. I'll post the RFC I wrote for it so it can gather some comments overnight.
_________________________________________________________________
| |
|CSSHTTP -- Chunked Server-Side Hypertext Transfer Protocol |
|_________________________________________________________________|
Chunked Server-Side Hypertext Transfer Protocol, or CSSHTTP for
short, is a method for several web servers connected in a tree
formation to easily share chunks of certain files when requested
by a user. Each server using CSSHTTP software can have both
masters and children in the tree. Ends of the tree, caused by
children without further children connected to them, operate
quite simply. They just receive chunks of files sent to them via
their master server, catalog those chunks by file name and region
of the original file, and return the lists when called on.
Servers that have further children however, will not only take on
this role but also another, which is to collect these lists from
its child servers. It will then compile these lists and sort them
by file names (ensuring to record which child server has which
part of each file on its own copy of the list) and send them to
its master, which will do the same. The master server for the
entire tree will be different than the rest of the servers
because it will not hold any pieces of any files. The master of
the tree will only harvest piece lists from its children. When
a request for a certain file is put forward to the tree's master,
it will find out which of its children have parts of the
requested file. It will then contact those children, who will
then check their lists to see if any of their children have
pieces of the file and connect to them and so on until all
of the pieces have been collected on the tree's master server
and pieced together.
CSSHTTP would use the HTTP protocol to communicate between
master and child servers. The master server would issue a GET
with the format "file name/CRC hash" and expect the server to
connect to all its child servers and return all chunks it has
pieced together as well as possible. If the master server has
another master above it, it would use the pieces received,
separate them based on its information about how many pieces
that server has, do this for each other child server (if any,)
organize all its pieces together, and return the chunk to its
master server so it can do the same. It is recommended that the
same pieces are sent to several child servers for distribution, so
if any one server stops functioning there will be several other
mirrors of the same chunk. If any one server was down, its master
must reply with the "Bytes-retrieved: " header, followed by the
order of bytes it actually has of the file (which will be passed
on from master to master until it gets to a server which can
receive another copy of the missing chunks.) The format for the
Chunks-retrieved header would be a simple number pattern using
comma for separation and hyphen for ranges. (1-8,10,12 would mean
one through eight and ten and twelve.)
distribution would be achieved using a simple HTTP POST header,
using the same format as the GET header for receiving files.
The child server would then split that chunk and distrobute it
evenly among its child servers, making sure each part gets sent to
at least two child servers (optional) to ensure good distribution
if any server stops functioning.
Spoiler: the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
the game.
| 
/ 
