Sacha

I think most usages will use 2-3 nodes of jboss simply replicated with the
same beans everywhere.  No complex stuff, no sub-partition etc etc, only
when we grow in "super clusters" of 10 machines do we start gaining stuff
from more advanced design.

There is a very simple design, the one here we can do in no time.

This also has no database impact (we don't work with the database). And I
seriously think we can go far with such a simple design, there is nothing
Julian needs to know on the entity side except the "findSession
(findByPrimaryKey)" and that's it. Clustered nodes.

|Marc,
|
|Yes, I can try this (and anyway, I will have to: you propose this since
|September... I can't make this last longer... ;) )

Yes I propose this over and over, but it is so simple a design, that we are
doing nothing that we don't do already.
We need a Hashmap for a cmp engine (how trivial is that), and DONE.

when we move to SFSB state replication we can start worrying about
sub-partitions and then you will have to worry about load balancers being
smart and all, when we can say "look configure your cluster to have 5 nodes
fully replicated, in fact do the admin from the central web server" and you
are done... this is simple and we probably won't run into the upper limit of
this system, where the sub-partitions start making a difference, I really
think so and it is so thin that it would be silly not to see it work or
crash.

|While very elegant, the problem I have with this solution concerns
|scalability.

very high-end scalability.

|With the current SFSB code, if you have 10 nodes, state is not owned by the
|all 10 nodes. Instead, we create sub-partitions. For example, we would have
|5 sub-partitions, each containing 2 nodes, and each node would contain its
|own state + the backup of the other node in its same sub-partition. Thus,
|while the number of node grows, the load is totally linear and we
|do not end
|up with each node having to store in-VM the state of 10 nodes!

But you only have the beans on "pinned" nodes, if I understand your
description correctly, I could be wrong.  Here we need the beans on all
nodes in the jetty cluster hence the simple solution, just replicate
configuration across your node and have mirror images running.

It is fancy but only in particular cases do I see this being useful, I could
be wrong.

I don't need 5x2 I need 10.

| This imply
|that when you work with a particular SFSB, its stub *knows* which are the
|members of the sub-partition and will not ask for its state to node 7, if
|only node 1 and 2 own its state.

Here the persistence engine would need to be rewritten to ejbLoad locally,
and then you follow the bean, if you don't want to replicate too many then
the architecture would be

the pyramid is
main servers for HTTPSESSION :3 servers running mirror images
edge servers for JETTY: 10 servers pinging the mirrors.
web millions and millions and billions

you have  3=10 scaling which in my experience of SAP takes care of even
alien load.
This is a standard SAPr/3 configuration... don't come with "scalability
issues".

Here we have serialization between the jetty/jboss session as they are on
different nodes.  It can still be a very fancy install, no need to
sub-partition or anything it is an admin issue and the code is simple, not
trivial but simple (SFSB like in VM on the t

Another solution (still simple to code would be)
main server = jetty server
we have 5 servers. the jetty stuff has the colocated bean, your fancy
colocation proxy logic *you already have* determines to call thelocal bean,
it is super fast as there is no network and the pyramid I described above is
really a circle of mirror instances with FULL STACK.

Both would work really nicely and I don't know that we need anything more
complex than this simple EJB structure.

You have done the work on EJB clustering, time to see it pay off. This is
it.

|In the case you describe, the findByPrimaryKey call can be run on any node.
|Thus, the location (read "location" not "colocation") problem i've
|described
|in my previous post: how to make the findByPrimaryKey call nice enough to
|address the call a good node of the cluster for a particular sessionId.

we are talking about the clustered colocated case
The findByPrimaryKey is running on the home of the colocated bean, if the
cache has that bean then you return immediately, if he doesnt then ejbLoad
knows to pull the initial state for that session and register the listeners
for that session.  If the session needs "exclusive access" then we just
provide the locking mechanisms and that is configurable.

|As for caching, optimisations, ... it would be possible only when working
|with a well-parameterized hard load-balancers that would always
|direct calls
|to the same node: the own that owns a copy of the sate.

What I am thinking of is that load balancers are effective when stateless,
if we use mirror clusters, completely symetric, you don't know or need
topology information on the cluster.

You just spray the cluster and the ejbLoad knows to load teh stuff from the
SFSB like caching.


|Otherwise, we need to implement a distributed-cache engine. Currently, this
|distributed-cache (hit-miss) engine is only available *inside* a
|sub-partition.

Yes,

|
|You follow me?

I think so and it would be pretty, correct me if I am wrong but the initial
design is so simple that we could be done with it in a week.

Only exclusive access to the HttpSession would require more work but even
then it could be simple.

marcf


_______________________________________________
Jboss-development mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/jboss-development

Reply via email to