cgrotz / helium.io Goto Github PK

When issue #25 is implemented create a demo that shows how we can work with this.

At the moment every 100 messages a snaphshot is generated, this size should be configurable

https://github.com/Atmosphere/atmosphere/wiki/Creating-private-channel-of-communication-between-Browsers

Implement a local data model, with synchronisation from the server side.

This would allow the offline usage of roadrunner.

• RPC mechanism ( Predecessor: #30 )
• Local data model
• Add local rule validation
• Data synchronisation from remote master to local client

Adding a vert.x verticle variant would be great, because then sock.js could be easily used for communicating with the server, which would improve browser support enormously.

In the implementation for #3 the query API was added in a way that checked the changes reported by the changelog on wether or not the data fits the query and than distributes the event to the frontend.

This behaviour needs to be changed in a way that changes to the data are distributed in this way.

Data Node didn't match query -(change)-> Data Node matches query --> Distribute Query Child Added Event
Data Node matched query -(change)-> Data Node still matches query --> Distribute Query Child Changed Event
Data Node matched query -(change)-> Data Node don't matches query anymore --> Distribute Query Child Removed Event

At the moment incoming messages are processed and messages are distributed depending on the message content.

This behaviour should be changed to distributing the changes that really happend on the persistence.

At the moment there is no concept for authentication a user against Roadrunner.
The recommendation for running Roadrunner in a productive environment is running it with TLS/SSL.
As API, it would really like to see something similar to firebase.js oder hoodie (http://hood.ie/#docs)

// sign in
var ref = new Roadrunner('http://localhost:8080/');
ref.login('name', 'secret');
// or with a generated secret
ref.login('secret');

// sign out
ref.logout();

// the data for the authenticated user
ref.auth.username;

• Unit tests for all components should be created.
• Phantom.js testing of the javascript client

• Implement Write, Delete via Disruptor
• Implemente Read via Distripution and Rest

As a developer i would like to handle the disconnecting of a client.

I would like to be able to attach commands to a reference that should be executed, when the client disconnects from roadrunner.

   myDataRef.onDisconnect().remove();
   myDataRef.onDisconnect().set({connected: false});
   myDataRef.onDisconnect().update({connected: false});
   myDataRef.onDisconnect().push({msg: 'Client disconnected'});

Due to vert.x support i don't see a reason to keep the netty support.

Netty project needs to be removed as well as netty references in the documentation

https://confluence.opensource.anotheria.net/display/MSK

At the moment the communication is done asynchronously via sending messages.

This should be replaced with an RPC mechanism. This is a precondition for allowing the possibility to hold a local state of the data and synchronize it.

The data inside the Roadrunner Data Persistence should be able to be accessed via a Rest API

http://developer.chrome.com/extensions/devtools.html

I believe there are some duplicate classes ans methods. This should be cleaned up.

Archtitecture should be documented using Arc42

The coyote module should be branched until the development of coyote is farther along.

It would be nice changing form websockets towards sockjs, but it should be evaluated if it's possible for tomcat to support sockjs.

https://github.com/sockjs
https://github.com/rstoyanchev/spring-sockjs-protocol-webapp

This issue is a prerequisite to #17

Change the URL Scheme for the following:

• Roadrunner Reference: http://<server_name>/users/batman/name
• HTML View (Generic): http://<server_name>/users/batman/name
• JSON View: http://<server_name>/users/batman/name.json
• XML View: http://<server_name>/users/batman/name.xml