Locust 是一个开源的python压力测试的框架，代码相对简单，涵盖的东西却不少。 修改起来挺方便，适合学习一个项目。
github: https://github.com/locustio/locust
OptionParser
OptionParser 是一个生成commandline 解析各个参数的库，并能自动生成帮助文件，很强大
基本用法
parser = OptionParser(usage="locust [options] [LocustClass [LocustClass2 ... ]]")
parser.add_option(
'--loglevel', '-L',
action='store',
type='str',
dest='loglevel',
default='INFO',
help="Choose between DEBUG/INFO/WARNING/ERROR/CRITICAL. Default is INFO.",
)
其中action有一组固定的值可供选择，默认是’store ‘，表示将命令行参数值保存在 options 对象里。 store_true 和 store_false ，用于处理带命令行参数后面不 带值的情况。如 -v,-q 等命令行参数：
parser.add_option("-v", action="store_true", dest="verbose")
parser.add_option("-q", action="store_false", dest="verbose")
其它的 actions 值还有：store_const 、append 、count 、callback 。
命令分组
如果程序有很多的命令行参数，你可能想为他们进行分组，这时可以使用 OptonGroup
group = OptionGroup(parser, ``Dangerous Options'',
``Caution: use these options at your own risk. ``
``It is believed that some of them bite.'')
group.add_option(``-g'', action=''store_true'', help=''Group option.'')
parser.add_option_group(group)
下面是将会打印出来的帮助信息：
usage: [options] arg1 arg2
options:
-h, --help show this help message and exit
-v, --verbose make lots of noise [default]
-q, --quiet be vewwy quiet (I'm hunting wabbits)
-fFILE, --file=FILE write output to FILE
-mMODE, --mode=MODE interaction mode: one of 'novice', 'intermediate'
[default], 'expert'
Dangerous Options:
Caution: use of these options is at your own risk. It is believed that
some of them bite.
-g Group option.
显示程序版本
象 usage message 一样，你可以在创建 OptionParser 对象时，指定其 version 参数，用于显示当前程序的版本信息：
parser = OptionParser(usage="%prog [-f] [-q]", version="%prog 1.0")
这样，optparse 就会自动解释 –version 命令行参数：
$ /usr/bin/foo --version
foo 1.0
处理异常
包括程序异常和用户异常。这里主要讨论的是用户异常，是指因用户输入无效的、不完整的命令行参数而引发的异常。optparse 可以自动探测并处理一些用户异常：
$ /usr/bin/foo -n 4x
usage: foo [options]
foo: error: option -n: invalid integer value: '4x'
$ /usr/bin/foo -n
usage: foo [options]
foo: error: -n option requires an argument
用户也可以使用 parser.error() 方法来自定义部分异常的处理：
(options, args) = parser.parse_args()
[...]
if options.a and options.b:
parser.error("options -a and -b are mutually exclusive")
上面的例子，当 -b 和 -b 命令行参数同时存在时，会打印出“options -a and -b are mutually exclusive“，以警告用户。
如果以上的异常处理方法还不能满足要求，你可能需要继承 OptionParser 类，并重载 exit() 和 erro() 方法。
load python 文件
locust 框架是load 你自己写的python 文件并解析的，这个也挺有意思的。 def load_locustfile(path)函数是实现这个目的的， 代码如下：
def load_locustfile(path):
"""
Import given locustfile path and return (docstring, callables).
Specifically, the locustfile's ``__doc__`` attribute (a string) and a
dictionary of ``{'name': callable}`` containing all callables which pass
the "is a Locust" test.
"""
# Get directory and locustfile name
directory, locustfile = os.path.split(path)
# If the directory isn't in the PYTHONPATH, add it so our import will work
added_to_path = False
index = None
if directory not in sys.path:
sys.path.insert(0, directory)
added_to_path = True
# If the directory IS in the PYTHONPATH, move it to the front temporarily,
# otherwise other locustfiles -- like Locusts's own -- may scoop the intended
# one.
else:
i = sys.path.index(directory)
if i != 0:
# Store index for later restoration
index = i
# Add to front, then remove from original position
sys.path.insert(0, directory)
del sys.path[i + 1]
# Perform the import (trimming off the .py)
imported = __import__(os.path.splitext(locustfile)[0])
# Remove directory from path if we added it ourselves (just to be neat)
if added_to_path:
del sys.path[0]
# Put back in original index if we moved it
if index is not None:
sys.path.insert(index + 1, directory)
del sys.path[0]
# Return our two-tuple
locusts = dict(filter(is_locust, vars(imported).items()))
return imported.__doc__, locusts
要点是 imported = __import__(os.path.splitext(locustfile)[0]) 导入你写的python 文件， 然后用 locusts = dict(filter(is_locust, vars(imported).items()))进行解析。 导入这个很好理解，vars()函数是python 内置的一个函数，在输入是对象的时候和__dict__ 一致。 这里是用来获得导入模块里面的所有内容的。filter函数也是python 内置的一个函数，用来过滤列表的，很有用哦~
协程 gevent
可以看到locust有一个web端，他是用协程起的
main_greenlet = gevent.spawn(web.start, locust_classes, options)
gevent是第三方库，通过greenlet实现协程，其基本思想是：
当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。
gevent 需要自己安装，底层用C写的。协程的概念类似于CPU的中断和轮询，看起来像是多线程，其实只有CPU的一个core 在跑。
协程的好处：
- 跨平台
- 跨体系架构
- 无需线程上下文切换的开销
- 无需原子操作锁定及同步的开销
- 方便切换控制流，简化编程模型
- 高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。
缺点：
- 无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程- 需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。
- 进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序：这一点和事件驱动一样，可以使用异步IO操作来解决
Event
一个简单event实现，以后可以参考
class EventHook(object):
"""
Simple event class used to provide hooks for different types of events in Locust.
Here's how to use the EventHook class::
my_event = EventHook()
def on_my_event(a, b, **kw):
print "Event was fired with arguments: %s, %s" % (a, b)
my_event += on_my_event
my_event.fire(a="foo", b="bar")
"""
def __init__(self):
self._handlers = []
def __iadd__(self, handler):
self._handlers.append(handler)
return self
def __isub__(self, handler):
self._handlers.remove(handler)
return self
def fire(self, **kwargs):
for handler in self._handlers:
handler(**kwargs)
request_success = EventHook()
core
core.py 文件是locust 数据结构和核心
用decorate去给task加权重
def task(weight=1):
"""
Used as a convenience decorator to be able to declare tasks for a TaskSet
inline in the class. Example::
class ForumPage(TaskSet):
@task(100)
def read_thread(self):
pass
@task(7)
def create_thread(self):
pass
"""
def decorator_func(func):
func.locust_task_weight = weight
return func
"""
Check if task was used without parentheses (not called), like this::
@task
def my_task()
pass
"""
if callable(weight):
func = weight
weight = 1
return decorator_func(func)
else:
return decorator_func
用元类去改造Locust类: 加了一个变量new_tasks，并fuzhi
class TaskSetMeta(type):
"""
Meta class for the main Locust class. It's used to allow Locust classes to specify task execution
ratio using an {task:int} dict, or a [(task0,int), ..., (taskN,int)] list.
"""
def __new__(mcs, classname, bases, classDict):
new_tasks = []
for base in bases:
if hasattr(base, "tasks") and base.tasks:
new_tasks += base.tasks
if "tasks" in classDict and classDict["tasks"] is not None:
tasks = classDict["tasks"]
if isinstance(tasks, dict):
tasks = six.iteritems(tasks)
for task in tasks:
if isinstance(task, tuple):
task, count = task
for i in xrange(0, count):
new_tasks.append(task)
else:
new_tasks.append(task)
for item in six.itervalues(classDict):
if hasattr(item, "locust_task_weight"):
for i in xrange(0, item.locust_task_weight):
new_tasks.append(item)
classDict["tasks"] = new_tasks
return type.__new__(mcs, classname, bases, classDict)