[转]大量小文件的实时同步方案

本文转自http://blog.daviesliu.net/2008/04/24/sync/

传统的文件同步方案有rsync(单向) 和 unison(双向)等，它们需要扫描所有文件后进行比对，差量传输。如果文件数量达到了百万甚至千万量级，扫描所有文件将非常耗时。而且正在发生变化的往往是其中很少的一部分，这是非常低效的方式。

之前看了Amazon的Dynamo的设计文档，它们每个节点的数据是通过Hash Tree来实现同步，既有通过日志来同步的软实时特点(msyql, bdb等)，也可以保证最终数据的一致性(rsync, unison等)。Hash Tree的大体思路是将所有数据存储成树状结构，每个节点的Hash是其所有子节点的Hash的Hash，叶子节点的Hash是其内容的Hash。这样一旦某个节点发生变化，其Hash的变化会迅速传播到根节点。需要同步的系统只需要不断查询跟节点的hash，一旦有变化，顺着树状结构就能够在logN级别的时间找到发生变化的内容，马上同步。

文件系统天然的是树状结构，尽管不是平衡的数。如果文件的修改时间是可靠的，可以表征文件的变化，那就可以用它作为文件的Hash值。另一方面，文件的修改通常是按顺序执行的，后修改的文件比早修改的文件具有更大的修改时间，这样就可以把一个目录内的最大修改时间作为它的修改时间，以实现Hash Tree。这样，一旦某个文件被修改，修改时间的信息就会迅速传播到根目录。

一般的文件系统都不是这样做的，目录的修改时间表示的是目录结构最后发生变化的时间，不包括子目录，否则会不堪重负。因为我们需要自己实现这个功能，利用Linux 2.6内核的新特性inotify获得某个目录内文件发生变化的信息，并把其修改时间传播到它的上级目录(以及再上级目录)。Python 有 pyinotify，watch.py的代码如下：

view plaincopy to clipboardprint?

1. #!/usr/bin/python   
2.   
3. from pyinotify import *   
4. import os, os.path   
5.   
6. flags = IN_CLOSE_WRITE|IN_CREATE|IN_Q_OVERFLOW   
7. dirs = {}   
8. base = '/log/lighttpd/cache/p_w_picpaths/icon/u241'   
9. base = 'tmp'   
10.   
11. class UpdateParentDir(ProcessEvent):   
12.     def process_IN_CLOSE_WRITE(self, event):   
13.         print 'modify', event.pathname   
14.         mtime = os.path.getmtime(event.pathname)   
15.         p = event.path   
16.         while p.startswith(base):   
17.             m = os.path.getmtime(p)   
18.             if m < mtime:   
19.                 print 'update', p   
20.                 os.utime(p, (mtime,mtime))   
21.             elif m > mtime:   
22.                 mtime = m   
23.             p = os.path.dirname(p)   
24.        
25.     process_IN_MODIFY = process_IN_CLOSE_WRITE   
26.   
27.     def process_IN_Q_OVERFLOW(self, event):   
28.         print 'over flow'   
29.         max_queued_events.value *= 2   
30.   
31.     def process_default(self, event):   
32.         pass  
33.   
34. wm = WatchManager()   
35. notifier = Notifier(wm, UpdateParentDir())   
36. dirs.update(wm.add_watch(base, flags, rec=True, auto_add=True))   
37.   
38. notifier.loop()   

#!/usr/bin/python from pyinotify import * import os, os.path flags = IN_CLOSE_WRITE|IN_CREATE|IN_Q_OVERFLOW dirs = {} base = '/log/lighttpd/cache/p_w_picpaths/icon/u241' base = 'tmp' class UpdateParentDir(ProcessEvent): def process_IN_CLOSE_WRITE(self, event): print 'modify', event.pathname mtime = os.path.getmtime(event.pathname) p = event.path while p.startswith(base): m = os.path.getmtime(p) if m < mtime: print 'update', p os.utime(p, (mtime,mtime)) elif m > mtime: mtime = m p = os.path.dirname(p) process_IN_MODIFY = process_IN_CLOSE_WRITE def process_IN_Q_OVERFLOW(self, event): print 'over flow' max_queued_events.value *= 2 def process_default(self, event): pass wm = WatchManager() notifier = Notifier(wm, UpdateParentDir()) dirs.update(wm.add_watch(base, flags, rec=True, auto_add=True)) notifier.loop()

在已经有Hash Tree的时候，同步就比较简单了，不停地获取根目录的修改时间并顺着目录结构往下找即可。需要注意的是，在更新完文件后，需要设置修改时间为原文件的修改时间，目录也是，保证Hash Tree的一致性，否则没法同步。mirror.py的代码如下

view plaincopy to clipboardprint?

1. #!/usr/bin/python   
2.   
3. import sys,time,re,urllib  
4. import os,os.path   
5. from os.path import exists, isdir, getmtime   
6.   
7. src = sys.argv[1]   
8. dst = sys.argv[2]   
9.   
10. def local_mirror(src, dst):   
11.     if exists(dst) and mtime == getmtime(dst):   
12.         return  
13.     if not isdir(src):   
14.         print 'update:', dst   
15.         open(dst,'wb').write(open(src).read())   
16.     else:   
17.         if not exists(dst):   
18.             os.makedirs(dst)   
19.         for filename in os.listdir(src):   
20.             local_mirror(os.path.join(src,filename), os.path.join(dst,filename))   
21.     os.utime(dst, (mtime,mtime))   
22.   
23. def get_info(path):   
24.     f = urllib.urlopen(path)   
25.     mtime = f.headers.get('Last-Modified')   
26.     if mtime:   
27.         mtime = time.mktime(time.strptime(mtime, '%a, %d %b %Y %H:%M:%S %Z'))   
28.     content = f.read()   
29.     f.close()   
30.     return int(mtime), content   
31.   
32. p = re.compile(r'([\d.]+?) +([\w/]+)')   
33.   
34. def remote_mirror(src, dst):   
35.     mtime, content = get_info(src)   
36.     if exists(dst) and mtime == int(getmtime(dst)):   
37.         return  
38.     print 'update:', dst, src   
39.     if not src.endswith('/'):   
40.         open(dst,'wb').write(content)   
41.     else:   
42.         if not exists(dst):   
43.             os.makedirs(dst)   
44.         for mt,filename in p.findall(content):   
45.             mt = int(float(mt))   
46.             lpath = dst+filename   
47.             if not exists(lpath) or int(getmtime(lpath)) != mt:   
48.                 remote_mirror(src+filename, lpath)   
49.     os.utime(dst, (mtime,mtime))   
50.   
51. if src.startswith('http://'):   
52.     mirror = remote_mirror   
53. else:   
54.     mirror = local_mirror   
55.   
56. while True:   
57.     mirror(src, dst)   
58.     time.sleep(1)   

#!/usr/bin/python import sys,time,re,urllib import os,os.path from os.path import exists, isdir, getmtime src = sys.argv[1] dst = sys.argv[2] def local_mirror(src, dst): if exists(dst) and mtime == getmtime(dst): return if not isdir(src): print 'update:', dst open(dst,'wb').write(open(src).read()) else: if not exists(dst): os.makedirs(dst) for filename in os.listdir(src): local_mirror(os.path.join(src,filename), os.path.join(dst,filename)) os.utime(dst, (mtime,mtime)) def get_info(path): f = urllib.urlopen(path) mtime = f.headers.get('Last-Modified') if mtime: mtime = time.mktime(time.strptime(mtime, '%a, %d %b %Y %H:%M:%S %Z')) content = f.read() f.close() return int(mtime), content p = re.compile(r'([\d.]+?) +([\w/]+)') def remote_mirror(src, dst): mtime, content = get_info(src) if exists(dst) and mtime == int(getmtime(dst)): return print 'update:', dst, src if not src.endswith('/'): open(dst,'wb').write(content) else: if not exists(dst): os.makedirs(dst) for mt,filename in p.findall(content): mt = int(float(mt)) lpath = dst+filename if not exists(lpath) or int(getmtime(lpath)) != mt: remote_mirror(src+filename, lpath) os.utime(dst, (mtime,mtime)) if src.startswith('http://'): mirror = remote_mirror else: mirror = local_mirror while True: mirror(src, dst) time.sleep(1)

如果源文件不在同一台机器上，可以通过NFS等共享过来。或者可以通过支持列目录的HTTP服务器来访问远程目录，mirror.py 已经支持这种访问方式。server.py 是用webpy做的一个简单的只是列目录的文件服务器。由于瓶颈在IO上，它的性能不是关键。server.py的代码如下：

view plaincopy to clipboardprint?

1. #!/usr/bin/python   
2.   
3. import os,os.path   
4. import web   
5. import time  
6.   
7. root = 'tmp'   
8.   
9. HTTP_HEADER_TIME = '%a, %d %b %Y %H:%M:%S %Z'   
10.   
11. class FileServer:   
12.     def GET(self, path):   
13.         path = root + path   
14.         if not os.path.exists(path):   
15.             return 404   
16.         mtime = time.localtime(os.path.getmtime(path))   
17.         web.header('Last-Modified', time.strftime(HTTP_HEADER_TIME, mtime))   
18.         if os.path.isdir(path):   
19.             for file in os.listdir(path):   
20.                 if file.startswith('.'): continue  
21.                 p = os.path.join(path,file)   
22.                 m = os.path.getmtime(p)   
23.                 if os.path.isdir(p):   
24.                     file += '/'   
25.                 print m, file  
26.         else:   
27.             print open(path,'rb').read()   
28.   
29. urls = (   
30.    "(/.*)", "FileServer",   
31. )   
32.   
33. if __name__ == '__main__':   
34.     web.run(urls, globals())   

#!/usr/bin/python import os,os.path import web import time root = 'tmp' HTTP_HEADER_TIME = '%a, %d %b %Y %H:%M:%S %Z' class FileServer: def GET(self, path): path = root + path if not os.path.exists(path): return 404 mtime = time.localtime(os.path.getmtime(path)) web.header('Last-Modified', time.strftime(HTTP_HEADER_TIME, mtime)) if os.path.isdir(path): for file in os.listdir(path): if file.startswith('.'): continue p = os.path.join(path,file) m = os.path.getmtime(p) if os.path.isdir(p): file += '/' print m, file else: print open(path,'rb').read() urls = ( "(/.*)", "FileServer", ) if __name__ == '__main__': web.run(urls, globals())

为了获得更好性能，以达到更好的实时性，Hash Tree最好是平衡的，比如BTree。如果一个文件发生变化，同步它需要进行的IO操作为N*M，其中N为数的层数，M为每层的文件数目。现在我们N为2，M最大为10000，适当减少它可以获得更好的性能，比如N为4，M为100。在以后创建目录结构时，最好能够考虑这方面的因素。

之前hongqn推荐过一个利用inotify的文件同步方案，同步方式类似于mysql和bdb等，由于过于复杂导致不可靠而没有采用。上面这个方案只用了一百多行Python代码就基本解决问题了，是不是很帅？:-)

• 赞
• 收藏
• 评论
• 分享
• 举报

上一篇：vsftp mysql安装配置

下一篇：rabbitmq消息件在idc机房监控中的应用

提问和评论都可以，用心的回复会被更多人看到 评论

发布评论

全部评论 () 最热 最新

相关文章

• 不同设备之间文件实时同步

  需求：1，linjux和windows之间双向实时同步文件；2，超长路径和超长文件名的支持；（大于256）现有设备：NAS 172.16.5.111#NAS套件中心安装container manager#拉取镜像、新版docker pull swr.cn-north-4.myhuaweicloud.com/ddn-k8s/docker.io/syncthing/syncthing:1.28.

  docker 重新启动 本地文件
• CentOS7下使用Lsyncd实现文件实时同步

  Lsyncd简单介绍Lsyncd 使用文件系统事件接口（inotify 或 fsevents）来监视本地文件和目录的更改。Lsyncd 在几秒钟内将这些文件事件整理核对后，然后生成一个或多个进程以将更改同步到远程文件系统。默认使用的同步方法是rsync。因此，Lsyncd 是一种轻量级的实时镜像解决方案。Lsyncd 相对容易安装，不需要新的文件系统或块设备。Lysncd 不会影响本地文件系统的

  服务器 文件系统 配置文件
• 使用 ​​rsync + inotify​​ 实现实时文件同步：简单又高效

  使用 rsync + inotify 实现实时文件同步：简单又高效在日常的运维工作中，文件的实时同步是一个非常常见的需求，比如：网站更新：同步静态资源到多台服务器。备份数据：将生产数据实时备份到异地存储。日志传输：将日志实时同步到集中分析服务器。为了高效实现这些需求，我们可以将强大的文件同步工具 rsync 和实时文件监控工具 inotify 结合起来，轻松实现实时文件同步。接下来，我会用通俗的语

  文件同步 实时同步 服务器
• 大量小文件的实时同步方案（python…

  <!DOCTYPE html PUBLIC "-//W3C//DT

  修改时间 python 根目录
• csync2+inotify实现大量小文件实时同步方案

  作者:NetSeek                              来源: http://www.linuxtone.org【关键技术】利用csync2+sqlite实现数据的高效实时的增量备份，

  linux 职场 休闲 csync2
• sersync2 大量小文件实时同步

  sersync2可以实现一台机器上的某个目录实时同步到多台机器，非常适合大量小文件如web网页。 1. 配置同步目标服务器# vi /etc/rsyncd.confuid = root gid = root max connections = 36000 use chroot = no log file = /var/log/rsyncd.log pid file

  linux 职场 休闲 rhel6 sersync
• 删除大量小文件

    FreeBSD删除文件缓存,在负载方面FreeBSD比CentOS好很多很多。#!/bin/shif [ ! -s /tmp/dir.dat ];then find /home/www/web/cache -type d > /tmp/dir.datfimkdir /var/tmpdirDIRS=`cat /tmp/dir.dat`for i in $DIR

  删除大量小文件
• csync+lsync 实时双向批量同步小文件

  cysnc+lsync配置安装环境 ubuntu 12.041） 两台机器安装配置：    apt-get install xinetd csync2 lsyncd    cat /etc/xinetd.d/csync2       &nb

  csync lsyncd xinetd批量小文件同步
• java压缩大量小文件

  # 如何实现Java压缩大量小文件## 概述作为一名经验丰富的开发者，我将指导你如何在Java中实现对大量小文件进行压缩。这个过程分为几个步骤，我将为你详细解释每一步需要做什么，并提供相应的代码示例。## 流程图```mermaidflowchart TD Start --> 指定待压缩的文件夹 指定待压缩的文件夹 --> 遍历文件夹下的所有文件 遍历文件夹下

  压缩文件 java Java
• spark读大量小文件

  # Spark读取大量小文件在大数据处理中，常常会遇到需要处理大量小文件的情况。传统的文件系统在处理大量小文件时效率较低，因为每个文件都需要进行磁盘的读取和寻址操作。而Spark提供的分布式计算框架可以高效地处理大量小文件。## Spark简介Spark是一个开源的大数据处理框架，提供了灵活和高效的分布式计算功能。Spark的主要特点是内存计算和容错机制，可以加速大数据处理的速度。

  解决方案 apache hadoop
• Hbase存储大量小文件

  # Hbase存储大量小文件Hbase是一个分布式的、面向列的NoSQL数据库，它是基于Google的Bigtable模型实现的。Hbase在处理大量小文件时表现出色，这使得它成为处理大规模数据集的理想选择。本文将通过代码示例和图表，详细介绍Hbase如何存储大量小文件。## Hbase存储架构Hbase的存储架构基于HDFS（Hadoop Distributed File Syste

  数据 apache hadoop
• 海量小文件同步

  集中式存储是目前中小企业广泛采用的方案，随着时间的流逝，这些存储不可避免的膨胀。集中式存储的弊端愈加显现，同步就是其中一个。环境:文件容量以TB计，里面是千万/亿级的小文件，分布在成千上万的子文件夹内。分析：rsync几乎是唯一选择，海量小文件同步面临的问题主要是rsync无止境的扫描，同步进度难以把控，巨大的临时目录等。所以解决办法只能是庖丁解牛，将一个大任务分解成N个小任务。场景假设如下：1、

  同步 rsync 海量小文件
• rsync巧妙的删除大量小文件

  rsync采用替换原理，快速删除大量文件。1、使用rsync清空目录  <1>、先建个空目录     mkdir blank  <2>、删除目标目录     rsync --delete-before -d -a -H -v --progress --stats ./blank ./destin

  rsync 大量 小文件
• Linux删除大量小文件的两种方案场景介绍

  关于Linux上删除小文件写过这篇《Linux下如何快速删除大量碎小的文件？》，碰巧看到社群的技术文章《Linux 删除大量小文件的

  linux 运维 服务器 sed oracle
• 大量小文件 mongodb 大量小文件压缩很慢

  1，在需要对大量小文件进行移动或复制时，用cp、mv都会显得很没有效率，可以用tar先压缩再解压缩的方式。2，在网络环境中传输时，可以再结合nc命令，通过管道和tcp端口进行传输。nc和tar可以用来快速的在两台机器之间传输文件和目录，比ftp和scp要来得简单的多。由于nc是一个超轻量的命令，所以一般busybox都会集成它。当一个linux终端，比如linux pda,通过usblan的方式连

  大量小文件 mongodb linux 循环语句 PHP
• hdfs存储大量小文件 hdfs适合存储大量的小文件

  HDFSHDFS产生的背景数据量越来越大，一个操作系统中存不下所有的数据，那就需要分配到多个操作系统的磁盘上，但是由不好进行管理，因此就需要一个系统来管理多个机器上的文件，这就是分布式文件管理系统，HDFS是一种分布式管理系统。HDFS定义HDFS就是Hadoop Distribute File System，他适合一次写入，多次读出的场景，且不支持文件的修改，适合用来做数据分析和大数据，可以构建

  hdfs存储大量小文件 大数据 hadoop hdfs HDFS
• hadoop大量小文件 hadoop小文件过多

  1.存储大量小文件存在的问题大量小文件的存在势必占用大量的 NameNode 内存 HDFS 中的每一个文件、目录以及文件块，在 NameNode 内存都会有记录，每一条记录大约占用150字节的内存空间(该大小与文件、目录及文件块的大小无关)，namenode的内存就会成为HDFS 的横向扩展能力的一个限制因素。如果我们使用 MapReduce 任务来处理这些小文件，因为每个 Map 会处理一个

  hadoop大量小文件 hdfs hadoop big data hive
• 海量小文件存储 java 大量小文件 存储

  在单个目录存放超过上百万的文件时,对大部分的OS都是一个挑战，目录的浏览就是一个非常难以忍受的事情。所以针对海量小文件的应用场景，能够使用nosql数据库时,尽量使用如redis之类的nosql数据库.在非使用文件系统来存储管理海量小文件的情况下,尽量使用以下原则来进行管理尽可能使用目录分批存储,避免单目录文件数量过万文件系统最好使用XFS，XFS的inode数量是ext4的10倍以上如果不小心遇

  海量小文件存储 java tomcat nosql数据库 文件系统
• hadoop 统计小文件 hadoop处理大量小文件

  1. HDFS上的小文件问题 小文件是指文件大小明显小于HDFS上块（block）大小（默认64MB）的文件。如果存储小文件，必定会有大量这样的小文件，否则你也不会使用Hadoop（If you’re storing small files, then you probably have lots of them (otherwise you wouldn’t turn to Hadoop)），这

  hadoop 统计小文件 jira java 大数据 HDFS
• HIVE处理大量小文件

  一、hive小文件 Hive的数据存储在HDFS，它对大文件的处理是非常高效的，如果合理配置文件系统的块大小，NameNode可以支持很大的数据量。HDFS主要分为NameNode，DataNode，ZKFC。 简单来说，HDFS数据的文件元信息，包括位置、大小、分块信息等，都是保存在NameNod ...

  hive hdfs hadoop 数据 建表