Holumbus-Distribution: intra- and inter-program communication

[ distributed-computing, library, network, program ] [ Propose Tags ]
Versions [RSS] 0.0.1,, 0.1.0, 0.1.1
Dependencies array (>=, base (>=4 && <5), binary (>=0.4), bytestring (>=0.9), containers (>=0.1), deepseq (>=1.1 && <2), haskell98 (>=1), hslogger (>=1.0), hxt (>=8.2), network (>=2.1), random (>=1.0), readline (>=1 && <2), stm (>=, time (>=1.1), unix (>=2.3) [details]
License LicenseRef-OtherLicense
Copyright Copyright (c) 2010 Stefan Schmidt, Uwe Schmidt, Sebastian Reese
Author Stefan Schmidt, Uwe Schmidt
Maintainer Stefan Schmidt <sts@holumbus.org>
Category Distributed Computing, Network
Home page http://holumbus.fh-wedel.de
Uploaded by StefanSchmidt at 2010-08-31T21:48:36Z
Reverse Dependencies 3 direct, 0 indirect [details]
Executables PortRegistryDaemon, PortRegistry
Downloads 3804 total (8 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for Holumbus-Distribution-0.1.1

[back to package description]
This is the Holumbus-Distribution Library

Version 0.1.0

Stefan Schmidt sts@holumbus.org



Holumbus is a set of Haskell libraries. This package contains the 
Holumbus-Distribution library for building and running a distributed systems.
One of the core elements of this library is an Erlang-style communication 
system for interchanging data between different threads or applications. 

This library was completely rewritten between version 0.0.1 and 0.1.0. The old
packages can be found under Holumbus.Network.* while the new ones are
located at Holumbus.Distribution.*. The old packages will be removed in
future versions.

This library itself is independent from other Holumbus libraries although it
contains some modules which are only to be used by the other Holumbus
libraries but this may change in the near future.


Haskell offers great libraries and datatypes for the implementation
of intra-process communication, e.g. MVars, Chans, STM. But compared
to other functional languages like Erlang or Mozart/Oz (ok, the later
is a multi paradigm language) offer better support for building distributed
systems. Holumbus-Distribution wants to close this gap by offering multiple
distributed data structures.

The following datastructures are implemented so far:

* distributed Chan (DChan)
  like the Chan datatype, but it allows the writing
  and reading (!) from other programs

* distributed MVar (DMVar)
  like the MVar datatype, but the content of the
  MVar can be shared among multiple programs.

* distributed Functions (DFunction)
  an easy way to do remote procedure calls, just like

* distributed Values (DValue)
  a variable which could only be written once and
  which could easily read by other programs

* distributed Streams and Ports (DStream, DPort) 
  just like the DChan, but this time, you are only
  allowed to read from the channel from one program

To be able to use these data structures, your program needs to become a
distributed node (DNode, comparable to an Erlang-Node). After initializing
the node, you can create instances of the data structures described above.
You only need to register these resources at your node and then other nodes
are able to access them. 


Examples  Some example applications
Programs  The applications you need to run a distributed system.
          (these are not needed any more an belongs to the old
           Holumbus.Network.* packages, they will be deleted in 0.2.0)
source    Source code of the Holumbus-Distribution library.


So far, this library is only tested under Linux, please tell me, if you have 
problems under Windows or other OS.
The Holumbus-Distribution library requires at least GHC 6.10 and the 
following packages (available via Hackage).



A Cabal file is provided, therefore Holumbus-Distribution can be installed using
the standard Cabal way:

$ runhaskell Setup.hs configure
$ runhaskell Setup.hs build
$ runhaskell Setup.hs install --global # with root privileges

This will generate the library and the PortRegestry programs.

For those who prefer to build it the old way with make:

$ make build
$ make install # with root privileges

Steps to make a distributed system running

How to use Streams and Ports:

On the receive side:
    -- Step 1:
    -- make a Haskell DNode, named "myReceiver" on the Port 7999
    -- this only needs to be called once during the runtime of the program
    _ <- initDNode $ (defaultDNodeConfig "myReceiver")
      { dnc_MinPort = (fromInteger 7999), dnc_MaxPort = (fromInteger 7999) }
    -- Step 2:
    -- make a new DStream, named "myStream"
    -- this stream can be used until you close it with "closeDStream"
    stream <- newDStream "myStream"

    -- Step 3:
    -- wait for the next message, read it print it out to stdout
    msg <- (receive stream)::(IO String)
    putStrLn msg

    -- Step 4:
    -- we are behaving nicely and clean everything up before we leave
    closeDStream stream

On the sender side:

    -- Step 1:
    -- make a Haskell DNode, we don't care about its name, so we leave it
    -- blank. The system will generate a unique random name on its own.
    -- this only needs to be called once during the runtime of the program
    _ <- initDNode $ defaultDNodeConfig ""

    -- Step 2:
    -- we need to know how to address the receiver node, so we have to provide
    -- its address, this only needs to be done once, or when the address of
    -- the receiver changes (which will not happen in most applications)
    addForeignDNode $ mkDNodeAddress "myReceiver" "localhost" (fromInteger 7999)

    -- Step 3:
    -- we make a new port, connected to "myStream" at the node "myReceiver"
    port <- newDPort "myStream" "myReceiver"

    -- Step 4:
    -- send the messages
    send port "Hello World"

    -- Step 5:
    -- we are behaving nicely and clean everything up before we leave