Anybody done this

[Joe Armstrong]

  I want to build the PANOMNICOM (this is cross posted to the
Erlang and Planet lab lists to encourage a cross-fertilization of ideas)

  The PANOMNICOM is the universal computer which is everywhere.

  Imagine all  computers in the  Universe have two big  buttons called
ATTACH and DETACH, they all run the PANOMNICOM

 This is what I want to do

    - Hack away
    - On computer (ONE) I run Erlang.
    - I bang the DETACH BUTTON 
    - Evaluate erlang:suspend(File)
      Erlang stops. The state is stored in a file.
      The file is processed  into N chunks (Using some erasure code
      for example, reed-solomon tornado or raptor codes)
      the chunks are encrypted
      the encrypted chunks are stored in a distributed hash table in a P2P network
      (say using DKS Chord, Pastry etc - they're all the same :-)
    - I go to any other computer (TWO) *anywhere* in the world
    - I press the ATTACH button
    - K chunks of my data are recovered from the distributed hash table
      the chunks are decrypted
      the original file is reconstructed (note a K:N erasure has the property
      that if some data is processed to form N different chunks, then the original data
      can be reconstructed from any K different chunks, where K < N )
      Get the original state file back
      do erlang:resume(File)
    - Carry on hacking
    - My data in the PANOMNICOM is stored reliably *forever* - or until the sun goes
      bananas - whichever is first.


  Here are some sub-problems that I want code (preferably Erlang) for
- has  anybody  done/thought/coded anything  remotely  related to  the
following:

  1) Implement a virtual block device

  I  want a  process  that implements  the  protocol that  all the  io
library functions use.

  The only interface to the block-device should be

	read_block(Device, N), 
	write_block(Device, N, <<Bin>>)
        query_device(Device) -> {#blocks, #blocksize}

  Also I'd like to make ext2 file systems *inside* files and binaries -
and send complete ext2 filesystems in binaries as messages.

2) Stopping and starting Erlang.

  I'd  like to  say  erlang:suspend(File) which  would suspend  Erlang
dumping the state into a  file and later say erlang:resume(File) which
would re-start  the suspended Erlang  from *exactly* the state  it was
in.

3)  Efficient implementation of erasure codes (Done I think)

4) Distributed hash tables (sort of done - BUT big problems
	   
with malicious users etc)

  Now I  guess nobody has  built this yet  (unless you just  happen to
have  hacked this together  and have  it sitting  around on  your hard
disk)

  But any progress towards this would be helpfully.

Cheers

/Joe