«

2 or more hosts, each running the same application.
Each Java application on each host is assigned a specific task.
Say:

App on host1 does task X
App on host2 does task Y
App on host3 does task Z

Only one app can do any specific task.

Now, if app on host1 shutsdown for whatever reason, either app on host2 or host3 should take over task X.
I was thinking of implementing this with UDP ... but someone may have already done this ... without using a database.

Is there a design pattern for the above ... basically a failover pattern ?

noone wrote:

>
> 2 or more hosts, each running the same application.
> Each Java application on each host is assigned a specific task.
> Say:
>
> App on host1 does task X
> App on host2 does task Y
> App on host3 does task Z
>
> Only one app can do any specific task.
>
> Now, if app on host1 shutsdown for whatever reason, either app on host2
> or host3 should take over task X.
> I was thinking of implementing this with UDP ... but someone may have
> already done this ... without using a database.
>
> Is there a design pattern for the above ... basically a failover pattern ?
>

The pattern described here provides some choices:

http://www.embedded.com/story/OEG20020729S0030

# Standby backup. While the primary module runs in the system, a backup module is waiting in "standby," watching the primary module for faults and ready to fire up and take over. For example, high-availability web servers can be designed using this
approach.

# Rotating standby. While the primary module runs in the system, there may be a number of backup modules. One backup will take over running the system in case of a fault in the primary. The flight computers on the space shuttle have been designed
with this philosophy: the primary module consists of a pair of computers that must always agree with one another. The first backup module is a similar pair. But the second backup module on the space shuttle is a single computer that can take over
only via human command.

# Failover to non-critical module. The primary module runs the critical resources of the system. A backup module can run other non-critical things, but it can take over the most critical services of the primary in case of fault. This is what we do,
as humans, when a PC's high-speed Internet connection fails as we're trying to send an urgent e-mail, and we quickly switch over to that old modem we never thought we'd need again.

# Mutual takeover. Each module runs its own critical resources, but can take over the critical resources of another module in case of fault. For example, in a cardiac intensive care ward, there should be a heart monitoring computer for every eight
patients. But each one can handle an additional eight patients (perhaps with some graceful degradation) if a neighboring heart monitoring computer goes down.


Simplest maybe for me is either the standby or rotatin standby approach