感谢朋友支持本博客,欢迎共同探讨交流,由于能力和时间有限,错误之处在所难免,欢迎指正!
如果转载,请保留作者信息。
博客地址:http://blog.csdn.net/gaoxingnengjisuan
邮箱地址:[email protected]
PS:最近没有登录博客,很多朋友的留言没有看见,这里道歉!还有就是本人较少上QQ,可以邮件交流。
接续上一篇博客:
转到2,来看方法update_deleted的实现:
if job['delete']:
self.run_pool.spawn(self.update_deleted, job)
def update_deleted(self, job):
"""
同步本分区下数据到远程副本分区,并删除本分区下对象数据;
1 获取指定分区目录下各个对象的suff----suffixes;
2 遍历指定分区所有副本(除了本分区)节点,在每个副本节点上:
2.1 调用方法sync,实现通过rsync命令行实现同步本地分区下suffixes确定的若干对象数据到远程节点相应的分区下;
注意:这里并没由冗余复制数据的操作,因为命令rsync可以自动跳过完全相同的文件只更新不同的文件,大大的减低了网络传输负载;
2.2 通过REPLICATE方法获取远程节点相应的分区下对象相应的哈希值;
3 当本地分区到每个副本节点分区下的数据同步全部完成之后,则删除本分区下的数据;
注:
这里没有进行本地分区数据和远程副本数据的比较验证工作,说明这个方法需要直接同步分区下所有数据到远程副本节点;
应该适用于如下情形:
假设本分区所在设备节点号为1,所有副本设备节点号为1/2/3/4,当执行rebalance操作后,所有设备节点号为2/3/4/5,在rebalance操作过程中,
1号设备上本分区则被标志为delete;此时,需要先同步1号设备本分区数据到2/3/4/5号设备上,然后删除1号设备本分区下的数据;
在这里虽然也执行了复制1号设备数据到2/3/4号设备,但是这里并没由进行冗余复制操作,因为命令rsync可以自动跳过完全相同的文件只更新不同的文件,大大的减低了网络传输负载;
"""
def tpool_get_suffixes(path):
"""
获取指定分区目录下各个对象的suff;
path = job['path'] = /srv/node/local_dev['device']/objects/partition
"""
return [suff for suff in os.listdir(path)
if len(suff) == 3 and isdir(join(path, suff))]
self.replication_count += 1
self.logger.increment('partition.delete.count.%s' % (job['device'],))
begin = time.time()
try:
responses = []
# 获取指定分区目录下各个对象的suff;
# job['path'] = /srv/node/local_dev['device']/objects/partition
suffixes = tpool.execute(tpool_get_suffixes, job['path'])
if suffixes:
# job['nodes']:同一个分区相关副本除了本节点的其他的节点(所以可能有多个);
for node in job['nodes']:
# 通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
# 因为在命令行的构成过程中,本地数据的地址在前作为源数据地址,远程数据地址在后作为目标数据地址;
# 可以通过一条命令实现suffixes所指定的数据的同步,源数据地址有多个,目标数据地址有一个;
# 注:
# 这里没有进行本地和远程数据的比较和验证操作,而是直接把本地数据拷贝到远程地址;
# 这里并没由冗余复制数据的操作,因为命令rsync可以自动跳过完全相同的文件只更新不同的文件,大大的减低了网络传输负载;
success = self.sync(node, job, suffixes)
if success:
with Timeout(self.http_timeout):
# REPLICARE方法,对应sever里面的RELICATE方法;
# REPLICATE方法就是获取指定分区下的哈希值文件(可能有多个,因为分区下可能映射了多个对象),用于判断对象数据是否发生改变;
# 并获取方法执行的响应信息,即远程节点上副本的哈希值;
conn = http_connect(
node['replication_ip'],
node['replication_port'],
node['device'], job['partition'], 'REPLICATE',
'/' + '-'.join(suffixes), headers=self.headers)
conn.getresponse().read()
responses.append(success)
if self.handoff_delete:
# delete handoff if we have had handoff_delete successes
delete_handoff = len([resp for resp in responses if resp]) >= self.handoff_delete
else:
# delete handoff if all syncs were successful
delete_handoff = len(responses) == len(job['nodes']) and all(responses)
# suffixes为空或请求的三个已经都响应成功后删除本地partion下的文件;
if not suffixes or delete_handoff:
self.logger.info(_("Removing partition: %s"), job['path'])
tpool.execute(shutil.rmtree, job['path'], ignore_errors=True)
except (Exception, Timeout):
self.logger.exception(_("Error syncing handoff partition"))
finally:
self.partition_times.append(time.time() - begin)
self.logger.timing_since('partition.delete.timing', begin)
2.1.获取指定分区目录下各个对象的suff----suffixes;2.2.遍历指定分区所有副本(除了本节点)节点,在每个副本节点上:
2.2.1.调用方法sync,实现通过rsync命令行实现同步本地分区下suffixes确定的若干对象数据到远程节点相应的分区下;
注意:这里并没由冗余复制数据的操作,因为命令rsync可以自动跳过完全相同的文件只更新不同的文件,大大的减低了网络传输负载;
2.2.2.通过REPLICATE方法获取远程节点相应的分区下对象相应的哈希值;
2.3.当本地分区到每个副本节点分区下的数据同步全部完成之后,则删除本分区下的数据;
转到2.2,来看方法sync的实现:
def sync(self, node, job, suffixes): # Just exists for doc anchor point
"""
通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
因为在命令行的构成过程中,本地数据的地址在前作为源数据地址,远程数据地址在后作为目标数据地址;
可以通过一条命令实现suffixes所指定的数据的同步,源数据地址有多个,目标数据地址有一个;
"""
# def rsync;
# 通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
# 因为在命令行的构成过程中,本地数据的地址在前作为源数据地址,远程数据地址在后作为目标数据地址;
# 可以通过一条命令实现suffixes所指定的数据的同步,源数据地址有多个,目标数据地址有一个;
return self.sync_method(node, job, suffixes)
注:这里调用的方法是rsync;
def rsync(self, node, job, suffixes):
"""
通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
因为在命令行的构成过程中,本地数据的地址在前作为源数据地址,远程数据地址在后作为目标数据地址;
可以通过一条命令实现suffixes所指定的数据的同步,源数据地址有多个,目标数据地址有一个;
"""
if not os.path.exists(job['path']):
return False
# Rsync(remote synchronize)是一个远程数据同步工具,
# 可通过LAN/WAN快速同步多台主机间的文件。
# Rsync使用所谓的“Rsync算法”来使本地和远程两个主机之间的文件达到同步,
# 这个算法只传送两个文件的不同部分,而不是每次都整份传送,因此速度相当快;
args = [
'rsync',
'--recursive',
'--whole-file',
'--human-readable',
'--xattrs',
'--itemize-changes',
'--ignore-existing',
'--timeout=%s' % self.rsync_io_timeout,
'--contimeout=%s' % self.rsync_io_timeout,
'--bwlimit=%s' % self.rsync_bwlimit,
]
# 获取远程节点的IP;
node_ip = rsync_ip(node['replication_ip'])
# rsync_module = node_ip::object
if self.vm_test_mode:
rsync_module = '%s::object%s' % (node_ip, node['replication_port'])
else:
rsync_module = '%s::object' % node_ip
had_any = False
# 遍历suffixes,分别生成suffix的具体路径,并加载到命令行变量args中;
# 如果不存在suffixes,则说明前面获取损坏的对象数据的操作是错误的,则直接返回;
# 这里也可以看到,命令rsync可以实现同时同步多个数据对象;
for suffix in suffixes:
# job['path'] = /srv/node/local_dev['device']/objects/partition
# spath = /srv/node/local_dev['device']/objects/partition/suffix
spath = join(job['path'], suffix)
if os.path.exists(spath):
args.append(spath)
had_any = True
if not had_any:
return False
# 添加远程数据路径到命令行变量args中;
# rsync_module = node_ip::object;
args.append(join(rsync_module, node['device'], 'objects', job['partition']))
# 实现同步本地分区下若干数据到远程节点相应的分区下;
return self._rsync(args) == 0
2.2.1.遍历suffixes,分别生成suffix的具体路径(/srv/node/local_dev['device']/objects/partition/suffix),并加载到命令行变量args中;2.2.2.添加远程数据路径到命令行变量args中;
2.2.3.调用方法_rsync实现同步本地分区下若干数据到远程节点相应的分区下;
转到2.2.3,来看方法_rsync的实现:
def _rsync(self, args):
"""
实现同步本地分区下若干数据到远程节点相应的分区下
"""
start_time = time.time()
ret_val = None
try:
with Timeout(self.rsync_timeout):
# 此处即为同步操作了,推送模式;
proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
results = proc.stdout.read()
ret_val = proc.wait()
except Timeout:
self.logger.error(_("Killing long-running rsync: %s"), str(args))
proc.kill()
return 1 # failure response code
total_time = time.time() - start_time
for result in results.split('\n'):
if result == '':
continue
if result.startswith('cd+'):
continue
if not ret_val:
self.logger.info(result)
else:
self.logger.error(result)
if ret_val:
error_line = _('Bad rsync return code: %(ret)d <- %(args)s') % {'args': str(args), 'ret': ret_val}
if self.rsync_error_log_line_length:
error_line = error_line[:self.rsync_error_log_line_length]
self.logger.error(error_line)
elif results:
self.logger.info(_("Successful rsync of %(src)s at %(dst)s (%(time).03f)"), {'src': args[-2], 'dst': args[-1], 'time': total_time})
else:
self.logger.debug(_("Successful rsync of %(src)s at %(dst)s (%(time).03f)"), {'src': args[-2], 'dst': args[-1], 'time': total_time})
return ret_val
转到3,来看方法update的实现:
def update(self, job):
"""
实现复制一个分区的高级方法;
对于远程副本节点,循环执行,针对每一个节点实现以下操作:
1 通过http连接远程节点,通过REPLICATE方法实现获取job['partition']下所有对象的哈希值;
2 找出本地分区下哈希值中后缀和远程分区下哈希值中后缀不同的,说明分区下的某些对象文件数据发生了变化;
3 针对发生变化的数据,调用sync方法,通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
"""
self.replication_count += 1
self.logger.increment('partition.update.count.%s' % (job['device'],))
begin = time.time()
try:
# 方法get_hashes从具体的分区(具体的object)的哈希值文件hashes.pkl获取hashes值并更新,获取本地的hashes;
# job[path]为job_path = join(obj_path, partition) = /srv/node/local_dev['device']/objects/partition;
# local_hash为hashes.pkl中的反序列化回来的内容;
# hashed为改变的数目;
hashed, local_hash = tpool_reraise(
get_hashes,
job['path'], # job['path'] = /srv/node/local_dev['device']/objects/partition
do_listdir=(self.replication_count % 10) == 0,
reclaim_age=self.reclaim_age)
self.suffix_hash += hashed
self.logger.update_stats('suffix.hashes', hashed)
# 其他副本对应的节点数目;
# 此时attempts_left 为2 若果replica为3;
attempts_left = len(job['nodes'])
# 此时的nodes为除去本节点外的所有节点;
# 因为job['nodes]不包含本地节点,
# get_more_nodes(int(job['partition']))能获得除去本partion所对应节点外的其他所有节点;
nodes = itertools.chain(
job['nodes'],
# get_more_nodes:这个方法实现了获取其他副本的节点;
# 这个方法说明了三副本带来的高可用性;
# 如果replicator进程检测到对远程node执行同步操作失败;
# 那么它就会通过ring类提供的get_more_nodes接口来获得其他副本存放的node进行同步;
self.object_ring.get_more_nodes(int(job['partition'])))
# 其他副本对应的节点数目;
# 此时attempts_left 为2 若果replica为3;
# 对于远程副本节点,循环执行,针对每一个节点实现以下操作:
# 通过http连接远程节点,通过REPLICATE方法实现获取job['partition']下所有对象的哈希值;
# 找出本地分区下哈希值中后缀和远程分区下哈希值中后缀不同的,说明分区下的某些对象文件数据发生了变化;
# 针对发生变化的数据,调用sync方法,通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
while attempts_left > 0:
# If this throws StopIterator it will be caught way below
node = next(nodes)
attempts_left -= 1
try:
with Timeout(self.http_timeout):
# REPLICARE方法,对应sever里面的RELICATE方法;
# REPLICATE方法就是获取指定分区下的哈希值文件(可能有多个,因为分区下可能映射了多个对象),用于判断对象数据是否发生改变;
#并获取方法执行的响应信息,即远程节点上副本的哈希值;
resp = http_connect(
node['replication_ip'], node['replication_port'],
node['device'], job['partition'], 'REPLICATE',
'', headers=self.headers).getresponse()
if resp.status == HTTP_INSUFFICIENT_STORAGE:
self.logger.error(_('%(ip)s/%(device)s responded as unmounted'), node)
attempts_left += 1
continue
if resp.status != HTTP_OK:
self.logger.error(_("Invalid response %(resp)s from %(ip)s"), {'resp': resp.status, 'ip': node['replication_ip']})
continue
# 获取远程节点上分区的哈希值;
remote_hash = pickle.loads(resp.read())
del resp
# 找出本地分区下哈希值中后缀和远程分区下哈希值中后缀不同的;
# 如果分区下某些对象数据发生改变,其对应的哈希值文件也会发生改变;
# 如果有不同,说明分区下的某些对象文件数据发生了变化;
# 示例:
# 假如 local_hash 为 123 321 122 remote_hash 123 321 124 则 122为变化的
# 文件路径hash值后三位会不会重复
suffixes = [suffix for suffix in local_hash if
local_hash[suffix] !=
remote_hash.get(suffix, -1)]
# 如果没有不同,说明对象数据都没有变化,则继续请求下一个节点;
if not suffixes:
continue
# 针对那些和远程节点分区上不同的哈希值,这里进行重新计算;
# 然后再一次和远程节点分区上的哈希值进行比较;
# 这样做的目的是确保筛选的完全准确性;
hashed, recalc_hash = tpool_reraise(
get_hashes,
job['path'], recalculate=suffixes,
reclaim_age=self.reclaim_age)
self.logger.update_stats('suffix.hashes', hashed)
local_hash = recalc_hash
suffixes = [suffix for suffix in local_hash if
local_hash[suffix] !=
remote_hash.get(suffix, -1)]
# sync方法:
# 通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
# 因为在命令行的构成过程中,本地数据的地址在前作为源数据地址,远程数据地址在后作为目标数据地址;
# 可以通过一条命令实现suffixes所指定的数据的同步,源数据地址有多个,目标数据地址有一个;
self.sync(node, job, suffixes)
with Timeout(self.http_timeout):
conn = http_connect(node['replication_ip'], node['replication_port'], node['device'], job['partition'], 'REPLICATE',
'/' + '-'.join(suffixes), headers=self.headers)
conn.getresponse().read()
self.suffix_sync += len(suffixes)
self.logger.update_stats('suffix.syncs', len(suffixes))
except (Exception, Timeout):
self.logger.exception(_("Error syncing with node: %s") % node)
self.suffix_count += len(local_hash)
except (Exception, Timeout):
self.logger.exception(_("Error syncing partition"))
finally:
self.partition_times.append(time.time() - begin)
self.logger.timing_since('partition.update.timing', begin)
3.1.通过http连接远程节点,通过REPLICATE方法实现获取job['partition']下所有对象的哈希值;3.2.找出本地分区下哈希值中后缀和远程分区下哈希值中后缀不同的,说明分区下的某些对象文件数据发生了变化;
3.3.针对发生变化的数据,调用sync方法,通过rsync命令行实现同步本地分区下若干数据到远程节点相应的分区下;
注:方法sync的解析,前面已经完成,这里不再进行赘述;