Skip to main content

A journey of Scaling generation of file system snapshots

We are a cloud file system startup managing billions of files for thousands of customers and one of the constant scaling issue is "how do you generate a snapshot of cloud filesystem" and send it to the client to start an initial sync. To elaborate more let say a customer has so far uploaded 25M files. Now he starts a new office and wants to setup a Netgear/NAS appliance and install our server sync software. Before the Netgear/NAS appliance could start syncing it needs a consistent snapshot of cloud filesystem so it could start that as a starting point before it could start syncing  changes based on events.  Now 25M is a big number right now but 5 year back the same problem was with if a customer has 500K files and a new employee joins and installs a sync software on his laptop, how do you send the sync client a consistent server snapshot.

It seems every 1-2 year or so we solve this problem and as scale increases we have to come up with something new to make it more faster than before.

Snapshot solution Version 1

When we initially started we were using filers and using NFS and when a customer would add a folder on local or from web ui, we on our server would replicate the operation via NFS.   When  a new user sync install would request a snapshot we would crawl the file system and send him a snapshot.  This worked for sometime but crawling the file system is slow and NFS would freeze the OS.

Snapshot solution Version 2

To solve the crawling issue we started a python process on the filer that would start with an initial image via crawling and it would hold it in memory. It would then listen to INotify events when we would do operation via NFS and it would update the  in memory snapshot.  When a new user sync install would request the snapshot we would serve it from the cached in memory install.  This worked great for sometime but it ran into issues whenever we would bring restart a filer or the python process would restart or the snasphot was so big that it would cause OOM.

Snapshot solution Version 3

We ditched NFS and we started storing filesystem metadata in a NOSQL database called as BerkelyDB. Its a key value database and we would store the file on filer but BerkelyDB would store the metadata about file XYZ belongs to folder ABC and is located on ZZZ filer at this location. When a new user sync install would request the snapshot we would just dump all BerkelyDB data(paths were stored as key and folder metadata as values) and generate  a snapshot.  This worked for a long time until we started reaching customers with 3M+ files and this would buckle under pressure if multiple clients would request snapshots at same time. BerkelyDB would run into memory issues or cache thrashing.

Snapshot solution Version4

Besides cache/memory issues  BerkelyDB's biggest issue was data loss and replication. So we ditched BerkelyDB and started using Mysql. We created Folder,File,Version table and 1000s of shards to store metadata. We are right now running 100+ mysql servers to store this data. One customer's data was stored in one shard so whenever a user sync install would request the snapshot we would join the three tables and spit out the snapshot.  This was one big breakthrough from other areas of application also.  But one big problem with this approach was that we allow customers to upload any number of versions and the snapshot only cares about latest version of the file. So in order to derive latest version of the file we had to discard old versions using a correlated subquery.  So this works fine for 5M files but it really buckled up under 8M+ files as we had to fire a correlated subquery for each file.

Snapshot solution Version5
We found out that if we joined Folder,File,version table and then use unix sort to sort the file and then use python to filter out latest version it was much faster than correlated queries. But this also buckled under pressure when we hit a customer with 25M files. The join in mysql db takes 2 hours to spit the data and the unix sort takes 2-3 hours.  Also the snapshot is large so we started caching this on disk and we used nginx as a reverse proxy to start serving cached snapshot. But again lately some big customers started facing issues with snapshot timeouts.

Snapshot solution Version6
This weekend we are again improvising on this solution as we found out that if we could denormalize the latest version when the file is being added,copied, moved,deleted,restored on the File table record, then to generate a snapshot we just need to join folder,file table and serve it.  From our tests we found out that generating a snapshot on 25M file customer takes only 6 minutes compared to 5 hour process with join query and unix sort approach.  Off course this has twice the space complexity but the time complexity is way better.

Offcourse this requires a lot of grunt work to modify the old code and we would need to migrate billions of files so all this would rollout slowly over the course of this month but I am hoping this solution would again buy us some time.

The core problem is snapshot and we need to find out a better way to bootstrap a client instead of sending him the entire snapshot so may be this saga has more evolution than what we had seen in the past :).


Popular posts from this blog

RabbitMQ java clients for beginners

Here is a sample of a consumer and producer example for RabbitMQ. The steps are
Download ErlangDownload Rabbit MQ ServerDownload Rabbit MQ Java client jarsCompile and run the below two class and you are done.
This sample create a Durable Exchange, Queue and a Message. You will have to start the consumer first before you start the for the first time.

For more information on AMQP, Exchanges, Queues, read this excellent tutorial
import com.rabbitmq.client.Connection; import com.rabbitmq.client.Channel; import com.rabbitmq.client.*; public class RabbitMQProducer { public static void main(String []args) throws Exception { ConnectionFactory factory = new ConnectionFactory(); factory.setUsername("guest"); factory.setPassword("guest"); factory.setVirtualHost("/"); factory.setHost(""); factory.setPort(5672); Conne…

Spring query timeout or transaction timeout

If you are using spring to manage transactions then you can specify default transaction timeout using

    <bean id="transactionManager"
        <property name="dataSource" ref="dataSource" />
        <property name="defaultTimeout" value="30" /> <!--30 sec--->             

or you can override the timeout in the annotation

    @Transactional(readOnly = false, timeout=30)

or if you are doing it programatic transactions then you can do

DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(dataSource);

 or you can override the timeout for one particular transaction

TransactionTemplate transactionTemplate = new TransactionTemplate();

Python adding pid file

I have a thumbnail generator that launches multiple processes and the correct way to shut it down is to send kill -HUP to the parent process. To automate I had to write a pid file from python, it was a piece of cake
def writePidFile(): pid = str(os.getpid()) f = open('', 'w') f.write(pid) f.close()