分布式定时任务框架——python定时任务框架APScheduler扩展

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/chosen0ne/article/details/7925979

        如果将定时任务部署在一台服务器上,那么这个定时任务就是整个系统的单点,这台服务器出现故障的话会影响服务。对于可以冗余的任务(重复运行不影响服务),可以部署在多台服务器上,让他们同时执行,这样就可以很简单的避免单点。但是如果任务不允许冗余,最多只能有一台服务器执行任务,那么前面的方法显然行不通。本篇文章就向大家介绍如何避免这种互斥任务的单点问题,最后再介绍一下基于APScheduler的分布式定时任务框架,这个框架是通过多个项目的实践总结而成的。

        对于运行在同一台服务器上的两个进程,可以通过加锁实现互斥执行,而对于运行在多个服务器上的任务仍然可以通过用加锁实现互斥,不过这个锁是分布式锁。这个分布式锁并没有那么神秘,实际上只要一个提供原子性的数据库即可。比如,在数据库的locks表里有一个记录(lock record),包含属性:

        name:锁的名字,互斥的任务需要用名字相同的锁。

        active_ip:持有锁的服务器的ip。

        update_time:上次持有锁的时间,其他非活跃的服务器通过这个属性判断活跃的服务器是否超时,如果超时,则会争夺锁。

        一个持有锁的服务器通过不断的发送心跳,来更新这个记录,心跳的内容就是持有锁的时间戳(update_time),以及本机ip。也就是说,通过发送心跳来保证当前的服务器是活跃的,而其他服务器通过lock record中的update_time来判断当前活跃的服务器是否超时,一旦超时,其他的服务器就会去争夺锁,接管任务的执行,并发送心跳更新active_ip。

        通过上面描述,这个框架中最重要的两个概念就是分布式锁和心跳。下面看一下分布式定时任务框架中是如何实现这两点的。当然,这个框架依赖于APScheduler,所以必须安装这个模块,具体APScheduler的介绍见我的另一篇文章,因为依赖APScheduler,所以这个框架很简单,只有一个类:

from apscheduler.scheduler import Scheduler
import datetime
import time
import socket
import struct
import fcntl

def get_ip(ifname):
	s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
	return socket.inet_ntoa(fcntl.ioctl(
		s.fileno(),
		0x8915, # SIOCGIFADDR
		struct.pack('256s', ifname[:15])
	)[20:24])
	

class MutexScheduler(Scheduler):
	def __init__(self, gconfig={}, **options):
		Scheduler.__init__(self, gconfig, **options)
		self.ip = get_ip('eth0')

	def mutex(self, lock = None, heartbeat = None, lock_else = None, 
			unactive_interval = datetime.timedelta(seconds = 30)):
		
		def mutex_func_gen(func):
			def mtx_func():

				if lock:
					lock_rec = lock()
					now = datetime.datetime.now()

					# execute mutex job when the server is active, or the other server is timeout.
					if not lock_rec or lock_rec['active_ip'] == self.ip or (lock_rec['update_time'] and now - lock_rec['update_time'] >= unactive_interval):  
						if lock_rec:
							del lock_rec['active_ip']
							del lock_rec['update_time']

						if not lock_rec:
							lock_rec = {}

						lock_attrs = func(**lock_rec)
						if not lock_attrs:
							lock_attrs = {}

						# send heart beat
						heartbeat(self.ip, now, **lock_attrs)
					else: 
						lock_else(lock_rec)
				else:
					func()

			return mtx_func

		self.mtx_func_gen = mutex_func_gen

		def inner(func):
			return func

		return inner

	def cron_schedule(self, **options):
		def inner(func):
			if hasattr(self, 'mtx_func_gen'):
				func = self.mtx_func_gen(func)

			func.job = self.add_cron_job(func, **options)
			return func
		return inner
        mutex方法是核心,通过装饰器的方式提供互斥功能。在使用时:

@sched.mutex(lock = my_lock, heartbeat = my_heartbeat)
@sched.cron_schedule(second = '*')
def my_job(**attrs):
    print 'my_job ticks'
        mutex装饰器必须用在cron_schedule装饰器之前,mutex主要是组装job。mutex的参数有:

                lock:函数,用于获取锁记录(lock record),函数原型:lock()。lock的返回值时dict,就是锁记录内容。

                heartbeat:函数,用于发出心跳,函数原型:heartbeat(ip, now, **attrs)。ip是本机ip;now是当前时间戳;attrs是一个dict,用于在锁记录中存放一些其他用户自定义信息。

                lock_else:函数,在没有获得锁时执行,函数原型:lock_else(lock_rec)。lock_rec是锁记录,包含active_ip,update_time以及用户自定义的属性。

                unactive_interval:datetime.timedelta类型,超时时间,也就是说当前时间减去update_time大于unactive_interval的话,就代表超时。

        在使用这个类时,必须实现自己的lock,heartbeat以及lock_else函数。

        job的原型是job(**attrs),attrs就是存放在锁记录中的用户自定义属性,job可以有dict类型的返回值,这个返回值会存入锁记录中。

        下面,看一下具体使用的例子,使用的mongodb存放分布式锁。

import apscheduler.events
import datetime
import time
import pymongo
import sys

sys.path.append('../src/')

import mtxscheduler

sched = mtxscheduler.MutexScheduler()

mongo = pymongo.Connection(host = '127.0.0.1', port = 27017)
lock_store = mongo['lockstore']['locks']

def lock():
	print 'lock()'
	now = datetime.datetime.now() - datetime.timedelta(seconds = 3)
	lck = lock_store.find_one({'name': 't'})
	return lck

def hb(ip, now, **attrs):
	print 'heartbeat()'
	attrs['active_ip'] = ip
	attrs['update_time'] = now
	lock_store.update({'name': 't'}, {'$set': attrs}, upsert = True)

def le(lock_rec):
	if lock_rec:
		print 'active ip', lock_rec['active_ip']
	else:
		 print 'lock else'

i = 0

@sched.mutex(lock = lock, heartbeat = hb, lock_else = le)
@sched.cron_schedule(second = '*')
def job(**attr):
	global i
	i += 1
	print i

def err_listener(ev):
	if ev.exception:
		print sys.exc_info()
			
sched.add_listener(err_listener, apscheduler.events.EVENT_JOB_ERROR)

sched.start()
time.sleep(10)
        这里用到了mongodb的python driver,可以通过命令安装:

easy_install pymongo
        easy_install的安装件另一篇文章

        这个任务很简单就是定时打印整数序列。同时在两台服务器上部署运行,可以发现只有一台服务器会输出整数序列。

        使用起来还是很方便的。源代码见github,其中还有使用redis存储锁,已经在锁记录中存放自定义信息的例子。




        

没有更多推荐了,返回首页