1.  Atomic group: can be solved by using the following 
protocol: 
The first phase: the server multicasts the message to all members of the 
group. Then the server waits for the replies from all these members. 
(The clients send an acknowledgement message (reply) to the server after
they receive the message.)
The second phase: 
If the server receives replies from all members, it sends a 
``commitment''  message to all members. Otherwise, the server sends 
an ``abort'' message to all the members. 

A client will read the message if it receives the ``commitment'' message from
the server. It will  delete the message if it receives the ``abort'' 
message. If no message is received from the server 
  within a specified time,  the client finds an error. (How to handle the 
error?)

This protocol assumes that the ``commitment''/``abort'' message 
can be received by all members. This asumption is reasonable 
since the ``commitment''/``abort'' message is short, and the time gap 
between the first phase and second phase is small.

2. Client failure: A client is assumed to be ``dead'' if 

it does not  reply within a fixed time. 
You have to  design a way to detect if a client is ``dead''. 
If a client is detected to be ``dead'', the system has to 
kick it out so that the whole group can work properly.


3. Server failure:  The simpliest method is to use 
a ``backup server''. (See DIstributed System text book) 
You have to make sure that the information on the backup server is updated.
You can also consider three or  more servers (not necessary).
What happens if there are many many servers?