def _initHeat(self):
"""
根据heat所需要测试，创建云主机
:return:
"""
self._loggers.stabilityHeatLogger.info('初始化heat测试的云主机规格')
self._test_heat_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.stability_test_heat_flavor)
self._test_heat_flavor_name = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.stability_test_heat_flavor)
self._loggers.stabilityHeatLogger.info('初始化heat网络资源，创建名为' +
self._test_heat_net_name +
'的网络')
test_heat_net = Net()
test_heat_net.name = StrTool.addUUID(self._test_heat_net_name)
test_heat_net.cidr = self._test_heat_subnet_cidr
try:
test_heat_net.id = self._openstackClient.createNetwork(
test_heat_net.name, test_heat_net.cidr)
except Exception, e:
self._loggers.stabilityHeatLogger.error('初始化网络' +
self._router_name + '失败!' +
'\r\n' + e.message)
def _createProjectForAccount(self, project_name):
"""
创建项目
:param project_name:
:return: project_id
"""
command = "openstack project create " + project_name + " -f json"
command = self._authTool.insertAdminAuth(command)
tmp_project_id = subprocess.check_output(command, shell=True)
project_id = StrTool.getStringWithDic(tmp_project_id, "id")
if not project_id:
return None
return project_id
def _createUserForAccount(self, user_name, password):
"""
创建用户
:param user_name:
:param password:
:return: user_id
"""
command = "openstack user create " + user_name + " --password " + password + " -f json"
command = self._authTool.insertAdminAuth(command)
tmp_user_id = subprocess.check_output(command, shell=True)
user_id = StrTool.getStringWithDic(tmp_user_id, "id")
if not user_id:
return None
return user_id
def _getPoolId(self, listener_id):
"""
获取所有负载均衡器池id
:param listener_id:
:return: pool_id
"""
command = "neutron lbaas-listener-show " + listener_id + " -f json"
command = self._neutronInsertAuth(command)
tmp_pool_id = subprocess.check_output(command, shell=True)
tmp_pool_id = StrTool.getStringWithLBRB(
tmp_pool_id, '{"Field": "default_pool_id", "Value": "', '"}')
pool_id = tmp_pool_id.strip()
if not pool_id:
return None
return pool_id
def _getHealthmonitorId(self, pool_id):
"""
获取所有负载均衡器健康检测器id
:param pool_id:
:return: healthmonitor_id
"""
command = "neutron lbaas-pool-show " + pool_id + " -f json"
command = self._neutronInsertAuth(command)
tmp_healthmonitor_id = subprocess.check_output(command, shell=True)
tmp_healthmonitor_id = StrTool.getStringWithLBRB(
tmp_healthmonitor_id, '{"Field": "healthmonitor_id", "Value": "',
'"}')
healthmonitor_id = tmp_healthmonitor_id.strip()
if not healthmonitor_id:
return None
return healthmonitor_id
def _getListenerId(self, loadbalancer_id):
"""
获取负载均衡器listenerid
:param loadbalancer_id:
:return: listener_id
"""
command = "neutron lbaas-loadbalancer-show " + loadbalancer_id + " -f json"
command = self._neutronInsertAuth(command)
tmp_listener_id = subprocess.check_output(command, shell=True)
tmp_listener_id = StrTool.getStringWithLBRB(
tmp_listener_id,
'{"Field": "listeners", "Value": "{\\\\"id\\\\": \\\\"', '\\\\"}')
listener_id = tmp_listener_id.strip()
if not listener_id:
return None
return listener_id
def _getMemberId(self, pool_id):
"""
获取所有负载均衡器后端服务器id
:param pool_id:
:return: member_ids
"""
command = "neutron lbaas-pool-show " + pool_id + " -f json"
command = self._neutronInsertAuth(command)
tmp_member_ids = subprocess.check_output(command, shell=True)
tmp_member_ids = StrTool.getStringWithLBRB(
tmp_member_ids, '{"Field": "members", "Value": "', '"}')
member_ids = []
if not tmp_member_ids.strip():
return member_ids
member_ids = tmp_member_ids.split('\\n')
return member_ids
def _initUnixbench(self):
"""
根据unixbench所需要测试，创建云主机
:return:
"""
self._loggers.stabilityUnixbenchLogger.info('初始化unixbench测试的云主机规格')
self._test_unixbench_flavor_id = getFlavorId(self._accountResource.get_flavors(), self._readConfig.executeTest.stability_test_unixbench_flavor)
self._loggers.stabilityUnixbenchLogger.info('初始化unixbench网络资源，创建名为' + self._test_unixbench_net_name + '的网络')
test_unixbench_net = Net()
test_unixbench_net.name = StrTool.addUUID(self._test_unixbench_net_name)
test_unixbench_net.cidr = self._test_unixbench_subnet_cidr
try:
test_unixbench_net.id = self._openstackClient.createNetwork(test_unixbench_net.name, test_unixbench_net.cidr)
self._test_unixbench_net_id = test_unixbench_net.id
except Exception,e:
self._loggers.stabilityUnixbenchLogger.error('创建unixbench所需网络' + self._test_unixbench_net_name + '失败!'+'\r\n'+e.message)
def getIp(self):
"""
获取存储地址
:return:
"""
commad = "openstack endpoint show -f json `openstack endpoint list | grep swift_s3 | grep public | awk {'print $2'}`"
commad = self._authTool.insertAdminAuth(commad)
try:
tmp_ip = subprocess.check_output(commad, shell=True)
tmp_ip = ujson.dumps(tmp_ip)
ip = StrTool.getStringWithLBRB(tmp_ip, 'url\\\\": \\\\"http://',
'\\\\",', 'all')
ip = ip[0].strip()
if not ip:
return None
return ip
except Exception:
return None
def _initUnixbench(self):
"""
根据unixbench所需要测试，设置要测试的网络/云主机名
:return:
"""
self._loggers.basebenchLogger.info('初始化unixbench的网络资源，创建名为' +
self._test_unixbench_net_name +
'的网络')
test_unixbench_net = Net()
test_unixbench_net.name = StrTool.addUUID(
self._test_unixbench_net_name)
test_unixbench_net.cidr = self._test_unixbench_subnet_cidr
try:
test_unixbench_net.id = self._openstackClient.createNetwork(
test_unixbench_net.name, test_unixbench_net.cidr)
except Exception, e:
self._loggers.basebenchLogger.error('创网络' +
self._test_unixbench_net_name +
'失败!' + '\r\n' + e.message)
def createLoadbalancer(self, lb_name, floatingip_id, subnet_id,
connection_limit, protocol, protocol_port,
lb_algorithmt, delay_time, max_retries, timeout,
protocol_type, instance_ips_weight):
"""
创建负载均衡器
:param lb_name:
:param floatingip_id:
:param subnet_id:
:param connection_limit: 最大连接数，可选5000,10000,20000
:param protocol: 协议,可选HTTP、TCP
:param protocol_port: 端口，范围1-65535
:param lb_algorithmt: 负载均衡方式，可选ROUND_ROBIN,LEAST_CONNECTIONS,SOURCE_IP
:param delay_time: 间隔时间，范围2-60
:param max_retries: 尝试次数，范围1-10
:param timeout: 超时时间，范围5-300
:param protocol_type: 健康检查方式，可选PING、HTTP
:param instance_ips_weight: 数组[[云主机ip,weight],[云主机ip,weight]],weight范围1-10
:return: loadbalancer_id
"""
command = "neutron lbaas-loadbalancer-create --name " + lb_name + " --floatingip_id " + floatingip_id + " -f json"
command = self._neutronInsertAuth(command)
loadbalancer_id = subprocess.check_output(command, shell=True)
loadbalancer_id = StrTool.getStringWithLBRB(
loadbalancer_id, '{"Field": "id", "Value": "', '"}')
loadbalancer_id = loadbalancer_id.strip()
if not loadbalancer_id:
return None
self._addInterfaceForLoadbalancer(loadbalancer_id, subnet_id)
listener_id = self._addListenerForLoadbalancer(lb_name,
loadbalancer_id,
connection_limit,
protocol, protocol_port)
pool_id = self._addPoolForLoadbalancer(lb_name, listener_id, protocol,
lb_algorithmt)
self._addHealthmonitorForLoadbalancer(delay_time, max_retries, timeout,
protocol_type, pool_id)
for instance_ip_weight in instance_ips_weight:
self.addMemberForLoadbalancer(subnet_id, instance_ip_weight[0],
protocol_port, instance_ip_weight[1],
pool_id)
return loadbalancer_id
def _addPoolForLoadbalancer(self, pool_name, listener_id, protocol,
lb_algorithmt):
"""
为负载均衡器创建pool
:param pool_name:
:param listener_id:
:param protocol:
:param lb_algorithmt:
:return: pool_id
"""
command = "neutron lbaas-pool-create --name " + pool_name + " --listener " + listener_id + " --protocol " + protocol\
+ " --lb-algorithm " + lb_algorithmt + " -f json"
command = self._neutronInsertAuth(command)
pool_id = subprocess.check_output(command, shell=True)
pool_id = StrTool.getStringWithLBRB(pool_id,
'{"Field": "id", "Value": "', '"}')
pool_id = pool_id.strip()
if not pool_id:
return None
return pool_id
def _initFio(self):
"""
根据fio所需要测试，设置要测试的网络/云主机名/云硬盘名
:return:
"""
self._loggers.basebenchLogger.info('初始化fio测试的云主机规格')
self._test_fio_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.basebench_test_fio_flavor)
self._loggers.basebenchLogger.info('初始化fio网络资源，创建名为' +
self._test_fio_net_name + '的网络')
test_fio_net = Net()
test_fio_net.name = StrTool.addUUID(self._test_fio_net_name)
test_fio_net.cidr = self._test_fio_subnet_cidr
try:
test_fio_net.id = self._openstackClient.createNetwork(
test_fio_net.name, test_fio_net.cidr)
except Exception, e:
self._loggers.basebenchLogger.error('创建网络' + test_fio_net.name +
'失败!' + '\r\n' + e.message)
def _addListenerForLoadbalancer(self, listener_name, loadbalancer_id,
connection_limit, protocol, protocol_port):
"""
为负载均衡器创建监听器
:param listener_name:
:param loadbalancer_id:
:param connection_limit:
:param protocol:
:param protocol_port:
:return: listener_id
"""
command = "neutron lbaas-listener-create --name " + listener_name + " --loadbalancer " + loadbalancer_id + " --connection_limit "\
+ connection_limit + " --protocol " + protocol + " --protocol-port " + protocol_port + " -f json"
command = self._neutronInsertAuth(command)
listener_id = subprocess.check_output(command, shell=True)
listener_id = StrTool.getStringWithLBRB(listener_id,
'{"Field": "id", "Value": "',
'"}')
listener_id = listener_id.strip()
if not listener_id:
return None
return listener_id
class InitResource:
def __init__(self):
self._readConfig = ReadConfig()
self._loggers = Loggers()
self._os_tenant_name = self._readConfig.accounts.basebench_os_tenant_name
self._os_project_name = self._readConfig.accounts.basebench_os_project_name
self._os_username = self._readConfig.accounts.basebench_os_username
self._os_password = self._readConfig.accounts.basebench_os_password
self._init = Init(self._os_tenant_name, self._os_project_name,
self._os_username, self._os_password,
self._loggers.basebenchLogger)
self._accountResource = self._init.initAccountResource()
self._test_fio_router_name = 'basebench_fio_router'
self._test_iperf_router_name = 'basebench_iperf_router'
self._test_unixbench_router_name = 'basebench_unixbench_router'
self._user_data_path = 'userdata/user_data'
self._test_fio_net_name = 'basebench_fio_net'
self._test_fio_subnet_cidr = '192.168.50.0/24'
self._test_iperf_net1_name = 'basebench_iperf_net1'
self._test_iperf_subnet1_cidr = '192.168.70.0/24'
self._test_iperf_net2_name = 'basebench_iperf_net2'
self._test_iperf_subnet2_cidr = '192.168.80.0/24'
self._test_unixbench_net_name = 'basebench_unixbench_net'
self._test_unixbench_subnet_cidr = '192.168.60.0/24'
self._loggers.basebenchLogger.info('===初始化基准测试基础资源===')
self._initResource()
def _initResource(self):
"""
公共资源初始化
:return:
"""
self._loggers.basebenchLogger.info('初始化命令行客户端')
self._openstackClient = OpenstackClient(self._os_tenant_name,
self._os_project_name,
self._os_username,
self._os_password)
self._novaClient = NovaClient(self._os_project_name, self._os_username,
self._os_password)
self._cinderClient = CinderClient(self._os_tenant_name,
self._os_project_name,
self._os_username, self._os_password)
self._loggers.basebenchLogger.info('初始化默认安全组、测试镜像、测试镜像')
self._default_secgroup_id = getDefaultSecGroupId(
self._accountResource.get_secgroups(),
self._readConfig.base.default_secgroup_name)
self._admin_float_net_id = getAdminFloatNetId(
self._accountResource.get_adminNets(),
self._readConfig.base.admin_float_net_name)
self._test_image_id = getTestImageId(
self._accountResource.get_images(),
self._readConfig.base.test_image_name)
self._loggers.basebenchLogger.info('初始化可用域' +
self._readConfig.base.zone_names)
self._zone_names = self._readConfig.base.zone_names.split('||')
#判断需要测试的类型
if self._readConfig.executeTest.is_basebench_test_fio.lower(
) == 'true':
self._loggers.basebenchLogger.info('===开始初始化fio资源===')
self._initFio()
if self._readConfig.executeTest.is_basebench_test_unixbench.lower(
) == 'true':
self._loggers.basebenchLogger.info('===开始初始化unixbench资源===')
self._initUnixbench()
if self._readConfig.executeTest.is_basebench_test_iperf.lower(
) == 'true':
self._loggers.basebenchLogger.info('===开始初始化iperf资源===')
self._initIperf()
self._loggers.basebenchLogger.info(
'将测试初始化资源写入到文件dbs/basebenchTestAccountResource.dbs')
FileTool.writeObjectIntoFile(self._accountResource,
'dbs/basebenchTestAccountResource.dbs')
def _initFio(self):
"""
根据fio所需要测试，设置要测试的网络/云主机名/云硬盘名
:return:
"""
self._loggers.basebenchLogger.info('初始化fio测试的云主机规格')
self._test_fio_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.basebench_test_fio_flavor)
self._loggers.basebenchLogger.info('初始化fio网络资源，创建名为' +
self._test_fio_net_name + '的网络')
test_fio_net = Net()
test_fio_net.name = StrTool.addUUID(self._test_fio_net_name)
test_fio_net.cidr = self._test_fio_subnet_cidr
try:
test_fio_net.id = self._openstackClient.createNetwork(
test_fio_net.name, test_fio_net.cidr)
except Exception, e:
self._loggers.basebenchLogger.error('创建网络' + test_fio_net.name +
'失败!' + '\r\n' + e.message)
self._test_fio_net_id = test_fio_net.id
self._loggers.basebenchLogger.info('初始化fio路由器资源，创建名为' +
self._test_fio_router_name + '的路由器')
test_fio_router = Router()
test_fio_router.name = StrTool.addUUID(self._test_fio_router_name)
try:
test_fio_router.id = self._openstackClient.createRouter(
test_fio_router.name, self._admin_float_net_id)
except Exception, e:
self._loggers.basebenchLogger.error('初始化fio路由器' +
test_fio_router.name + '失败!' +
'\r\n' + e.message)
'绑定到路由器' +
test_fio_router.name + '失败' +
'\r\n' + e.message)
self._accountResource.add_net(test_fio_net)
self._accountResource.add_router(test_fio_router)
self._loggers.basebenchLogger.info('初始化fio测试的云主机')
test_fio_volume_types = self._readConfig.executeTest.basebench_test_fio_volume_types.split(
'||')
test_fio_types = self._readConfig.executeTest.basebench_test_fio_types.split(
'||')
for test_fio_volume_type in test_fio_volume_types:
volumeType_id = getVolumeTypeId(
self._accountResource.get_volumeTypes(), test_fio_volume_type)
for test_fio_type in test_fio_types:
volumeName = StrTool.addUUID('basebench_fio_' + test_fio_type +
test_fio_volume_type)
computeName = StrTool.addUUID('basebench_fio_' +
test_fio_type +
test_fio_volume_type)
testType = test_fio_type + test_fio_volume_type
# 创建云硬盘
test_volume = Volume()
test_volume.name = volumeName
test_volume.size = self._readConfig.executeTest.basebench_test_fio_volume_size
test_volume.type = test_fio_volume_type
self._loggers.basebenchLogger.info('创建云硬盘' + test_volume.name)
try:
test_volume.id = self._cinderClient.createVolume(
volumeName, volumeType_id, test_volume.size)
except Exception, e:
self._loggers.basebenchLogger.error('创建云硬盘' +
def _initObjectstore(self):
"""
初始化对象存储稳定性测试资源
:return:
"""
self._loggers.stabilityObjstoreLogger.info('初始化对象存储测试的云主机规格')
self._test_oss_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.stability_test_objstore_load_flavor)
self._loggers.stabilityObjstoreLogger.info('初始化对象存储网络资源，创建名为' +
self._oss_net_name + '的网络')
oss_test_net = Net()
oss_test_net.name = StrTool.addUUID(self._oss_net_name)
oss_test_net.cidr = self._oss_subnet_cidr
try:
oss_test_net.id = self._openstackClient.createNetwork(
oss_test_net.name, oss_test_net.cidr)
except Exception as e:
self._loggers.stabilityObjstoreLogger.error('创建网络' +
oss_test_net.name +
'失败!' + '\r\n' +
e.args.__str__())
self._oss_test_net_id = oss_test_net.id
self._loggers.stabilityObjstoreLogger.info('初始化一个路由器资源，创建名为' +
self._router_name + '的路由')
test_router = Router()
test_router.name = StrTool.addUUID(self._router_name)
try:
test_router.id = self._openstackClient.createRouter(
test_router.name, self._admin_float_net_id)
except Exception as e:
self._loggers.stabilityObjstoreLogger.error('创建路由器' +
test_router.name +
'失败!' + '\r\n' +
e.args.__str__())
self._router_id = test_router.id
self._loggers.stabilityObjstoreLogger.info('将网络' + self._oss_net_name +
'绑定到路由器' +
self._router_name)
try:
oss_subnet_id = self._openstackClient.getSubNetId(
self._oss_test_net_id)
self._openstackClient.addRouterInterface(self._router_id,
oss_subnet_id)
test_router.add_subnet_id(oss_subnet_id)
oss_test_net.add_subnet_id(oss_subnet_id)
except Exception as e:
self._loggers.stabilityObjstoreLogger.error('将对象存储网络' +
self._oss_net_name +
'绑定到路由器' +
self._router_name +
'失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_net(oss_test_net)
self._accountResource.add_router(test_router)
self._loggers.stabilityObjstoreLogger.info('初始化对象存储测试的云主机')
computeName = StrTool.addUUID('basebench_OSS')
testType = StrTool.addUUID('OSS')
#申请浮动IP
test_oss_floatIp = FloatIp()
try:
test_oss_floatIp.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_oss_floatIp.id = self._openstackClient.getFloatId(
test_oss_floatIp.ip)
except Exception as e:
self._loggers.stabilityObjstoreLogger.error('申请浮动ip失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_floatIp(test_oss_floatIp)
#启动云主机
test_oss_compute = Compute()
test_oss_compute.name = computeName
test_oss_compute.testType = testType
try:
test_oss_compute.id = self._novaClient.bootCompute(
computeName, self._test_oss_flavor_id, self._test_image_id,
self._oss_test_net_id, self._default_secgroup_id,
random.choice(self._zone_names), self._user_data_path)
except Exception as e:
self._loggers.stabilityObjstoreLogger.error('启动云主机' +
test_oss_compute.name +
'失败!' + '\r\n' +
e.args.__str__())
# 绑定浮动ip
try:
is_add_succ = self._novaClient.addFloatForCompute(
test_oss_compute.id, test_oss_floatIp.ip)
if is_add_succ:
test_oss_compute.float_ip = test_oss_floatIp.ip
except Exception as e:
self._loggers.stabilityObjstoreLogger.error('为云主机' +
test_oss_compute.name +
'绑定浮动ip:' +
test_oss_floatIp.ip +
'失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_objectstorageCompute(test_oss_compute)
self._accountResource.add_compute(test_oss_compute)
def _initIperf(self):
"""
初始化iperf测试必须有的资源
:return:
"""
self._loggers.basebenchLogger.info('初始化iperf测试的云主机规格')
self._test_iperf_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.basebench_test_iperf_flavor)
self._loggers.basebenchLogger.info('初始化iperf测试的网络' +
self._test_iperf_net1_name + '和' +
self._test_iperf_net2_name)
test_iperf_net1 = Net()
test_iperf_net2 = Net()
test_iperf_net1.name = self._test_iperf_net1_name
test_iperf_net1.cidr = self._test_iperf_subnet1_cidr
test_iperf_net2.name = self._test_iperf_net2_name
test_iperf_net2.cidr = self._test_iperf_subnet2_cidr
try:
test_iperf_net1.id = self._openstackClient.createNetwork(
self._test_iperf_net1_name, self._test_iperf_subnet1_cidr)
test_iperf_net2.id = self._openstackClient.createNetwork(
self._test_iperf_net2_name, self._test_iperf_subnet2_cidr)
except Exception as e:
self._loggers.basebenchLogger.error('初始化iperf测试的网络' +
self._test_iperf_net1_name +
'和' +
self._test_iperf_net2_name +
'失败!' + '\r\n' +
e.args.__str__())
self._test_iperf_net1_id = test_iperf_net1.id
self._test_iperf_net2_id = test_iperf_net2.id
self._loggers.basebenchLogger.info('初始化iperf路由器资源，创建名为' +
self._test_iperf_router_name +
'的路由器')
test_iperf_router = Router()
test_iperf_router.name = StrTool.addUUID(self._test_iperf_router_name)
try:
test_iperf_router.id = self._openstackClient.createRouter(
test_iperf_router.name, self._admin_float_net_id)
except Exception as e:
self._loggers.basebenchLogger.error('初始化iperf路由器' +
test_iperf_router.name +
'失败!' + '\r\n' +
e.args.__str__())
self._loggers.basebenchLogger.info('将iperf网络' +
self._test_iperf_net1_name +
'绑定到路由器' + test_iperf_router.name)
try:
test_iperf_net1_subnet_id = self._openstackClient.getSubNetId(
self._test_iperf_net1_id)
self._openstackClient.addRouterInterface(
test_iperf_router.id, test_iperf_net1_subnet_id)
test_iperf_router.add_subnet_id(test_iperf_net1_subnet_id)
test_iperf_net1.add_subnet_id(test_iperf_net1_subnet_id)
except Exception as e:
self._loggers.basebenchLogger.error('将iperf网络' +
self._test_iperf_net1_name +
'绑定到路由器' +
test_iperf_router.name +
'失败!' + '\r\n' +
e.args.__str__())
self._loggers.basebenchLogger.info('将iperf网络' +
self._test_iperf_net2_name +
'绑定到路由器' + test_iperf_router.name)
try:
test_iperf_net2_subnet_id = self._openstackClient.getSubNetId(
self._test_iperf_net2_id)
self._openstackClient.addRouterInterface(
test_iperf_router.id, test_iperf_net2_subnet_id)
test_iperf_router.add_subnet_id(test_iperf_net2_subnet_id)
test_iperf_net2.add_subnet_id(test_iperf_net2_subnet_id)
except Exception as e:
self._loggers.basebenchLogger.error('将iperf网络' +
self._test_iperf_net2_name +
'绑定到路由器' +
test_iperf_router.name +
'失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_net(test_iperf_net1)
self._accountResource.add_net(test_iperf_net2)
self._accountResource.add_router(test_iperf_router)
self._loggers.basebenchLogger.info('初始化iperf测试的云主机')
self._loggers.basebenchLogger.info('启动两组iperf测试云主机，同网段和不同网段')
for i in range(2):
#获取可用域
if len(self._zone_names) < 2:
self._loggers.basebenchLogger.error(
'可用域' + self._zone_names.__str__() + '少于两个无法进行iperf测试')
return
# 启动2组iperf测试云主机，同网段和不同网段
iperf_computePair = []
for j in range(2):
#申请一个浮动ip
test_floatIp = FloatIp()
self._loggers.basebenchLogger.info('申请一个浮动ip')
try:
test_floatIp.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(
test_floatIp.ip)
self._loggers.basebenchLogger.info('申请到一个浮动ip:' +
test_floatIp.ip)
except Exception as e:
self._loggers.basebenchLogger.error('申请浮动ip失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_floatIp(test_floatIp)
# tmp_zone=None
# tmp_net=None
# tmp_testType=None
# tmp_name=None
#同网段
if i == 0 and j == 0:
self._loggers.basebenchLogger.info('启动同网段的第一台云主机')
tmp_zone = self._zone_names[0]
tmp_net = self._test_iperf_net1_id
tmp_testType = 'basebench_iperf_one_net'
tmp_name = StrTool.addUUID('basebench_iperf_one_' + str(j))
#同网段
elif i == 0 and j == 1:
self._loggers.basebenchLogger.info('启动同网段的第二台云主机')
tmp_zone = self._zone_names[1]
tmp_net = self._test_iperf_net1_id
tmp_testType = 'basebench_iperf_one_net'
tmp_name = StrTool.addUUID('basebench_iperf_one_' + str(j))
#不同网段
elif i == 1 and j == 0:
self._loggers.basebenchLogger.info('启动不同网段的第一台云主机')
tmp_zone = self._zone_names[0]
tmp_net = self._test_iperf_net1_id
tmp_testType = 'basebench_iperf_two_net'
tmp_name = StrTool.addUUID('basebench_iperf_two_' + str(j))
#不同网段
else:
self._loggers.basebenchLogger.info('启动不同网段的第二台云主机')
tmp_zone = self._zone_names[1]
tmp_net = self._test_iperf_net2_id
tmp_testType = 'basebench_iperf_two_net'
tmp_name = StrTool.addUUID('basebench_iperf_two_' + str(j))
#创建云主机
test_compute = Compute()
test_compute.name = tmp_name
test_compute.testType = tmp_testType
self._loggers.basebenchLogger.info('启动云主机' + test_compute.name)
try:
test_compute.id = self._novaClient.bootCompute(
test_compute.name, self._test_iperf_flavor_id,
self._test_image_id, tmp_net,
self._default_secgroup_id, tmp_zone,
self._user_data_path)
test_compute.ip = self._novaClient.getComputeIp(
test_compute.name)
except Exception as e:
self._loggers.basebenchLogger.error('启动云主机' +
test_compute.name +
'失败!' + '\r\n' +
e.args.__str__())
#绑定浮动ip
self._loggers.basebenchLogger.info('为云主机' + test_compute.name +
'绑定浮动ip:' + test_floatIp.ip)
try:
is_add_succ = self._novaClient.addFloatForCompute(
test_compute.id, test_floatIp.ip)
if is_add_succ:
test_compute.float_ip = test_floatIp.ip
except Exception as e:
self._loggers.basebenchLogger.error('为云主机' +
test_compute.name +
'绑定浮动ip:' +
test_floatIp.ip +
'失败!' + '\r\n' +
e.args.__str__())
iperf_computePair.append(test_compute)
self._accountResource.add_compute(test_compute)
#设置一组iperf云主机
self._accountResource.add_iperfComputePair(iperf_computePair)
def _initHeat(self):
"""
根据heat所需要测试，创建云主机
:return:
"""
self._loggers.stabilityHeatLogger.info('初始化heat测试的云主机规格')
self._test_heat_flavor_id = getFlavorId(self._accountResource.get_flavors(), self._readConfig.executeTest.stability_test_heat_flavor)
self._test_heat_flavor_name = getFlavorId(self._accountResource.get_flavors(), self._readConfig.executeTest.stability_test_heat_flavor)
self._loggers.stabilityHeatLogger.info('初始化heat网络资源，创建名为' + self._test_heat_net_name + '的网络')
test_heat_net = Net()
test_heat_net.name = StrTool.addUUID(self._test_heat_net_name)
test_heat_net.cidr = self._test_heat_subnet_cidr
try:
test_heat_net.id = self._openstackClient.createNetwork(test_heat_net.name, test_heat_net.cidr)
except Exception as e:
self._loggers.stabilityHeatLogger.error('初始化网络'+self._router_name+'失败!'+'\r\n'+e.args.__str__())
self._test_heat_net_id = test_heat_net.id
self._loggers.stabilityHeatLogger.info('初始化一个路由器资源，创建名为' + self._router_name + '的路由')
test_router=Router()
test_router.name=StrTool.addUUID(self._router_name)
try:
test_router.id = self._openstackClient.createRouter(test_router.name, self._admin_float_net_id)
except Exception as e:
self._loggers.stabilityHeatLogger.error('创建路由器'+self._router_name+'失败!'+'\r\n'+e.args.__str__())
self._router_id=test_router.id
self._loggers.stabilityHeatLogger.info('将heat网络' + self._test_heat_net_name + '绑定到路由器' + self._router_name)
try:
test_heat_net_subnet_id = self._openstackClient.getSubNetId(self._test_heat_net_id)
self._openstackClient.addRouterInterface(self._router_id, test_heat_net_subnet_id)
test_router.add_subnet_id(test_heat_net_subnet_id)
test_heat_net.add_subnet_id(test_heat_net_subnet_id)
except Exception as e:
self._loggers.stabilityHeatLogger.error('将heat网络' + self._test_heat_net_name + '绑定到路由器' + self._router_name + '失败!' + '\r\n' + e.args.__str__())
self._accountResource.add_net(test_heat_net)
self._accountResource.add_router(test_router)
# 初始化heat必须有的资源
self._password = '******'
self._max_computes = '5'
self._min_computes = '3'
self._alarm_type = 'cpu_util'
self._max_alarmvalue = '90'
self._min_alarmvalue = '45'
self._heat_templatepath = 'heat_template/heat_new.yaml'
for i in range(int(self._readConfig.executeTest.stability_test_heat_group_num)):
heatName = StrTool.addUUID('basebench_heat'+str(i))
testType = 'heat'
#启动heat
test_heat = Heat()
test_heat.name = heatName
test_heat.testType=testType
self._loggers.stabilityHeatLogger.info('创建一个伸缩组名为'+ test_heat.name)
try:
test_heat.id=self._heatClient.creatHeat(self._test_heat_net_id,
self._test_heat_subnet_cidr,
self._test_image_id,
self._readConfig.base.test_image_name,
self._test_heat_flavor_id,
self._test_heat_flavor_name,
self._password,
self._default_secgroup_id,
self._max_computes,
self._min_computes,
self._alarm_type,
self._max_alarmvalue,
self._min_alarmvalue,
self._heat_templatepath,
heatName)
except Exception as e:
self._loggers.stabilityHeatLogger.info('创建一个伸缩组名为' + test_heat.name + '失败!' + '\r\n' + e.args.__str__())
self._accountResource.add_heatCompute(test_heat)
class InitMemtesterResource:
def __init__(self):
self._readConfig = ReadConfig()
self._loggers = Loggers()
self._os_tenant_name = self._readConfig.accounts.stability_memtester_os_tenant_name
self._os_project_name = self._readConfig.accounts.stability_memtester_os_project_name
self._os_username = self._readConfig.accounts.stability_memtester_os_username
self._os_password = self._readConfig.accounts.stability_memtester_os_password
self._init = Init(self._os_tenant_name, self._os_project_name,
self._os_username, self._os_password,
self._loggers.stabilityMemtesterLogger)
self._accountResource = self._init.initAccountResource()
self._router_name = 'basebench_memtester_router'
self._user_data_path = 'userdata/user_data'
self._test_memtester_net_name = 'basebench_memtester_net'
self._test_memtester_subnet_cidr = '192.168.50.0/24'
self._loggers.stabilityMemtesterLogger.info(
'===初始化稳定性测试基础资源[memtester账号]===')
self._initResource()
def _initResource(self):
"""
公共资源初始化
:return:
"""
self._loggers.stabilityMemtesterLogger.info('初始化命令行客户端')
self._openstackClient = OpenstackClient(self._os_tenant_name,
self._os_project_name,
self._os_username,
self._os_password)
self._novaClient = NovaClient(self._os_project_name, self._os_username,
self._os_password)
self._cinderClient = CinderClient(self._os_tenant_name,
self._os_project_name,
self._os_username, self._os_password)
self._loggers.stabilityMemtesterLogger.info('初始化默认安全组、测试镜像、测试镜像')
self._default_secgroup_id = getDefaultSecGroupId(
self._accountResource.get_secgroups(),
self._readConfig.base.default_secgroup_name)
self._admin_float_net_id = getAdminFloatNetId(
self._accountResource.get_adminNets(),
self._readConfig.base.admin_float_net_name)
self._test_image_id = getTestImageId(
self._accountResource.get_images(),
self._readConfig.base.test_image_name)
self._zone_names = self._readConfig.base.zone_names.split('||')
#判断是否进行memtester测试
if self._readConfig.executeTest.is_stability_test_memtester.lower(
) == 'true':
self._loggers.stabilityMemtesterLogger.info(
'===开始初始化稳定性测试memtester资源===')
self._initMemtester()
self._loggers.stabilityMemtesterLogger.info(
'将测试初始化资源写入到文件dbs/stabilityMemtesterTestAccountResource.dbs')
FileTool.writeObjectIntoFile(
self._accountResource,
'dbs/stabilityMemtesterTestAccountResource.dbs')
def _initMemtester(self):
"""
根据memtester所需要测试，创建云主机
:return:
"""
self._loggers.stabilityMemtesterLogger.info('初始化memtester测试的云主机规格')
self._test_memtester_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.stability_test_memtester_flavor)
self._loggers.stabilityMemtesterLogger.info(
'初始化memtester网络资源，创建名为' + self._test_memtester_net_name + '的网络')
test_memtester_net = Net()
test_memtester_net.name = StrTool.addUUID(
self._test_memtester_net_name)
test_memtester_net.cidr = self._test_memtester_subnet_cidr
try:
test_memtester_net.id = self._openstackClient.createNetwork(
test_memtester_net.name, test_memtester_net.cidr)
except Exception, e:
self._loggers.stabilityMemtesterLogger.error(
'创建网络' + test_memtester_net.name + '失败!' + '\r\n' + e.message)
self._test_memtester_net_id = test_memtester_net.id
self._loggers.stabilityMemtesterLogger.info('初始化一个路由器资源，创建名为' +
self._router_name + '的路由')
test_router = Router()
test_router.name = StrTool.addUUID(self._router_name)
try:
test_router.id = self._openstackClient.createRouter(
test_router.name, self._admin_float_net_id)
except Exception, e:
self._loggers.stabilityMemtesterLogger.error('创建路由器' +
test_router.name +
'失败!' + '\r\n' +
e.message)
def _initFio(self):
"""
根据fio所需要测试，设置要测试的网络/云主机名/云硬盘名
:return:
"""
self._loggers.basebenchLogger.info('初始化fio测试的云主机规格')
self._test_fio_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.basebench_test_fio_flavor)
self._loggers.basebenchLogger.info('初始化fio网络资源，创建名为' +
self._test_fio_net_name + '的网络')
test_fio_net = Net()
test_fio_net.name = StrTool.addUUID(self._test_fio_net_name)
test_fio_net.cidr = self._test_fio_subnet_cidr
try:
test_fio_net.id = self._openstackClient.createNetwork(
test_fio_net.name, test_fio_net.cidr)
except Exception as e:
self._loggers.basebenchLogger.error('创建网络' + test_fio_net.name +
'失败!' + '\r\n' +
e.args.__str__())
self._test_fio_net_id = test_fio_net.id
self._loggers.basebenchLogger.info('初始化fio路由器资源，创建名为' +
self._test_fio_router_name + '的路由器')
test_fio_router = Router()
test_fio_router.name = StrTool.addUUID(self._test_fio_router_name)
try:
test_fio_router.id = self._openstackClient.createRouter(
test_fio_router.name, self._admin_float_net_id)
except Exception as e:
self._loggers.basebenchLogger.error('初始化fio路由器' +
test_fio_router.name + '失败!' +
'\r\n' + e.args.__str__())
self._loggers.basebenchLogger.info('将fio网络' + test_fio_net.name +
'绑定到路由器' + test_fio_router.name)
try:
test_fio_net_subnet_id = self._openstackClient.getSubNetId(
self._test_fio_net_id)
self._openstackClient.addRouterInterface(test_fio_router.id,
test_fio_net_subnet_id)
test_fio_net.add_subnet_id(test_fio_net_subnet_id)
test_fio_router.add_subnet_id(test_fio_net_subnet_id)
except Exception as e:
self._loggers.basebenchLogger.error('将fio网络' + test_fio_net.name +
'绑定到路由器' +
test_fio_router.name + '失败' +
'\r\n' + e.args.__str__())
self._accountResource.add_net(test_fio_net)
self._accountResource.add_router(test_fio_router)
self._loggers.basebenchLogger.info('初始化fio测试的云主机')
test_fio_volume_types = self._readConfig.executeTest.basebench_test_fio_volume_types.split(
'||')
test_fio_types = self._readConfig.executeTest.basebench_test_fio_types.split(
'||')
for test_fio_volume_type in test_fio_volume_types:
volumeType_id = getVolumeTypeId(
self._accountResource.get_volumeTypes(), test_fio_volume_type)
for test_fio_type in test_fio_types:
volumeName = StrTool.addUUID('basebench_fio_' + test_fio_type +
test_fio_volume_type)
computeName = StrTool.addUUID('basebench_fio_' +
test_fio_type +
test_fio_volume_type)
testType = test_fio_type + test_fio_volume_type
# 创建云硬盘
test_volume = Volume()
test_volume.name = volumeName
test_volume.size = self._readConfig.executeTest.basebench_test_fio_volume_size
test_volume.type = test_fio_volume_type
self._loggers.basebenchLogger.info('创建云硬盘' + test_volume.name)
try:
test_volume.id = self._cinderClient.createVolume(
volumeName, volumeType_id, test_volume.size)
except Exception as e:
self._loggers.basebenchLogger.error('创建云硬盘' +
test_volume.name +
'失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_volume(test_volume)
# 申请一个浮动ip
self._loggers.basebenchLogger.info('申请一个浮动ip')
test_floatIp = FloatIp()
try:
test_floatIp.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(
test_floatIp.ip)
self._loggers.basebenchLogger.info('申请到一个浮动ip:' +
test_floatIp.ip)
except Exception as e:
self._loggers.basebenchLogger.error('申请浮动ip失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_floatIp(test_floatIp)
# 启动云主机
test_compute = Compute()
test_compute.name = computeName
test_compute.testType = testType
self._loggers.basebenchLogger.info('启动云主机' + test_compute.name)
try:
test_compute.id = self._novaClient.bootCompute(
computeName, self._test_fio_flavor_id,
self._test_image_id, self._test_fio_net_id,
self._default_secgroup_id,
random.choice(self._zone_names), self._user_data_path)
except Exception as e:
self._loggers.basebenchLogger.error('启动云主机' +
test_compute.name +
'失败!' + '\r\n' +
e.args.__str__())
# 绑定浮动ip
self._loggers.basebenchLogger.info('为云主机' + test_compute.name +
'绑定浮动ip:' + test_floatIp.ip)
try:
is_add_succ = self._novaClient.addFloatForCompute(
test_compute.id, test_floatIp.ip)
if is_add_succ:
test_compute.float_ip = test_floatIp.ip
except Exception as e:
self._loggers.basebenchLogger.error('为云主机' +
test_compute.name +
'绑定浮动ip:' +
test_floatIp.ip +
'失败!' + '\r\n' +
e.args.__str__())
# 挂载云硬盘
self._loggers.basebenchLogger.info('为云主机' + test_compute.name +
'挂载云硬盘' + test_volume.name)
try:
is_add_succ = self._novaClient.attachVolume(
test_compute.id, test_volume.id, '/dev/vdc')
if is_add_succ:
test_compute.volumeName = test_volume.name
test_compute.volumeId = test_volume.id
except Exception as e:
self._loggers.basebenchLogger.error('为云主机' +
test_compute.name +
'挂载云硬盘' +
test_volume.name +
'失败!' + '\r\n' +
e.args.__str__())
self._accountResource.add_fioCompute(test_compute)
self._accountResource.add_compute(test_compute)
self._loggers.stabilityFioLogger.info('初始化fio测试的云主机')
volume_types_and_num = self._readConfig.executeTest.stability_test_fio_volume_types_and_num.split(
'||')
test_fio_types = self._readConfig.executeTest.stability_test_fio_types.split(
'||')
for volume_type_and_num_str in volume_types_and_num:
volume_type_and_num = volume_type_and_num_str.split('&')
volumeType_id = getVolumeTypeId(
self._accountResource.get_volumeTypes(),
volume_type_and_num[0])
num = int(volume_type_and_num[1])
while num > 0:
num = num - 1
for test_fio_type in test_fio_types:
volumeName = StrTool.addUUID('basebench_fio_' +
test_fio_type +
volume_type_and_num[0])
computeName = StrTool.addUUID('basebench_fio_' +
test_fio_type +
volume_type_and_num[0] +
'_' + str(num))
#创建云硬盘
test_volume = Volume()
try:
test_volume.name = volumeName
test_volume.type = volume_type_and_num[0]
test_volume.size = self._readConfig.executeTest.stability_test_fio_volume_size
test_volume.id = self._cinderClient.createVolume(
test_volume.name, volumeType_id, test_volume.size)
except Exception, e:
self._openstackClient.addRouterInterface(
self._router_id, test_memtester_net_subnet_id)
test_router.add_subnet_id(test_memtester_net_subnet_id)
test_memtester_net.add_subnet_id(test_memtester_net_subnet_id)
except Exception, e:
self._loggers.stabilityMemtesterLogger.error(
'将memtester网络' + self._test_memtester_net_name + '绑定到路由器' +
self._router_name + '失败!' + '\r\n' + e.message)
self._accountResource.add_net(test_memtester_net)
self._accountResource.add_router(test_router)
self._loggers.stabilityMemtesterLogger.info('初始化memtester测试的云主机')
for i in range(
int(self._readConfig.executeTest.stability_test_memtester_num)
):
computeName = StrTool.addUUID('basebench_memtester' + str(i))
testType = 'memtester'
#申请一个浮动ip
self._loggers.stabilityMemtesterLogger.info('申请一个浮动ip')
test_floatIp = FloatIp()
try:
test_floatIp.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(
test_floatIp.ip)
self._loggers.stabilityMemtesterLogger.info('申请到一个浮动ip:' +
test_floatIp.ip)
except Exception, e:
self._loggers.stabilityMemtesterLogger.error('申请浮动ip失败!' +
'\r\n' +
except Exception, e:
self._loggers.stabilityUnixbenchLogger.error('创建路由器' + self._router_name + '失败!' + '\r\n' + e.message)
self._loggers.stabilityUnixbenchLogger.info('将unixbench网络' + self._test_unixbench_net_name + '绑定到路由器' + self._router_name)
try:
test_unixbench_net_subnet_id = self._openstackClient.getSubNetId(self._test_unixbench_net_id)
self._openstackClient.addRouterInterface(self._router_id, test_unixbench_net_subnet_id)
test_router.add_subnet_id(test_unixbench_net_subnet_id)
test_unixbench_net.add_subnet_id(test_unixbench_net_subnet_id)
except Exception, e:
self._loggers.stabilityUnixbenchLogger.error('将unixbench网络' + self._test_unixbench_net_name + '绑定到路由器' + self._router_name +'失败!'+'\r\n'+e.message)
self._accountResource.add_net(test_unixbench_net)
self._accountResource.add_router(test_router)
self._loggers.stabilityUnixbenchLogger.info('初始化unixbench测试的云主机')
for i in range(int(self._readConfig.executeTest.stability_test_unixbench_num)):
computeName = StrTool.addUUID('basebench_unixbench'+str(i))
testType = 'unixbench'
#申请一个浮动ip
self._loggers.stabilityUnixbenchLogger.info('申请一个浮动ip')
test_floatIp=FloatIp()
try:
test_floatIp.ip = self._openstackClient.getFloatIp(self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(test_floatIp.ip)
except Exception,e:
self._loggers.stabilityUnixbenchLogger.error('申请浮动ip失败!'+'\r\n'+e.message)
self._accountResource.add_floatIp(test_floatIp)
#启动云主机
test_compute = Compute()
test_compute.name = computeName
'\r\n' + e.message)
self._accountResource.add_net(test_heat_net)
self._accountResource.add_router(test_router)
# 初始化heat必须有的资源
self._password = '******'
self._max_computes = '5'
self._min_computes = '3'
self._alarm_type = 'cpu_util'
self._max_alarmvalue = '90'
self._min_alarmvalue = '45'
self._heat_templatepath = 'heat_template/heat_new.yaml'
for i in range(
int(self._readConfig.executeTest.stability_test_heat_group_num)
):
heatName = StrTool.addUUID('basebench_heat' + str(i))
testType = 'heat'
#启动heat
test_heat = Heat()
test_heat.name = heatName
test_heat.testType = testType
self._loggers.stabilityHeatLogger.info('创建一个伸缩组名为' +
test_heat.name)
try:
test_heat.id = self._heatClient.creatHeat(
self._test_heat_net_id, self._test_heat_subnet_cidr,
self._test_image_id, self._readConfig.base.test_image_name,
self._test_heat_flavor_id, self._test_heat_flavor_name,
self._password, self._default_secgroup_id,
self._max_computes, self._min_computes, self._alarm_type,
self._max_alarmvalue, self._min_alarmvalue,
def _initSysbench(self):
"""
初始化Sysbench测试必须有的资源
:return:
"""
self._loggers.stabilitySysbenchLogger.info('初始化Sysbench测试的云主机规格')
self._test_sysbench_flavor_id=getFlavorId(self._accountResource.get_flavors(),self._readConfig.executeTest.stability_test_sysbench_flavor)
self._loggers.stabilitySysbenchLogger.info('初始化Sysbench测试的网络'+self._test_sysbench_net_name)
test_sysbench_net=Net()
test_sysbench_net.name=self._test_sysbench_net_name
test_sysbench_net.cidr = self._test_sysbench_subnet_cidr
try:
test_sysbench_net.id=self._openstackClient.createNetwork(self._test_sysbench_net_name,self._test_sysbench_subnet_cidr)
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('创建网络' + self._test_sysbench_net_name + '失败'+'\r\n'+e.args.__str__())
self._test_sysbench_net_id=test_sysbench_net.id
self._loggers.stabilitySysbenchLogger.info('初始化一个路由器资源，创建名为' + self._router_name + '的路由')
test_router = Router()
test_router.name = StrTool.addUUID(self._router_name)
try:
test_router.id = self._openstackClient.createRouter(test_router.name, self._admin_float_net_id)
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('创建路由器' + self._router_name + '失败' + '\r\n' + e.args.__str__())
self._router_id = test_router.id
self._loggers.stabilitySysbenchLogger.info('将Sysbench网络' + self._test_sysbench_net_name + '绑定到路由器' + self._router_name)
try:
test_sysbench_net_subnet_id=self._openstackClient.getSubNetId(self._test_sysbench_net_id)
self._openstackClient.addRouterInterface(self._router_id, test_sysbench_net_subnet_id)
test_router.add_subnet_id(test_sysbench_net_subnet_id)
test_sysbench_net.add_subnet_id(test_sysbench_net_subnet_id)
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('将Sysbench网络' + self._test_sysbench_net_name + '绑定到路由器' + self._router_name+ '失败'+'\r\n'+e.args.__str__())
self._accountResource.add_net(test_sysbench_net)
self._accountResource.add_router(test_router)
#初始化trove必须有的资源
self._trove_volume_size = '100'
self._database_name = 'sbtest'
self._user_name = 'test'
self._user_password = '******'
self._datastore_name = 'mysql'
self._datastore_version_name = '5.6'
for i in range(int(self._readConfig.executeTest.stability_test_sysbench_group_num)):
self._loggers.stabilitySysbenchLogger.info('初始化Sysbench测试的云主机')
# 启动一组Sysbench测试,同网段
sysbench_computePair=[]
computeName = StrTool.addUUID('basebench_sysbench' + str(i))
testType = 'sysbench'
#申请一个浮动ip
test_floatIp = FloatIp()
try:
test_floatIp.ip = self._openstackClient.getFloatIp(self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(test_floatIp.ip)
self._loggers.stabilitySysbenchLogger.info('申请到一个浮动ip:' + test_floatIp.ip)
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('申请浮动ip失败:'+'\r\n'+e.args.__str__())
self._accountResource.add_floatIp(test_floatIp)
#启动云主机
test_compute = Compute()
test_compute.name = computeName
test_compute.testType=testType
self._loggers.stabilitySysbenchLogger.info('启动云主机'+test_compute.name)
try:
test_compute.id=self._novaClient.bootCompute(computeName,
self._test_sysbench_flavor_id,
self._test_image_id,
self._test_sysbench_net_id,
self._default_secgroup_id,
random.choice(self._zone_names),
self._user_data_path)
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('启动云主机' + test_compute.name + '失败'+'\r\n'+e.args.__str__())
#绑定浮动ip
self._loggers.stabilitySysbenchLogger.info('为云主机' + test_compute.name + '绑定浮动ip:' + test_floatIp.ip)
try:
is_add_succ=self._novaClient.addFloatForCompute(test_compute.id,test_floatIp.ip)
if is_add_succ:
test_compute.float_ip = test_floatIp.ip
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('为云主机' + test_compute.name + '绑定浮动ip:' + test_floatIp.ip + '失败'+'\r\n'+e.args.__str__())
#创建数据库实例
troveName = StrTool.addUUID('trove' + str(i))
test_trove = Trove()
test_trove.name = troveName
self._loggers.stabilitySysbenchLogger.info('创建一台数据库实例' + test_trove.name)
try:
test_trove.id = self._troveClient.createtrove(test_trove.name,
self._test_sysbench_flavor_id,
self._trove_volume_size,
self._database_name,
self._user_name,
self._user_password,
self._test_sysbench_net_id,
random.choice(self._zone_names),
self._datastore_name,
self._datastore_version_name)
except Exception as e:
self._loggers.stabilitySysbenchLogger.info('创建一台数据库实例' + test_trove.name + '失败'+'\r\n'+e.args.__str__())
test_trove.ip = self._novaClient.getComputeIp(test_trove.name)
sysbench_computePair.append(test_compute)
self._accountResource.add_compute(test_compute)
sysbench_computePair.append(test_trove)
#self._accountResource.add_compute(test_trove)
#设置一组iperf云主机
self._accountResource.add_sysbenchComputePair(sysbench_computePair)
def _initFio(self):
"""
根据fio测试需要，设置要测试的网络/云主机名/云硬盘名
:return:
"""
self._loggers.stabilityFioLogger.info('初始化fio测试的云主机规格')
self._test_fio_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.stability_test_fio_flavor)
self._loggers.stabilityFioLogger.info('初始化fio网络资源，创建名为' +
self._fio_net_name + '的网络')
fio_test_net = Net()
fio_test_net.name = StrTool.addUUID(self._fio_net_name)
fio_test_net.cidr = self._fio_subnet_cidr
try:
fio_test_net.id = self._openstackClient.createNetwork(
fio_test_net.name, fio_test_net.cidr)
except Exception as e:
self._loggers.stabilityFioLogger.error('创建网络' + fio_test_net.name +
'失败!' + '\r\n' +
e.args.__str__())
self._fio_net_id = fio_test_net.id
self._loggers.stabilityFioLogger.info('初始化一个路由器资源，创建名为' +
self._router_name + '的路由')
test_router = Router()
test_router.name = StrTool.addUUID(self._router_name)
try:
test_router.id = self._openstackClient.createRouter(
test_router.name, self._admin_float_net_id)
except Exception as e:
self._loggers.stabilityFioLogger.error('创建路由器' + test_router.name +
'失败!' + '\r\n' +
e.args.__str__())
self._router_id = test_router.id
self._loggers.stabilityFioLogger.info('将fio网络' + self._fio_net_name +
'绑定到路由器' + self._router_name)
try:
fio_subnet_id = self._openstackClient.getSubNetId(self._fio_net_id)
self._openstackClient.addRouterInterface(self._router_id,
fio_subnet_id)
test_router.add_subnet_id(fio_subnet_id)
fio_test_net.add_subnet_id(fio_subnet_id)
except Exception as e:
self._loggers.stabilityFioLogger.error('将fio网络' +
self._fio_net_name +
'绑定到路由器' +
self._router_name + '失败!' +
'\r\n' + e.args.__str__())
self._accountResource.add_net(fio_test_net)
self._accountResource.add_router(test_router)
self._loggers.stabilityFioLogger.info('初始化fio测试的云主机')
volume_types_and_num = self._readConfig.executeTest.stability_test_fio_volume_types_and_num.split(
'||')
test_fio_types = self._readConfig.executeTest.stability_test_fio_types.split(
'||')
for volume_type_and_num_str in volume_types_and_num:
volume_type_and_num = volume_type_and_num_str.split('&')
volumeType_id = getVolumeTypeId(
self._accountResource.get_volumeTypes(),
volume_type_and_num[0])
num = int(volume_type_and_num[1])
while num > 0:
num = num - 1
for test_fio_type in test_fio_types:
volumeName = StrTool.addUUID('basebench_fio_' +
test_fio_type +
volume_type_and_num[0])
computeName = StrTool.addUUID('basebench_fio_' +
test_fio_type +
volume_type_and_num[0] +
'_' + str(num))
#创建云硬盘
test_volume = Volume()
try:
test_volume.name = volumeName
test_volume.type = volume_type_and_num[0]
test_volume.size = self._readConfig.executeTest.stability_test_fio_volume_size
test_volume.id = self._cinderClient.createVolume(
test_volume.name, volumeType_id, test_volume.size)
except Exception as e:
self._loggers.stabilityFioLogger.error(
'创建云硬盘' + volumeName + '失败' + '\r\n' +
e.args.__str__())
self._accountResource.add_volume(test_volume)
#申请浮动IP
test_floatip = FloatIp()
try:
test_floatip.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_floatip.id = self._openstackClient.getFloatId(
test_floatip.ip)
except Exception as e:
self._loggers.stabilityFioLogger.error(
'申请浮动ip失败!' + '\r\n' + e.args.__str__())
self._accountResource.add_floatIp(test_floatip)
#启动云主机
test_compute = Compute()
test_compute.name = computeName
test_compute.testType = test_fio_type
try:
test_compute.id = self._novaClient.bootCompute(
test_compute.name, self._test_fio_flavor_id,
self._test_image_id, self._fio_net_id,
self._default_secgroup_id,
random.choice(self._zone_names),
self._user_data_path)
except Exception as e:
self._loggers.stabilityFioLogger.error(
'启动云主机' + test_compute.name + '失败!' + '\r\n' +
e.args.__str__())
# 绑定浮动IP
try:
is_add_succ = self._novaClient.addFloatForCompute(
test_compute.id, test_floatip.ip)
if is_add_succ:
test_compute.float_ip = test_floatip.ip
except Exception as e:
self._loggers.stabilityFioLogger.error(
'为云主机' + test_compute.name + '绑定浮动ip:' +
test_floatip.ip + '失败!' + '\r\n' +
e.args.__str__())
# 挂载云硬盘
try:
is_attach_succ = self._novaClient.attachVolume(
test_compute.id, test_volume.id, '/dev/vdb')
if is_attach_succ:
test_compute.volumeId = test_volume.id
test_compute.volumeName = test_volume.name
except Exception as e:
self._loggers.stabilityFioLogger.error(
'挂载云硬盘失败！' + '\r\n' + e.args.__str__())
self._accountResource.add_fioCompute(test_compute)
self._accountResource.add_compute(test_compute)
except Exception, e:
self._loggers.stabilityIperfLogger.error('申请浮动ip失败!' +
'\r\n' +
e.message)
self._accountResource.add_floatIp(test_floatIp)
zone = None
net_id = None
tmp_testType = 'iperf_two_net'
name = None
#第一台
if j == 0:
self._loggers.stabilityIperfLogger.info('启动第一台云主机')
zone = self._zone_names[0]
net_id = self._test_iperf_net1_id
name = StrTool.addUUID('basebench_iperf_' + str(i) + '_' +
str(j))
#第二台
elif j == 1:
self._loggers.stabilityIperfLogger.info('启动第二台云主机')
zone = self._zone_names[1]
net_id = self._test_iperf_net2_id
name = StrTool.addUUID('basebench_iperf_' + str(i) + '_' +
str(j))
#创建云主机
test_compute = Compute()
test_compute.name = name
test_compute.testType = tmp_testType
self._loggers.stabilityIperfLogger.info('启动云主机' +
test_compute.name)
try:
def _initUnixbench(self):
"""
根据unixbench所需要测试，创建云主机
:return:
"""
self._loggers.stabilityUnixbenchLogger.info('初始化unixbench测试的云主机规格')
self._test_unixbench_flavor_id = getFlavorId(
self._accountResource.get_flavors(),
self._readConfig.executeTest.stability_test_unixbench_flavor)
self._loggers.stabilityUnixbenchLogger.info(
'初始化unixbench网络资源，创建名为' + self._test_unixbench_net_name + '的网络')
test_unixbench_net = Net()
test_unixbench_net.name = StrTool.addUUID(
self._test_unixbench_net_name)
test_unixbench_net.cidr = self._test_unixbench_subnet_cidr
try:
test_unixbench_net.id = self._openstackClient.createNetwork(
test_unixbench_net.name, test_unixbench_net.cidr)
self._test_unixbench_net_id = test_unixbench_net.id
except Exception as e:
self._loggers.stabilityUnixbenchLogger.error(
'创建unixbench所需网络' + self._test_unixbench_net_name + '失败!' +
'\r\n' + e.args.__str__())
self._loggers.stabilityUnixbenchLogger.info('初始化一个路由器资源，创建名为' +
self._router_name + '的路由')
test_router = Router()
test_router.name = StrTool.addUUID(self._router_name)
try:
test_router.id = self._openstackClient.createRouter(
test_router.name, self._admin_float_net_id)
self._router_id = test_router.id
except Exception as e:
self._loggers.stabilityUnixbenchLogger.error('创建路由器' +
self._router_name +
'失败!' + '\r\n' +
e.args.__str__())
self._loggers.stabilityUnixbenchLogger.info(
'将unixbench网络' + self._test_unixbench_net_name + '绑定到路由器' +
self._router_name)
try:
test_unixbench_net_subnet_id = self._openstackClient.getSubNetId(
self._test_unixbench_net_id)
self._openstackClient.addRouterInterface(
self._router_id, test_unixbench_net_subnet_id)
test_router.add_subnet_id(test_unixbench_net_subnet_id)
test_unixbench_net.add_subnet_id(test_unixbench_net_subnet_id)
except Exception as e:
self._loggers.stabilityUnixbenchLogger.error(
'将unixbench网络' + self._test_unixbench_net_name + '绑定到路由器' +
self._router_name + '失败!' + '\r\n' + e.args.__str__())
self._accountResource.add_net(test_unixbench_net)
self._accountResource.add_router(test_router)
self._loggers.stabilityUnixbenchLogger.info('初始化unixbench测试的云主机')
for i in range(
int(self._readConfig.executeTest.stability_test_unixbench_num)
):
computeName = StrTool.addUUID('basebench_unixbench' + str(i))
testType = 'unixbench'
#申请一个浮动ip
self._loggers.stabilityUnixbenchLogger.info('申请一个浮动ip')
test_floatIp = FloatIp()
try:
test_floatIp.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(
test_floatIp.ip)
except Exception as e:
self._loggers.stabilityUnixbenchLogger.error('申请浮动ip失败!' +
'\r\n' +
e.args.__str__())
self._accountResource.add_floatIp(test_floatIp)
#启动云主机
test_compute = Compute()
test_compute.name = computeName
test_compute.testType = testType
try:
test_compute.id = self._novaClient.bootCompute(
test_compute.name, self._test_unixbench_flavor_id,
self._test_image_id,
self._test_unixbench_net_id, self._default_secgroup_id,
random.choice(self._zone_names), self._user_data_path)
except Exception as e:
self._loggers.stabilityUnixbenchLogger.error(
'启动云主机' + test_compute.name + '失败!' + '\r\n' +
e.args.__str__())
#绑定浮动ip
self._loggers.stabilityUnixbenchLogger.info('为云主机' +
test_compute.name +
'绑定浮动ip:' +
test_floatIp.ip)
try:
is_add_succ = self._novaClient.addFloatForCompute(
test_compute.id, test_floatIp.ip)
if is_add_succ:
test_compute.float_ip = test_floatIp.ip
except Exception as e:
self._loggers.stabilityUnixbenchLogger.error(
'为云主机' + test_compute.name + '绑定浮动ip:' + test_floatIp.ip +
'失败!' + '\r\n' + e.args.__str__())
self._accountResource.add_unixbenchCompute(test_compute)
self._accountResource.add_compute(test_compute)
#初始化trove必须有的资源
self._trove_volume_size = '100'
self._database_name = 'sbtest'
self._user_name = 'test'
self._user_password = '******'
self._datastore_name = 'mysql'
self._datastore_version_name = '5.6'
for i in range(
int(self._readConfig.executeTest.
stability_test_sysbench_group_num)):
self._loggers.stabilitySysbenchLogger.info('初始化Sysbench测试的云主机')
# 启动一组Sysbench测试,同网段
sysbench_computePair = []
computeName = StrTool.addUUID('basebench_sysbench' + str(i))
testType = 'sysbench'
#申请一个浮动ip
test_floatIp = FloatIp()
try:
test_floatIp.ip = self._openstackClient.getFloatIp(
self._admin_float_net_id)
test_floatIp.id = self._openstackClient.getFloatId(
test_floatIp.ip)
self._loggers.stabilitySysbenchLogger.info('申请到一个浮动ip:' +
test_floatIp.ip)
except Exception, e:
self._loggers.stabilitySysbenchLogger.info('申请浮动ip失败:' +
'\r\n' + e.message)
