import time
import os
# from SpeedTest import perform_default_speedtest
# 测试硬盘读写速度
def test_disk_speed():
filename = "./testfile.bin"
# 生成一个1GB大小的测试文件
with open(filename, "wb") as f:
f.write(os.urandom(1024*1024*1024))
# 从磁盘读取文件并记录时间
start_time = time.time()
with open(filename, "rb") as f:
while f.read(1024*1024):
pass
end_time = time.time()
# 计算磁盘读取速度
speed = os.path.getsize(filename) / (end_time - start_time) / (1024*1024)
print("磁盘读取速度: %.2f MB/s" % speed)
# 删除测试文件
os.remove(filename)
# 测试内存读写速度
def test_memory_speed():
# 生成一个1GB大小的测试数据
data = bytearray(os.urandom(1024*1024*1024))
# 从内存读取数据并记录时间
start_time = time.time()
for i in range(1024):
chunk = data[i*1024*1024:(i+1)*1024*1024]
end_time = time.time()
# 计算内存读取速度
speed = len(data) / (end_time - start_time) / (1024*1024)
print("内存读取速度: %.2f MB/s" % speed)
# 测试网络速度
# def test_network_speed():
# 创建 SpeedTest 实例
# speedtest = SpeedTest("www.speedtest.cn", debug=1, runs=2)
# perform_detault_speedtest("www.speedtest.cn")
# st = SpeedTest()
# # 测试下载速度
# download_speed = st.download() / (1024**2) # 将结果转换成 MB/s
# print("下载速度: %.2f MB/s" % download_speed)
# # 测试上传速度
# upload_speed = st.upload() / (1024**2) # 将结果转换成 MB/s
# print("上传速度: %.2f MB/s" % upload_speed)
# # 测试延迟
# ping = st.ping()
# print("延迟: %.2f ms" % ping)
if __name__ == "__main__":
# test_network_speed()
test_disk_speed()
test_memory_speed()下面是 SpeedTest .py文件内容. 用来测试网络速度的. 但是目前似乎有问题. 应该是规则变了 .
后来改用了一个linux的命令行工具进行的网速测试.
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import print_function
import argparse
import bisect
import itertools
import logging
import random
import re
import string
import sys
import platform
from math import sqrt
from threading import currentThread, Thread
from time import time
try:
from httplib import HTTPConnection
except ImportError:
from http.client import HTTPConnection
try:
from urllib import urlencode
except ImportError:
from urllib.parse import urlencode
__program__ = 'pyspeedtest'
__version__ = '1.2.7'
__description__ = 'Test your bandwidth speed using Speedtest.net servers.'
__supported_formats__ = ('default', 'json', 'xml')
class SpeedTest(object):
USER_AGENTS = {
'Linux': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:41.0) Gecko/20100101 Firefox/41.0',
'Darwin': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:41.0) Gecko/20100101 Firefox/41.0',
'Windows': 'Mozilla/5.0 (Windows NT 6.3; WOW64; rv:41.0) Gecko/20100101 Firefox/41.0',
'Java': 'Java/1.6.0_12',
}
DOWNLOAD_FILES = [
'/speedtest/random350x350.jpg',
'/speedtest/random500x500.jpg',
'/speedtest/random1500x1500.jpg'
]
UPLOAD_FILES = [
132884,
493638
]
ALPHABET = string.digits + string.ascii_letters
def __init__(self, host=None, http_debug=0, runs=2):
self._host = host
self.http_debug = http_debug
self.runs = runs
@property
def host(self):
if not self._host:
self._host = self.chooseserver()
return self._host
@host.setter
def host(self, new_host):
self._host = new_host
def connect(self, url):
try:
connection = HTTPConnection(url)
connection.set_debuglevel(self.http_debug)
connection.connect()
return connection
except:
raise Exception('Unable to connect to %r' % url)
def downloadthread(self, connection, url):
connection.request('GET', url, None, {'Connection': 'Keep-Alive'})
response = connection.getresponse()
self_thread = currentThread()
self_thread.downloaded = len(response.read())
def download(self):
total_downloaded = 0
connections = [
self.connect(self.host) for i in range(self.runs)
]
total_start_time = time()
for current_file in SpeedTest.DOWNLOAD_FILES:
threads = []
for run in range(self.runs):
thread = Thread(
target=self.downloadthread,
args=(connections[run],
'%s?x=%d' % (current_file, int(time() * 1000))))
thread.run_number = run + 1
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
total_downloaded += thread.downloaded
LOG.debug('Run %d for %s finished',
thread.run_number, current_file)
total_ms = (time() - total_start_time) * 1000
for connection in connections:
connection.close()
LOG.info('Took %d ms to download %d bytes',
total_ms, total_downloaded)
return total_downloaded * 8000 / total_ms
def uploadthread(self, connection, data):
url = '/speedtest/upload.php?x=%d' % randint()
connection.request('POST', url, data, {
'Connection': 'Keep-Alive',
'Content-Type': 'application/x-www-form-urlencoded'
})
response = connection.getresponse()
reply = response.read().decode('utf-8')
self_thread = currentThread()
self_thread.uploaded = int(reply.split('=')[1])
def upload(self):
connections = [
self.connect(self.host) for i in range(self.runs)
]
post_data = [
urlencode({'content0': content(s)}) for s in SpeedTest.UPLOAD_FILES
]
total_uploaded = 0
total_start_time = time()
for data in post_data:
threads = []
for run in range(self.runs):
thread = Thread(target=self.uploadthread,
args=(connections[run], data))
thread.run_number = run + 1
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
LOG.debug('Run %d for %d bytes finished',
thread.run_number, thread.uploaded)
total_uploaded += thread.uploaded
total_ms = (time() - total_start_time) * 1000
for connection in connections:
connection.close()
LOG.info('Took %d ms to upload %d bytes',
total_ms, total_uploaded)
return total_uploaded * 8000 / total_ms
def ping(self, server=None):
if not server:
server = self.host
connection = self.connect(server)
times = []
worst = 0
for _ in range(5):
total_start_time = time()
connection.request(
'GET',
'/speedtest/latency.txt?x=%d' % randint(),
None,
{'Connection': 'Keep-Alive'})
response = connection.getresponse()
response.read()
total_ms = time() - total_start_time
times.append(total_ms)
if total_ms > worst:
worst = total_ms
times.remove(worst)
total_ms = sum(times) * 250 # * 1000 / number of tries (4) = 250
connection.close()
LOG.debug('Latency for %s - %d', server, total_ms)
return total_ms
def chooseserver(self):
connection = self.connect('www.speedtest.cn')
now = int(time() * 1000)
# really contribute to speedtest.net OS statistics
# maybe they won't block us again...
extra_headers = {
'Connection': 'Keep-Alive',
'User-Agent': self.USER_AGENTS.get(platform.system(), self.USER_AGENTS['Linux'])
}
connection.request(
'GET', '/speedtest-config.php?x=%d' % now, None, extra_headers)
response = connection.getresponse()
reply = response.read().decode('utf-8')
match = re.search(
r'<client ip="([^"]*)" lat="([^"]*)" lon="([^"]*)"', reply)
location = None
if match is None:
LOG.info('Failed to retrieve coordinates')
return None
location = match.groups()
LOG.info('Your IP: %s', location[0])
LOG.info('Your latitude: %s', location[1])
LOG.info('Your longitude: %s', location[2])
connection.request(
'GET', '/speedtest-servers.php?x=%d' % now, None, extra_headers)
response = connection.getresponse()
reply = response.read().decode('utf-8')
server_list = re.findall(
r'<server url="([^"]*)" lat="([^"]*)" lon="([^"]*)"', reply)
my_lat = float(location[1])
my_lon = float(location[2])
sorted_server_list = []
for server in server_list:
s_lat = float(server[1])
s_lon = float(server[2])
distance = sqrt(pow(s_lat - my_lat, 2) + pow(s_lon - my_lon, 2))
bisect.insort_left(sorted_server_list, (distance, server[0]))
best_server = (999999, '')
for server in sorted_server_list[:10]:
LOG.debug(server[1])
match = re.search(
r'http://([^/]+)/speedtest/upload\.php', server[1])
if match is None:
continue
server_host = match.groups()[0]
latency = self.ping(server_host)
if latency < best_server[0]:
best_server = (latency, server_host)
if not best_server[1]:
raise Exception('Cannot find a test server')
LOG.debug('Best server: %s', best_server[1])
return best_server[1]
def content(length):
"""Return alphanumeric string of indicated length."""
cycle = itertools.cycle(SpeedTest.ALPHABET)
return ''.join(next(cycle) for i in range(length))
def init_logging(loglevel=logging.WARNING):
"""Initialize program logger."""
scriptlogger = logging.getLogger(__program__)
# ensure logger is not reconfigured
# it would be nice to use hasHandlers here, but that's Python 3 only
if not scriptlogger.handlers:
# set log level
scriptlogger.setLevel(loglevel)
# log message format
fmt = '%(name)s:%(levelname)s: %(message)s'
# configure terminal log
streamhandler = logging.StreamHandler()
streamhandler.setFormatter(logging.Formatter(fmt))
scriptlogger.addHandler(streamhandler)
def parseargs(args):
class SmartFormatter(argparse.HelpFormatter):
def _split_lines(self, text, width):
"""argparse.RawTextHelpFormatter._split_lines"""
if text.startswith('r|'):
return text[2:].splitlines()
return argparse.HelpFormatter._split_lines(self, text, width)
def positive_int(value):
try:
ivalue = int(value)
if ivalue < 0:
raise ValueError
return ivalue
except ValueError:
raise argparse.ArgumentTypeError(
'invalid positive int value: %r' % value)
def format_enum(value):
if value.lower() not in __supported_formats__:
raise argparse.ArgumentTypeError(
'output format not supported: %r' % value)
return value
parser = argparse.ArgumentParser(
add_help=False,
description=__description__,
formatter_class=SmartFormatter,
usage='%(prog)s [OPTION]...')
parser.add_argument(
'-d', '--debug',
default=0,
help='set http connection debug level (default is 0)',
metavar='L',
type=positive_int)
parser.add_argument(
'-h', '--help',
action='help',
help=argparse.SUPPRESS)
parser.add_argument(
'-m', '--mode',
choices=range(1, 8),
default=7,
help='''r|test mode: 1 - download
2 - upload
4 - ping
1 + 2 + 4 = 7 - all (default)''',
metavar='M',
type=int)
parser.add_argument(
'-r', '--runs',
default=2,
help='use N runs (default is 2)',
metavar='N',
type=positive_int)
parser.add_argument(
'-s', '--server',
help='use specific server',
metavar='H')
parser.add_argument(
'-f', '--format',
default='default',
help='output format ' + str(__supported_formats__),
metavar='F',
type=format_enum)
parser.add_argument(
'-v', '--verbose',
action='store_true',
dest='verbose',
help='output additional information')
parser.add_argument(
'--version',
action='version',
version='%(prog)s ' + __version__)
return parser.parse_args(args)
def perform_default_speedtest(server,debug=0,runs=2, format='default'):
speedtest = SpeedTest(server, debug, runs)
if format in __supported_formats__:
if format == 'default':
print('Using server: %s' % speedtest.host)
#if mode & 4 == 4:
print('Ping: %d ms' % speedtest.ping())
#if mode & 1 == 1:
print('Download speed: %s' % pretty_speed(speedtest.download()))
#if mode & 2 == 2:
print('Upload speed: %s' % pretty_speed(speedtest.upload()))
else:
stats = dict(server=speedtest.host)
#if mode & 4 == 4:
stats['ping'] = speedtest.ping()
#if mode & 1 == 1:
stats['download'] = speedtest.download()
#if mode & 2 == 2:
stats['upload'] = speedtest.upload()
if format == 'json':
from json import dumps
print(dumps(stats))
elif format == 'xml':
from xml.etree.ElementTree import Element, tostring
xml = Element('data')
for key, val in stats.items():
child = Element(key)
child.text = str(val)
xml.append(child)
print(tostring(xml).decode('utf-8'))
else:
raise Exception('Output format not supported: %s' % format)
def perform_speedtest(opts):
speedtest = SpeedTest(opts.server, opts.debug, opts.runs)
if opts.format in __supported_formats__:
if opts.format == 'default':
print('Using server: %s' % speedtest.host)
if opts.mode & 4 == 4:
print('Ping: %d ms' % speedtest.ping())
if opts.mode & 1 == 1:
print('Download speed: %s' % pretty_speed(speedtest.download()))
if opts.mode & 2 == 2:
print('Upload speed: %s' % pretty_speed(speedtest.upload()))
else:
stats = dict(server=speedtest.host)
if opts.mode & 4 == 4:
stats['ping'] = speedtest.ping()
if opts.mode & 1 == 1:
stats['download'] = speedtest.download()
if opts.mode & 2 == 2:
stats['upload'] = speedtest.upload()
if opts.format == 'json':
from json import dumps
print(dumps(stats))
elif opts.format == 'xml':
from xml.etree.ElementTree import Element, tostring
xml = Element('data')
for key, val in stats.items():
child = Element(key)
child.text = str(val)
xml.append(child)
print(tostring(xml).decode('utf-8'))
else:
raise Exception('Output format not supported: %s' % opts.format)
def main(args=None):
opts = parseargs(args)
init_logging(logging.DEBUG if opts.verbose else logging.WARNING)
try:
perform_speedtest(opts)
except Exception as e:
if opts.verbose:
LOG.exception(e)
else:
LOG.error(e)
sys.exit(1)
def pretty_speed(speed):
units = ['bps', 'Kbps', 'Mbps', 'Gbps']
unit = 0
while speed >= 1024:
speed /= 1024
unit += 1
return '%0.2f %s' % (speed, units[unit])
def randint():
"""Return a random 12 digit integer."""
return random.randint(100000000000, 999999999999)
LOG = logging.getLogger(__program__)
if __name__ == '__main__':
main()安装网络测试 命令行工具
curl -s https://packagecloud.io/install/repositories/ookla/speedtest-cli/script.rpm.sh | sudo bash
sudo yum install speedtest执行网络测试用命令
/usr/bin/speedtest
