Parannus

From RBOSE
Jump to: navigation, search
Parannus
Developer(s) nairboon
PMS parannus
Written in Javascript
Operating system Web-based
License GPL
SCM Git
Repository gitorious




Introduction

Parannus is an experiment to try out some ideas for achieving a distributed webframework based on the AnarchNet database and completely written in Javascript. It is intended to be used as a basic framework for a wide range of collaborative applications. It's extremely modular to minimize work duplication.

Different Setups

Parannus is supposed to be fully decentralized therefore it'll use AnarchNet as a p2p storage backend.

Install

See AnarchNet/Documentation/User

Single Local Parannus/Anarchnet installation

Parannus/AnarchNet is installed on a single machine and bound to the "localhost" interfcase. It is only accessible form this particular machine, in this relative secure context we can speedup the whole application by using far less in-browser cryptografic operations. This is the fastest and most secure setup with the following drawbacks

  • requires local installation, not extremely easy for end users
  • NAT
  • speed depends on the p2p network: resource aware algorithm & a fair amount of users

Parannus Thin Clients with local central Anarchnet backend

This could be useful for organizations, communities and home users. The Parannus Thin (in Browser) Client connects to a local (in the same LAN) installation of Anarchnet. This could also reduces the amount of needed cryptograhpy.

Parannus Thin Client with public "AnarchNet access provider"

In this setup a public server will connect to AnarchNet. Here we need a lot of cryptography which has a huge impact on the js-thin clients. We'll use this setup for testing Parannus/AnarchNet to show it's benefits. This also allows us faster deployment of the whole system. In the first phase the system could be used as a "normal" central collaborative platform until the AnarchNet backend is finished. After that other servers and even end users can join the network.


How it works

The core entities are Users and Groups, represented as complex documents. A document has the following properties:

  • type (used by apps, i.e a todo document)
  • access (public/private)
  • owner (handles modification rights)
  • revision (all documents have a history and every edit is tracked)
  • content (whatever you want)

Access

Documents owned by a single user are total under his control. The process is a bit more complicated when the document is owned by a group. Group:

  • name
  • members (like a member table)
  • votings (vote table for data modification)
  • decision making (like a access control list, specifies which properties can be changed and how)

Decision making

The decision making field could be used like that:

  • members.create: public (everybody can join the group)
  • name.edit: voting.major (group name changes need >50% acceptance in a voting)
  • all.* group (group owned documents can be edited by all members)
  • all.lock 5% (to lock a document from edits, needs 5% acceptance)
  • decision: 75% (to change the decision table you need 75% acceptance)
  • timelimit: 1w (voting run for 1 week)
  • skiplevel: 12w (after inactivity of 12 weeks the user is excluded from the voting (temporary), to avoid blocking because of inactive users i.e to reach 75%)


Sumary

Through this system we can organize data write access (everything is public by default). It's kind of a database with authentication&authorization included. In top of that we can run now various applications.

  • wikis (every group can have its own)
  • issue management system
  • document sharing
  • collaborative writing (piratepad)
  • much more...

Even though there exist many mature applications for these use cases, they all use their own data & user model. With parannus we have unified data access and data visualisation.

Principles

  • data is open
    • everything is open, therefore we enforce open decision making
  • data is versioned
    • through the versioning system we avoid data loss
    • we encourage people to collaborate, as everybody can "fork&merge"
  • no decisions behind closed doors
    • there is no such thing like secret ballot or privacy in voting, this leads into an open discussion and hopefully consensus
  • democratic system
    • there are no leaders by design
    • you are free to use the data how and with whom you want, there is now way to enforce anything, leadership won't work


Implementation

Package Repository

<graphviz> digraph pkg { size="5,6"; data -> branches -> snapshots; branches -> revisions;

versions -> data;

repository -> versions [label=" provides conflict free, autoupdated versions of the odebase"];

browser -> packageloader [label=" async module loading"]; packageloader-> packageprovider [label=" maps the repo to an url "]; packageprovider -> versions; } </graphviz>

Usage

To test it install Parannus & Anarchnet.

 ./anDaemon
node setup.js
node app.js

and browse here http://localhost:3000/app/user/index.html

Notes