[Red5devs] Integrating terracotta with red5 call...

[Orion Letizi]

We (Steven Gong, Steve Harris, Tim Eck, Taylor Gautier, and Orion 
Letizi) had a good discussion this morning (California time) about how 
to approach clustering Red5 with Terracotta.

The upshot is it seems like the best thing to start with is to cluster 
the relevant tree of Scope objects in the origin servers and to fire a 
Terracotta "distributed method call" whenever a shared object in a Scope 
object is updated.  That way, all the shared objects in the Scope tree 
will be available (via Terracotta) to all origin servers on demand and 
all origin servers will be notified when the state of a relevant scope 
object changes.

In order to do that, we'll need to figure out:

* what to use as a Terracotta clustered root object.  A likely candidate 
is the children of the org.red5.server.GlobalScope object.  There's a 
small wrinkle in the way roots work in Terracotta that would require the 
children of the GlobalScope object to be kept in a separate field.  
Right now, GlobalScope extends org.red5.server.Scope and inherits the 
Scope.children map.  We discussed adding a separate field to GlobalScope 
that we can use as the Terracotta root instead of the inherited 
Scope.children field.

* what to make transient in the scope tree.  There is some JVM-specific 
stuff in the scope tree (e.g., connections, streams, listeners, etc.) 
that should not be clustered by Terracotta.  These things need to be 
declared transient so that they don't become clustered.

* iron out the details of the Spring GlobalScope initialization.  This 
seemed like a fairly minor issue, but there may be some stuff we have to 
figure out there.

All in all, this seems very doable, although it will take some tinkering 
and maybe some minor refactoring in the Red5 server code to get it all 
to work properly.

Thanks very much to Steven Gong for taking the time to meet with us.  
This is really exciting stuff.

Cheers,
Orion