2013年4月

python限制子进程运行时间

想在python中限制子进程的运行时间,于是想到了定时器。下面是两种实现方法,具体的进程执行时间

可以调整。先看代码

#!/usr/bin/python

# limit time of subprocess running by set a timer

import os
import time
import signal
import threading

class Timer(threading.Thread):
	"""
	very simple but useless timer.
	"""
	def __init__(self, seconds):
		self.runTime = seconds
		self.process = []
		threading.Thread.__init__(self)
	def run(self):
		time.sleep(self.runTime)
		print "Time's up!"
		for pid in self.process:
			print "now kill process %d"%pid
			os.kill(pid,signal.SIGKILL)


def child():
	while True:
		print ("Child process",os.getpid())
		time.sleep(1)

if __name__ == '__main__':
	test = Timer(2)
	test.start()

	for i in range(5):
		newpid = os.fork()
		if newpid == 0:
			child()
		else:
			test.process.append(newpid)
			print ("Parent process ",os.getpid(),newpid)

- 阅读剩余部分 -

Linux下信号和sleep()

今天在写python的过程中碰到一个比较奇怪的问题,先看代码,定义了一个信号,加了一个计时器.

import time
import signal

def catcher(signum,_):
    print "beat !"

signal.signal(signal.SIGALRM, catcher)
signal.setitimer(signal.ITIMER_REAL,1, 2)

while True:
    print "hello"
    time.sleep(5)

程序一执行,输出的结果很奇怪

- 阅读剩余部分 -

python多线程编程

python多线程

传入函数创建线程

#!/usr/bin/python

import os
import sys
import time
import signal
import threading

def timer(no, interval):
    cnt = 0
    while cnt<10:
        print 'Thread:(%d) Time:%s/n'%(no, time.ctime())
        time.sleep(interval)
        cnt += 1

if __name__ == '__main__':
    #Initialize a thread object, passing in the function timer, and its parameters
    th1 = threading.Thread(target=timer, args=(1,1));
    th2 = threading.Thread(target=timer, args=(2,2));

    #Start thread
    th1.start()
    th2.start()

    #Main thread waits until child threads exit,without threading.join(),the main thread will exit even the child
    #threads is still running
    th1.join()
    th2.join()
    print "main thread exit..."

继承类创建线程

#!/usr/bin/python

import os
import sys
import threading
import signal
import time

class timer(threading.Thread): #The timer class is derived from the class threading.Thread
    def __init__(self, num, interval):
        threading.Thread.__init__(self)
        self.thread_num = num
        self.interval = interval
        self.thread_stop = False

    def run(self): #Overwrite run() method, put what you want the thread do here
        while not self.thread_stop:
            print 'Thread Object(%d), Time:%s' %(self.thread_num, time.ctime())
            time.sleep(self.interval)
            
    def stop(self):
        self.thread_stop = True

if __name__ == '__main__':
    Watcher()
    thread1 = timer(1, 1)
    thread2 = timer(2, 2)
    thread1.start()
    thread2.start()
    thread1.join()
    thread2.join()
    print "main thread exit..."

上面的程序在会出现无法响应ctrl + C 的情况,导致程序无法退出,可以加入一个Watcher的监控进程,来捕捉 ctrl + c的信号, 只需把Watcher()在线程创建之前调用即可.

class Watcher:
    def __init__(self):
        """ Creates a child thread, which returns.  The parent
            thread waits for a KeyboardInterrupt and then kills
            the child thread.
        """
        self.child = os.fork()
        if self.child == 0:
            return
        else:
            self.watch()

    def watch(self):
        try:
            os.wait()
        except KeyboardInterrupt:
            print ' exit...'
            self.kill()
        sys.exit()

    def kill(self):
        try:
            os.kill(self.child, signal.SIGKILL)
        except OSError:
            pass

python多线程有个限制,全局解释器锁(global interpreter lock),这个锁的意思是任一时间只能有一个线程使用解释器,跟单cpu跑多个程序一个意思,大家都是轮着用的,这叫“并发”,不是“并行”。手册上的解释是为了保证对象模型的正确性!这个锁造成的困扰是如果有一个计算密集型的线程占着cpu,其他的线程都得等着....,试想你的多个线程中有这么一个线程,得多悲剧,多线程生生被搞成串行;当然这个模块也不是毫无用处,手册上又说了:当用于IO密集型任务时,IO期间线程会释放解释器,这样别的线程就有机会使用解释器了!所以是否使用这个模块需要考虑面对的任务类型。

python IP地址转换

 IP地址从点分十进制到整型转换:


[code]
import socket
import struct

print struct.unpack("!L",socket.inet_aton("192.168.1.1"))[0]
[/code]

 IP地址从整型到点分十进制转换:


[code]
import socket
import struct

print socket.inet_ntoa(struct.pack("!L",integer)
[/code]

python 长整型L

>>> "Hello, world!"
'Hello, world!'
>>> 1000L
1000L
>>> #字符串是被单引号括起来的,长整型结尾有L。这是因为Python打印值的时候会保持该值在Python代码中的状态,而不是希望用户看到的状态,如果使用了print语句,结果就不一样了:
>>> print "Hello, world!"
Hello, world!
>>> print 1000L
1000
>>>

当你想知道一个变量的值是多少时,也可能会对它的整形还是长整形感兴趣。可以使用两个函数来实现这一需求:

str函数:会把值转换为合理的形式字符串,以便用户理解。
repr函数:会创建一个字符串,它以合法的Python表达式来表示:

自建CDN防御DDoS(1):知己知彼,建设持久防线

from http://www.infoq.com/cn/articles/anti-ddos-cdn-1


背景介绍


客服系统的主要业务是提供基于网页的实时动态的文字聊天,主要应用在各类网络商品销售、网站在线客服等领域,总用户数58万,同时在线活跃的用户约12万/天。

这些应用领域通常行业之间的竞争比较激烈,其中包括在线下无法名正言顺的灰色+暴利产业,导致竞争对手之间经常发动DDoS恶意攻击。但营销网站往往是单面加速,加上推广时效性很强,很难被彻底打击,于是一些自作聪明的黑客通过攻击网站的在线客服系统,导致网站无法跟访客沟通,不能交易,从而达到恶意攻击的目的。因此客服系统这个原本有助于网站营销的工具反而成了被攻击的主要对象,虽然伤得委屈,但也不得不面对挑战。

我们遭遇的DDoS攻击类型包括:延缓性的CC攻击和致命的大流量攻击。下面将对两种攻击方式的攻击特点、防御思路和我们用过的一些防御方案进行简单的介绍。

- 阅读剩余部分 -

ganglia

之前和杰哥聊天过程中发现了ganglia这个开源的项目,发现还是比较给力的.

快速开始向导


介绍


Ganglia 监控套件包括三个主要部分:gmond,gmetad,和网页接口,通常被称为ganlia-web

gmond 是一个守护进程,他运行在每一个需要监测的节点上,收集监测统计,发送和接受在同一个组播或单播通道上的统计信息
*如果他是一个发送者(mute=no)他会收集基本指标,比如系统负载(load_one),CPU利用率。他同时也会发送用户通过添加C/Python模块来自定义的指标。
*如果他是一个接收者(deaf=no)他会聚合所有从别的主机上发来的指标,并把它们都保存在内存缓冲区中。
gmetad 也是一个守护进程,他定期检查gmonds,从那里拉取数据,并将他们的指标存储在RRD存储引擎中。他可以查询多个集群并聚合指标。他也被用于生成用户界面的web前端。
ganglia-web 顾名思义,他应该安装在有gmetad运行的机器上,以便读取RRD文件。

集群是主机和度量数据的逻辑分组,比如数据库服务器,网页服务器,生产,测试,QA等,他们都是完全分开的,你需要为每个集群运行单独的gmond实例。
一般来说每个集群需要一个接收的gmond,每个网站需要一个gmetad。

- 阅读剩余部分 -