为 python 中的每个 HTTP 请求创建新的 TCP 连接
Create new TCP Connections for every HTTP request in python
对于我的大学项目,我正在尝试开发一个基于 python 的流量 generator.I 已经在 vmware 上创建了 2 台 CentOS 机器,我使用 1 台作为我的客户端,1 台作为我的服务器机器。我使用 IP 别名技术来增加客户端和服务器的数量,只使用一台 client/server 机器。到目前为止,我已经在我的客户端机器上创建了 50 个 IP 别名,在我的服务器机器上创建了 10 个 IP 别名。我还使用多处理模块同时生成从所有 50 个客户端到所有 10 个服务器的流量。我还在我的服务器上开发了一些配置文件(1kb、10kb、50kb、100kb、500kb、1mb)(在 /var/www/html 目录中,因为我使用的是 Apache 服务器),我正在使用 urllib2 从我的服务器向这些配置文件发送请求客户端机器。在这里,当我监视 TCP 连接数时 运行 我的脚本总是 <50。我想增加到 10000。我该如何实现?我想如果每一个新的http请求都建立一个新的TCP Connection,那么这个目标就可以实现了。我在正确的道路上吗?如果不是请指导我正确的路径。
'''
Traffic Generator Script:
Here I have used IP Aliasing to create multiple clients on single vm machine.
Same I have done on server side to create multiple servers. I have around 50 clients and 10 servers
'''
import multiprocessing
import urllib2
import random
import myurllist #list of all destination urls for all 10 servers
import time
import socbindtry #script that binds various virtual/aliased client ips to the script
response_time=[] #some shared variables
error_count=multiprocessing.Value('i',0)
def send_request3(): #function to send requests from alias client ip 1
opener=urllib2.build_opener(socbindtry.BindableHTTPHandler3) #bind to alias client ip1
try:
tstart=time.time()
for i in range(myurllist.url):
x=random.choice(myurllist.url[i])
opener.open(x).read()
print "file downloaded:",x
response_time.append(time.time()-tstart)
except urllib2.URLError, e:
error_count.value=error_count.value+1
def send_request4(): #function to send requests from alias client ip 2
opener=urllib2.build_opener(socbindtry.BindableHTTPHandler4) #bind to alias client ip2
try:
tstart=time.time()
for i in range(myurllist.url):
x=random.choice(myurllist.url[i])
opener.open(x).read()
print "file downloaded:",x
response_time.append(time.time()-tstart)
except urllib2.URLError, e:
error_count.value=error_count.value+1
#50 such functions are defined here for 50 clients
process=[]
def func():
global process
process.append(multiprocessing.Process(target=send_request3))
process.append(multiprocessing.Process(target=send_request4))
process.append(multiprocessing.Process(target=send_request5))
process.append(multiprocessing.Process(target=send_request6))
#append 50 functions here
for i in range(len(process)):
process[i].start()
for i in range(len(process)):
process[i].join()
print"All work Done..!!"
return
start=float(time.time())
func()
end=float(time.time())-start
print end
对于这类事情,您可能需要创建一个 pool 工作进程。我不知道 10000 个进程的池在您的用例中是否可行(这是一个非常雄心勃勃的目标),但您应该明确地研究这个想法。
池 背后的基本思想是您有 M 个任务要执行,最多同时执行 N 运行 个任务。当其中一个 worker 完成其任务时,它准备好处理另一个,直到 all 工作完成。一大优点是,如果一些任务需要很长时间才能完成,它们不会阻塞工作的整体进度(只要 "slow" 进程数 < N)。
顺带一提,这就是你程序的基本结构使用Pool
:
from multiprocessing import Pool
import time
import random
def send_request(some_parameter):
print("Do send_request", some_parameter)
time.sleep(random.randint(1,10)) # simulate randomly long process
if __name__ == '__main__':
pool = Pool(processes=100)
for i in range(200):
pool.apply_async(send_request, [i])
print("Waiting")
pool.close()
pool.join()
print("Done")
在我的系统上,这个示例程序需要大约 19 秒(实时)来执行。 在我的 Debian 系统上,在达到最大打开文件数之前,我一次只能生成 1000 多个进程(假设标准 ulimit -n
1024)。如果您需要如此大量的工作线程,您将不得不以某种方式提高该限制。即使这样做,正如我首先所说的那样,10000 个并发进程可能相当雄心勃勃(至少使用 Python)。
对于我的大学项目,我正在尝试开发一个基于 python 的流量 generator.I 已经在 vmware 上创建了 2 台 CentOS 机器,我使用 1 台作为我的客户端,1 台作为我的服务器机器。我使用 IP 别名技术来增加客户端和服务器的数量,只使用一台 client/server 机器。到目前为止,我已经在我的客户端机器上创建了 50 个 IP 别名,在我的服务器机器上创建了 10 个 IP 别名。我还使用多处理模块同时生成从所有 50 个客户端到所有 10 个服务器的流量。我还在我的服务器上开发了一些配置文件(1kb、10kb、50kb、100kb、500kb、1mb)(在 /var/www/html 目录中,因为我使用的是 Apache 服务器),我正在使用 urllib2 从我的服务器向这些配置文件发送请求客户端机器。在这里,当我监视 TCP 连接数时 运行 我的脚本总是 <50。我想增加到 10000。我该如何实现?我想如果每一个新的http请求都建立一个新的TCP Connection,那么这个目标就可以实现了。我在正确的道路上吗?如果不是请指导我正确的路径。
'''
Traffic Generator Script:
Here I have used IP Aliasing to create multiple clients on single vm machine.
Same I have done on server side to create multiple servers. I have around 50 clients and 10 servers
'''
import multiprocessing
import urllib2
import random
import myurllist #list of all destination urls for all 10 servers
import time
import socbindtry #script that binds various virtual/aliased client ips to the script
response_time=[] #some shared variables
error_count=multiprocessing.Value('i',0)
def send_request3(): #function to send requests from alias client ip 1
opener=urllib2.build_opener(socbindtry.BindableHTTPHandler3) #bind to alias client ip1
try:
tstart=time.time()
for i in range(myurllist.url):
x=random.choice(myurllist.url[i])
opener.open(x).read()
print "file downloaded:",x
response_time.append(time.time()-tstart)
except urllib2.URLError, e:
error_count.value=error_count.value+1
def send_request4(): #function to send requests from alias client ip 2
opener=urllib2.build_opener(socbindtry.BindableHTTPHandler4) #bind to alias client ip2
try:
tstart=time.time()
for i in range(myurllist.url):
x=random.choice(myurllist.url[i])
opener.open(x).read()
print "file downloaded:",x
response_time.append(time.time()-tstart)
except urllib2.URLError, e:
error_count.value=error_count.value+1
#50 such functions are defined here for 50 clients
process=[]
def func():
global process
process.append(multiprocessing.Process(target=send_request3))
process.append(multiprocessing.Process(target=send_request4))
process.append(multiprocessing.Process(target=send_request5))
process.append(multiprocessing.Process(target=send_request6))
#append 50 functions here
for i in range(len(process)):
process[i].start()
for i in range(len(process)):
process[i].join()
print"All work Done..!!"
return
start=float(time.time())
func()
end=float(time.time())-start
print end
对于这类事情,您可能需要创建一个 pool 工作进程。我不知道 10000 个进程的池在您的用例中是否可行(这是一个非常雄心勃勃的目标),但您应该明确地研究这个想法。
池 背后的基本思想是您有 M 个任务要执行,最多同时执行 N 运行 个任务。当其中一个 worker 完成其任务时,它准备好处理另一个,直到 all 工作完成。一大优点是,如果一些任务需要很长时间才能完成,它们不会阻塞工作的整体进度(只要 "slow" 进程数 < N)。
顺带一提,这就是你程序的基本结构使用Pool
:
from multiprocessing import Pool
import time
import random
def send_request(some_parameter):
print("Do send_request", some_parameter)
time.sleep(random.randint(1,10)) # simulate randomly long process
if __name__ == '__main__':
pool = Pool(processes=100)
for i in range(200):
pool.apply_async(send_request, [i])
print("Waiting")
pool.close()
pool.join()
print("Done")
在我的系统上,这个示例程序需要大约 19 秒(实时)来执行。 在我的 Debian 系统上,在达到最大打开文件数之前,我一次只能生成 1000 多个进程(假设标准 ulimit -n
1024)。如果您需要如此大量的工作线程,您将不得不以某种方式提高该限制。即使这样做,正如我首先所说的那样,10000 个并发进程可能相当雄心勃勃(至少使用 Python)。