Frangipani a scalable distributed file system

C is a conditional operator, which sends its output to E if the input value is greater than 10, and sends it to F otherwise. D is an aggregation operator that sums all values irrespective of key. Write down the timestamp changes that the records experience as they flow through the graph, e. You may omit vertices that do not modify the timestamp.

Informally explain when E. OnNotify 1, [] will be called. You do not need to step through the details of the pointstamp protocol. What do you expect the bottleneck — that is, the most loaded — resource e. Frangipani: A Scalable Distributed File System : Suppose a server modifies an i-node, appends the modification to its log, then another server modifies the same i-node, and then the first server crashes. The recovery system will see the i-node modification in the crashed server's log, but should not apply that log entry to the i-node, because that would un-do the second server's change.

How does Frangipani avoid or cope with this situation? Memcache at Facebook. Section 3. Explain why it would be a bad idea for writing clients to delete keys from Gutter servers. The last sentence in Section 4. The text observes "This put depends on all previous key-version pairs and thus is nearer than them.

You might think that the client's subsequent puts would need to carry along the dependency information about previous gets.

What entity ultimately uses the context information, and why does it not need the information about gets before the last put?

Explain why it's important that all viewers of a Certificate Transparency log see the same content. What attacks would be possible if a malicious log server was able to cause some readers of its log to see one sequence of records, and other readers to see a different set of records?

What mechanisms ensure that all viewers see the same log content? Why is it important that Blockstack names be unique, human-readable, and decentralized?

Why is providing all three properties hard? Managing Update Conflicts in Bayou Suppose we build a distributed filesystem using Bayou, and the system has a copy operation. Initially, file A contains "foo" and file B contains "bar". On one node, a user copies file A to file B, overwriting the old contents of B. On another node, a user copies file B to file A.

Please read the paper's Appendices. In Spinnaker a leader to responds to a client request after the leader and one follower have written a log record for the request on persistent storage. Why is this sufficient to guarantee strong consistency even after the leader or the one follower fail? One use of Zookeeper is a fault-tolerant lock service see the section "Simple locks" on page 6. Why isn't possible that two clients can acquire the same lock?

In particular, how does Zookeeper decide if a client has failed and it can give the lock to some other client? Russ Cox is one of the leads on the Go project. What do you like best about Go? Would you want to change anything in the language? If so, what and why? Read just these parts of Chapter 9: 9. The last two sections on two-phase locking and distributed two-phase commit are the most important. No compromises: distributed transactions with consistency, availability, and performance : Suppose there are two FaRM transactions that both increment the same object.

They start at the same time and see the same initial value for the object. One transaction completely finishes committing see Section 4 and Figure 4. Then the second transaction starts to commit.

There are no failures. What is the evidence that FaRM will use to realize that it must abort the second transaction? It would be highly available in spite of component failures. It would require minimal human administration, and administration would not become more complex as more components were added.

Frangipani is a new file system that approximates this ideal, yet was relatively easy to build because of its two-layer structure. These locks are provided by the lock service. Frangipani requires only a small, generic set of functions from its lock service. Locks are sticky; that is, a client will generally retain a lock until some other client needs a conflicting one. The lock service deals with client failure using leases. When a client first contacts the lock service, it obtains a lease.

All locks the client acquires are associated with the lease. Each lease has an expiration time, and the client must renew its lease before the expiration time, or the service will consider it to have failed. The lock service itself is total distributed for fault tolerance and scalable performance.

The lock service organizes locks into tables , and each file system has a table associated with it. When the file system is unmounted, the clerk closes the lock table. The distributed lock service uses heartbeat message to detect failures, and could tolerate minority failure. Locks are distributed on different lock servers, and sometimes they could be reassigned for load-balancing or other reasons.

When a Frangipani server crashes, the locks that it owns cannot be released until appropriate recovery actions have been performed. When the lease expires, the lock services would require another Frangipani to perform recovery and release all related locks. It is pretty easy to add and remove servers from the cluster.

The newly added server need only be told which Petal virtual disk to use and where to find the lock service, and the server to be removed could be shut down directly to be removed from the cluser.

It is also convenient to make a snapshot. Petal allows snapshot at any point to generate a same virtual disk, which is read-only. It uses copy-on-write techniques for efficiency, and a snapshot always reflects a coherent state.

In this way, we could backup the Frangipani system by by taking a Petal snapshot, because all Frangipani logs are stored on Frangipani disks. To restore the system, we can just copy it back to a new Petal virtual disk and run recovery on each log. But there is still a requirement for Frangipani to create consistent snapshots, that is all requests from Frangipani should be terminated for a while until the snapshot process finishes.

A barrier mechanism is introduced here, and only after all servers enter the barrier, would the snapshot begin. There is a global lock to identify snapshot, and each update request would acquire this lock in shared mode, while the snapshot request backup process acquire it in exclusive mode. When the server is required to release the lock, it knows a snapshot is going to start, and it enters the barrier by blocking all new file system calls that modify data, cleaning all dirty data in its cache and then releasing the lock.

After all servers enter the barrier, the snapshot begins, and then the lock would be released by the process.