python | network代写 | 计算机网络 | project – network design

network design

python | network代写 | 计算机网络 | project – , 该题目是值得借鉴的project代写的题目,涉及了计算机网络等方面的内容,实现的编程语言是python

project代写 代写project

Your design must work with at least 4 and up to 16 servers (the file servers may run on the same computer).

Your goal in the project is to distribute and store data across multiple data servers to 1) reduce their load (i.e., distributing requests across servers holding replicas), provide increased aggregate capacity, and fault tolerance. Your redundant block storage should follow the general approach taken in RAID-1 i.e., mirroring. Use integers to identify your servers, and configure the system so that there is an even number of servers, and server N with an even identifier is mirrored in server N+1. Think about how you should distribute blocks across disks so to distribute the load.

For reads: when there are no failures, your design should allow for load- balancing, distributing requests across the (N,N+1) servers holding mirror copies. For writes: writes should attempt to update both replicas in a (N,N+1) mirror set. If acknowledgments from both replicas return, your write can complete successfully and the client returns. If only one acknowledgment is received, your system should register the server that did not respond as failed, and continue future operations (reads/writes) using only the remaining, non-faulty disk in the mirror set. Your design should be able to tolerate a fail-stop failure of either server in each mirror set, but you do not need to implement the process of repair and recovery when a server crashes.

Expectations on how your system should operate:

Client interactive window:

Print the number of servers you are running.

  • Take waiting time t as input in seconds.
  • Take the 4 digit starting port number. (the other ports will start from that number till the last one) For eg for 4 servers, if input given is 1111, the ports are 1111, 1112, 1113, 1114. Your client should update these ports. Then your program will wait until all your servers are not alive. You may write like thispress enter after starting the servers.
  • Then, your program should show the contact to all the servers by showing on terminal. For egconnection established from

connection established from…….

(server names must be in the format

  • Then, you can perform and initialize your file system so that it would be ready to take the commands.
  • Your client should take arguments form the command line. From the arguments you have to map which function you have to call, and you have pass its respective parameters. The output should be printed on the screen (if it must be).
  • It should start from $ (with space after it).
  • It should be continuously running till I enter exit in the window.
  • The functions mkdir, create, mv, read, write, status, rm. (small letter case) For Ex$ mkdir /A/B $ create /a.txt


Before a write, your system should display the server identities on which you will write the data. After a programmable delay (entered as an argument), you should proceed with the write. During write, after writing on Nth server you should mention which next server is being written and before writing to this N+1 server, you should provide a wait statement inside your code with the assigned delay which should display in the terminal as waiting to write in another replica with its identity. You should assume that at most one replica will be down during write; then your system should start writing your data onto another replica.


Before read, your system should display the two/one (if other fails) server

identities on which your data resides. After the delay of 5 seconds, you should proceed with the read. Your system should be fault tolerant in a way that, if one of the replicas fails, it should fetch the data from the other replica. You can maintain a table which will keep track of this. Once your server is down, you can assume that it will not be alive again. Your system will not be tested for failures of both replicas.

Moreover, your reads should be balanced. If reading multiple times, your read should be able to fetch the data from different servers. For example- in n reads, odd reads are fetched from Nth server and even reads from N+1.

You are free to modify any part of code with the condition that it should support the same API from the top.