How about first doing a simulation using ns3? Once you have something that works in simulation you could move ahead with a PoC.

In a previous work, I needed to process a lot of information, and when not having the necessary hardware for this, I opted to use the same computers of my department. For I programmed it two modules, a client and a server. The server installed it in my computer and the client in all the computers of the department. The idea is simple: the server emits a sign every so often for broadcasting (udp), using a thread for this function. when the client detects this message, she communicates with the server and east sends him/her the executable program together with the data to process. The fundamental detail is that the client executes the program sent by the server with minimum priority, in such way that the user doesn't perceive his execution. When finishing being executed the program, the client sends the results to the servant and east sends him/her new data.

The prosecution of the data in the client's side can consume different times, for what the server should maintain a registration of each client's work. This registration will allow to know each client's efficiency. If a client fails, because the user turned off the computer, it doesn't pass anything. The server maintains a list of the not given works, in such way that spends it to another available client. Exactly that parameters to measure depends on your objectives, but this outline is very flexible. I programmed it in C++. Not I am expert in java neither python.

Dear @Evariso, 

Thank you very much for the nice suggestion. Let me explain it in detail with the following diagram.  As you see here, I shift from a centralized to a distributed-like architecture. My objective for this design is to mitigate single-point-of-failure. if the master server crashed by any reason, still the slaves are able to handle clients' requests. once the connection established, replication is taking place between master and slave. 

For the experiment, I used RESTFUL web service (Flask) written in Python, which clients can post and get data from slaves. After, data is replicating between slave and master in each node. 

My question are:

First, this is not my field; but reading your question I think you can just simulate your scheme on a single computer using fake faults and fake "programs" for them to run. I'd suggest a step-wise simulation; like 1 millisecond at a time, or 50 milliseconds, or whatever you find appropriate. 

You would have to gather realistic statistics for "transactions" being processed, make up things for them to do (client looks up something in a database, or changes their record, or places an order, or cancels one, etc). Those are begun at random times, and each has a series of "steps" to be simulated. So you don't actually code any database lookup (or any database!), your simulation just recognizes that step, and it means

a) communication attempted from slave to master,

b) master must look up data,

c) master must send data,

d) slave must receive it,

e) slave completes client request.

Or something like that, each one of which takes a different number of time steps, and can be subjected to certain faults. For example in (b) the database may crash.

Then you have to make "faults" occur at certain times on certain servers.

To make things repeatable, I would generate, for each slave server, a queue (list) of tasks it is supposed to do, with the time they are supposed to begin (or maybe just the order they should be in, with pauses in processing coded as a task). I would construct another list of the Faults, with a trigger time or event, and which machine it should interrupt.

Then I can have different network topologies process these lists, and see which topologies are more fault resistant. The task lists and fault list can be generated by hand or by another program, perhaps following the distribution of tasks as seen in real life, if you can find such statistics.

I am not sure what is typically used to judge network fault tolerance, your research should include reading papers in that field and noting what measures they report, and what distributions of tasks they use and what types of faults they consider. You may find plausible task type distributions there as well. Reading (or skimming) such papers is a skill students need to develop; eventually you should be able to read just their abstract and skim their conclusions in under five minutes to see if you can use anything in it. Save any papers you like so you can mine them later, and get your references right. This exercise will also give you insight into the structure of the thesis you wish to write; the order in which they introduce their topic, the reason it is important, and the measures and types of conclusion you are seeking. Remember these are papers that got published, which is what you want to do, too.

The literature search is what you should do first; it may show you the way to the simulation you need to do. I am definitely not the first person to think of it, I have heard of network simulations before.

The simulation is not easy; there is a long semester of work in that. Good luck. At some early stage (after your literature search) run your plan by your Thesis advisor, obviously.

I think you are having a clear idea of what you need to do and searching for how to simulate this.

May be creating a distributed environment with facility of some sort of message transfer using any kind of topology is the first step that you may take in order to simulate your idea.

Since, I am also working on commit protocols in distributed real time database systems, based on my experiences, after doing this you will be in a situation to really decide that what is needed what step you should take to complete your task.

For environment purpose, I am attaching two papers that may be useful to you.

http://link.springer.com/article/10.1007/s10619-006-8594-8