def test_req_replyc(self):
'''Send request from basicinbox and verify it recives reply from basicpub'''
my_print(
"\n----------------------Running request_replyc test---------------------\n"
)
basicpubc_out = open('req_reply_basicpubc.out', 'w')
basicpubc_err = open('req_reply_basicpubc.err', 'w')
basicinboxc_out = open('req_reply_basicinboxc.out', 'w')
ret1 = start_app("basicpubc",
"pub",
args=["-v", "-v", "-v", "-v"],
stdout=basicpubc_out,
stderr=basicpubc_err)
ret2 = call_wait4text("Created inbound subscription",
"req_reply_basicpubc.out")
ret3 = start_app("basicinboxc",
"sub",
stdout=basicinboxc_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Received reply", "req_reply_basicinboxc.out")
basicpubc_out.close()
basicpubc_err.close()
basicinboxc_out.close()
kill_process(ret3.pid)
self.assertTrue(ret4 == 0)
def test_ft_active_standbyc(self):
'''start two basicftmemberc and verify the first one goes ot active and second to standby, if both belong to same group'''
my_print(
"\n--------------Running basicftmemberc test active-standby--------------\n"
)
ftmemberc1_out = open('active_standby_ftmemberc1.out', 'w')
ftmemberc2_out = open('active_standby_ftmemberc2.out', 'w')
ret1 = start_app("basicftmemberc",
"pub",
args=["-g", "active-standby", "-b"],
stdout=ftmemberc1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active",
"active_standby_ftmemberc1.out")
ret3 = start_app("basicftmemberc",
"sub",
args=["-g", "active-standby", "-b"],
stdout=ftmemberc2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is standby",
"active_standby_ftmemberc2.out")
ret5 = call_wait4text("Current state is standby",
"active_standby_ftmemberc1.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 1)
def test_pubsubc(self):
'''publish messages using basicpubc and verify basicsubc receives the messages'''
my_print(
"\n-------------------------Running pubsubc test-------------------------\n"
)
basicsubc_out = open('pubsub_basicsubc.out', 'w')
basicsubc_err = open('pubsub_basicsubc.err', 'w')
basicpubc_out = open('pubsub_basicpubc.out', 'w')
ret1 = start_app("basicsubc",
"sub",
args=["-v", "-v", "-v", "-v"],
stdout=basicsubc_out,
stderr=basicsubc_err)
ret2 = call_wait4text("Created inbound subscription",
"pubsub_basicsubc.out")
ret3 = start_app("basicpubc",
"pub",
stdout=basicpubc_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("EXIT", "pubsub_basicsubc.out")
ret5 = call_comparelog("pubsub_expectedsubc.out",
"pubsub_basicsubc.out")
basicsubc_out.close()
basicsubc_err.close()
basicpubc_out.close()
if ret1.poll() is None:
kill_process(ret1.pid)
if ret3.poll() is None:
kill_process(ret3.pid)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_ft_priorityc(self):
'''start two basicftmemberc with different priority and verify that the one with lower priority goes to standby
from active'''
my_print(
"\n-----------------Running basicftmemberc test priority-----------------\n"
)
ftmemberc1_out = open('priority_ftmemberc1.out', 'w')
ftmemberc2_out = open('priority_ftmemberc2.out', 'w')
ret1 = start_app("basicftmemberc",
"pub",
args=["-g", "priority", "-w", "40", "-b"],
stdout=ftmemberc1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active",
"priority_ftmemberc1.out")
ret3 = start_app("basicftmemberc",
"sub",
args=["-g", "priority", "-w", "60", "-b"],
stdout=ftmemberc2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is active",
"priority_ftmemberc2.out")
ret5 = call_wait4text("Current state is standby",
"priority_ftmemberc1.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def test_pubsubcpp(self):
'''publish messages using basicpubcpp and verify basicsubcpp receives the messages'''
my_print("\n----------Running pubsubcpp test----------\n")
basicsubcpp_out = open('pubsub_basicsubcpp.out','w')
basicsubcpp_err = open('pubsub_basicsubcpp.err','w')
basicpubcpp_out = open('pubsub_basicpubcpp.out','w')
ret1 = start_app("basicsubcpp","sub",args=["-v","-v","-v","-v"],stdout=basicsubcpp_out,stderr=basicsubcpp_err)
ret2 = call_wait4text("Created inbound subscription","pubsub_basicsubcpp.out")
ret3 = start_app("basicpubcpp","pub",stdout=basicpubcpp_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("EXIT", "pubsub_basicsubcpp.out")
ret5 = call_comparelog("pubsub_expectedsubcpp.out","pubsub_basicsubcpp.out")
basicsubcpp_out.close()
basicsubcpp_err.close()
basicpubcpp_out.close()
if ret1.poll() is None:
kill_process(ret1.pid)
if ret3.poll() is None:
kill_process(ret3.pid)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_active_activec(self):
'''start two basicftmemberc and verify that both go to active, if they belong to different groups'''
my_print(
"\n---------------Running basicftmemberc test active-active--------------\n"
)
ftmemberc1_out = open('active_active_ftmemberc1.out', 'w')
ftmemberc2_out = open('active_active_ftmemberc2.out', 'w')
ret1 = start_app("basicftmemberc",
"pub",
args=["-g", "active-active1", "-b"],
stdout=ftmemberc1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active",
"active_active_ftmemberc1.out")
ret3 = start_app("basicftmemberc",
"sub",
args=["-g", "active-active2", "-b"],
stdout=ftmemberc2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is active",
"active_active_ftmemberc2.out")
ret5 = call_wait4text("Current state is standby",
"active_active_ftmemberc1.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 1)
def test_req_replycpp(self):
'''Send request from basicinboxcpp and verify it recives reply from basicpubcpp'''
my_print("\n----------Running req_replycpp test----------\n")
basicpubcpp_out = open('req_reply_basicpubcpp.out','w')
basicpubcpp_err = open('req_reply_basicpubcpp.err','w')
basicinboxcpp_out = open('req_reply_basicinboxcpp.out','w')
ret1 = start_app("basicpubcpp","pub",args=["-v","-v","-v","-v"],stdout=basicpubcpp_out,stderr=basicpubcpp_err)
ret2 = call_wait4text("Created inbound subscription","req_reply_basicpubcpp.out",args=["-t",'1'])
ret3 = start_app("basicinboxcpp","sub",stdout=basicinboxcpp_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Received reply", "req_reply_basicinboxcpp.out")
basicpubcpp_out.close()
basicpubcpp_err.close()
basicinboxcpp_out.close()
kill_process(ret3.pid)
self.assertTrue(ret4==0)
def test_ft_prioritycpp(self):
'''start two basicftmembercpp with different priority and verify that the one with lower priority goes to standby
from active'''
my_print("\n----------Running basicftmemberpp test priority----------\n")
ftmembercpp1_out = open('priority_ftmembercpp1.out','w')
ftmembercpp2_out = open('priority_ftmembercpp2.out','w')
ret1 =start_app("basicftmembercpp","pub",args=["-g","priority","-w","40","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active", "priority_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp","sub",args=["-g","priority","-w","60","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: active", "priority_ftmembercpp2.out")
ret5 = call_wait4text("Current state is: standby", "priority_ftmembercpp1.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_active_standbycpp(self):
'''start two basicftmembercpp and verify the first one goes to active and second to standby, if both belong to same group'''
my_print("\n----------Running basicftmembercpp test active-standby----------\n")
ftmembercpp1_out = open('active_standby_ftmembercpp1.out','w')
ftmembercpp2_out = open('active_standby_ftmembercpp2.out','w')
ret1 = start_app("basicftmembercpp","pub",args=["-g","active-standby","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active", "active_standby_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp","sub",args=["-g","active-standby","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: standby", "active_standby_ftmembercpp2.out")
ret5 = call_wait4text("Current state is: standby", "active_standby_ftmembercpp1.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==1)
def test_ft_active_activecpp(self):
'''start two basicftmembercpp and verify that both go to active, if they belong to different groups'''
my_print("\n----------Running basicftmemberpp test active-active----------\n")
ftmembercpp1_out = open('active_active_ftmembercpp1.out','w')
ftmembercpp2_out = open('active_active_ftmembercpp2.out','w')
ret1 = start_app("basicftmembercpp","pub",args=["-g","active-active1","-b"],stdout=ftmembercpp1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active", "active_active_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp","sub",args=["-g","active-active2","-b"],stdout=ftmembercpp2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: active", "active_active_ftmembercpp2.out")
ret5 = call_wait4text("Current state is: standby", "active_active_ftmembercpp1.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==1)
def test_ft_standby_to_activec(self):
'''Start two basicftmemberc with same group and stop the active one, verify the standby basicftmember goes to active'''
my_print("\n-------------Running basicftmemberc test standby-to-active------------\n")
ftmemberc1_out = open('standby_to_active_ftmemberc1.out','w')
ftmemberc2_out = open('standby_to_active_ftmemberc2.out','w')
ret1 = start_app("basicftmemberc","pub",args=["-g","standby-to-active","-b"],stdout=ftmemberc1_out,stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is active", "standby_to_active_ftmemberc1.out")
ret3 = start_app("basicftmemberc","sub",args=["-g","standby-to-active","-b"],stdout=ftmemberc2_out,stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is standby", "standby_to_active_ftmemberc2.out")
kill_process(ret1.pid)
ret5 = call_wait4text("Current state is active", "standby_to_active_ftmemberc2.out")
ftmemberc1_out.close()
ftmemberc2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2==0)
self.assertTrue(ret4==0)
self.assertTrue(ret5==0)
def test_ft_standby_to_activecpp(self):
'''Start two basicftmembercpp with same group and stop the active one, verify the standby basicftmemberpp goes to active'''
my_print(
"\n----------Running basicftmemberpp test standby-to-active----------\n"
)
ftmembercpp1_out = open('standby_to_active_ftmembercpp1.out', 'w')
ftmembercpp2_out = open('standby_to_active_ftmembercpp2.out', 'w')
ret1 = start_app("basicftmembercpp",
"pub",
args=["-g", "standby-to-active", "-b"],
stdout=ftmembercpp1_out,
stderr=subprocess.STDOUT)
ret2 = call_wait4text("Current state is: active",
"standby_to_active_ftmembercpp1.out")
ret3 = start_app("basicftmembercpp",
"sub",
args=["-g", "standby-to-active", "-b"],
stdout=ftmembercpp2_out,
stderr=subprocess.STDOUT)
ret4 = call_wait4text("Current state is: standby",
"standby_to_active_ftmembercpp2.out")
kill_process(ret1.pid)
ret5 = call_wait4text("Current state is: active",
"standby_to_active_ftmembercpp2.out")
ftmembercpp1_out.close()
ftmembercpp2_out.close()
kill_process(ret1.pid)
kill_process(ret3.pid)
self.assertTrue(ret2 == 0)
self.assertTrue(ret4 == 0)
self.assertTrue(ret5 == 0)
def k8s_flannel__k8s_service(self):
# 创建flannel服务支持:环境变量，配置文件，local volume，日志文件，部署到指定机器
if self.haproxy:
test_flag = True
ret1 = get_haproxy(self.haproxy)
self.assert_successful(ret1)
k8sFlannelData = data.ServiceData(
self.k8s_flannel_service,
self.namespace,
settings.SERVICE_CLAAS_REGION[0],
lb_type='haproxy',
alb_name=self.haproxy,
lb_id=ret1['haproxy_id'],
node_tag=self.node_tag.split(":")[1],
mipn_enabled=True)
#创建服务支持 环境变量 local volume，配置文件，指定日志文件，部署在指定的机器上 block后面操作
ret2 = create_service(self.k8s_flannel_service,
k8sFlannelData.k8s_flannel_service(),
settings.SERVICE_CLAAS_REGION[0])
self.assert_successful(ret2)
#验证服务是否可以访问 失败可以继续后面测试
ret3 = access_service(self.k8s_flannel_service, self.haproxy)
if not ret3['success']:
test_flag = False
#验证环境变量是否添加进去 失败可以继续后面测试
ret4 = exec_feature(self.k8s_flannel_service,
self.namespace,
command="env",
commands_string="k8s_key=k8s_value")
if not ret4['success']:
test_flag = False
#验证配置文件是否添加进去 失败可以继续后面测试
ret5 = exec_feature(self.k8s_flannel_service,
self.namespace,
command="'cat /home/abc'",
commands_string="config")
if not ret5['success']:
test_flag = False
#判断存储卷类型 不阻塞后面的测试
ret6 = verify_volumes(self.k8s_flannel_service, "host_path")
if not ret6['success']:
test_flag = False
#判断是否有Metrics 不阻塞后面的测试
ret7 = get_metrics(self.k8s_flannel_service)
if not ret7['success']:
test_flag = False
# 停止服务 如果失败block后面操作
ret8 = stop_app(self.k8s_flannel_service)
self.assert_successful(ret8)
#启动服务 如果失败block 后面操作
ret9 = start_app(self.k8s_flannel_service, num=1)
self.assert_successful(ret9)
#scale up 服务，更新服务的数量和size，失败block后面操作
ret10 = update_service(self.k8s_flannel_service, num=2, size="XS")
self.assert_successful(ret10)
#check 所有的容器都部署在指定的机器上 不阻塞后面的测试
ret11 = check_node(self.k8s_flannel_service, self.node_tag)
if not ret11['success']:
test_flag = False
# scale down 服务更新服务的数量和size 失败block后面操作
ret12 = update_service(self.k8s_flannel_service, num=1, size="XXS")
self.assert_successful(ret12)
# check 所有的容器都部署在指定的机器上 不阻塞后面的测试
ret13 = check_node(self.k8s_flannel_service, self.node_tag)
if not ret13['success']:
test_flag = False
# check 服务的日志
ret14 = get_logs(self.k8s_flannel_service)
if not ret14['success']:
test_flag = False
#check 日志文件
ret15 = get_logfile(self.k8s_flannel_service)
if not ret15['success']:
test_flag = False
#删除服务
ret16 = delete_app(self.k8s_flannel_service,
settings.SERVICE_CLAAS_REGION[0])
if not ret16['success']:
test_flag = False
result = {
'success': test_flag,
"get haproxy id ": ret1,
"create k8s haproxy service": ret2,
"access sercie ": ret3,
"get service env": ret4,
"get servie config": ret5,
"get service volume type": ret6,
"get service metrics": ret7,
"stop service": ret8,
"start service": ret9,
"scale up service": ret10,
"check instance in node": ret11,
"scale down service": ret12,
"check instance in node": ret13,
"get service log": ret14,
"get service logfile": ret15,
"delete service": ret16
}
self.assert_successful(result)
return result
def inner_elb_service_test__k8s_service(self):
test_flag = True
# 创建一个内网的ELB 失败返回
ret1 = create_alb(self.k8s_internal_elb,
create_type='manual',
type='elb',
alb_region=settings.SERVICE_CLAAS_REGION[0],
address_type="internal")
self.assert_successful(ret1)
elb_data = data.ServiceData(self.k8s_innerelb_service,
settings.CLAAS_NAMESPACE,
settings.SERVICE_CLAAS_REGION[0],
lb_type='elb',
alb_name=self.k8s_internal_elb,
lb_id=ret1['id'])
# 创建一个使用ELB网络模式的服务 失败返回
ret2 = create_service(self.k8s_innerelb_service,
elb_data.k8s_innerelb_service(),
settings.SERVICE_CLAAS_REGION[0])
self.assert_successful(ret2)
# 验证服务是否可以访问 失败继续测试
ret3 = access_service(self.k8s_innerelb_service, self.k8s_internal_elb)
if not ret3['success']:
test_flag = False
# 验证环境变量是否添加进去 失败可以继续后面测试
ret4 = exec_feature(self.k8s_innerelb_service,
self.namespace,
command="'/bin/ls /'")
if not ret4['success']:
test_flag = False
# 判断是否有Metrics 不阻塞后面的测试
ret5 = get_metrics(self.k8s_innerelb_service)
if not ret5['success']:
test_flag = False
# 停止服务 如果失败block后面操作
ret6 = stop_app(self.k8s_innerelb_service)
self.assert_successful(ret6)
# 启动服务 如果失败block 后面操作
ret7 = start_app(self.k8s_innerelb_service, num=1)
self.assert_successful(ret7)
# scale up 服务，更新服务的数量和size，失败block后面操作
ret8 = update_service(self.k8s_innerelb_service, num=2, size="XS")
self.assert_successful(ret8)
# scale down 服务更新服务的数量和size 失败block后面操作
ret9 = update_service(self.k8s_innerelb_service, num=1, size="XXS")
self.assert_successful(ret9)
# check 服务的日志
# ret10 = get_logs(self.k8s_innerelb_service)
# if not ret10['success']:
# test_flag = False
ret11 = delete_alb(self.k8s_innerelb_service)
self.assert_successful(ret11)
ret12 = delete_app(self.k8s_innerelb_service)
self.assert_successful(ret12)
result = {
'success': test_flag,
"create elb": ret1,
"create elb service": ret2,
"access service": ret3,
"service exec ": ret4,
"get metrics": ret5,
"stop service": ret6,
"start service": ret7,
"scale up service": ret8,
"scale down service": ret9,
# "get logs": ret10,
"delete elb": ret11,
"delete service": ret12
}
self.assert_successful(result)
return result
def k8s_host__k8s_service(self):
if self.haproxy:
#设置flag
test_flag = True
#创建部署服务需要的环境变量文件 创建失败就直接返回
ret1 = create_envs(self.k8s_envfile)
self.assert_successful(ret1)
#创建部署服务需要的glustfs存储卷，创建失败直接返回
ret2 = create_volume(self.gluster_name, 'glusterfs', None)
self.assert_successful(ret2)
#获取当前所在集群的Haproxy信息，获取失败直接返回
ret3 = get_haproxy(self.haproxy)
self.assert_successful(ret3)
#获取创建服务需要的数据
k8sFlannelData = data.ServiceData(self.k8s_host_service,
self.namespace,
settings.SERVICE_CLAAS_REGION[0],
lb_type='haproxy',
alb_name=self.haproxy,
lb_id=ret3['haproxy_id'],
volume_id=ret2['volume_id'],
volume_name=self.gluster_name,
envfile=self.k8s_envfile)
#创建Host模式挂载环境变量文件和glustfs存储卷的服务
ret4 = create_service(self.k8s_host_service,
k8sFlannelData.k8s_host_service(),
settings.SERVICE_CLAAS_REGION[0])
if not ret4["success"]:
delete_volume(ret2['volume_id'], self.gluster_name)
self.assert_successful(ret4)
#访问服务，及时失败也可以继续执行测试
ret5 = access_service(self.k8s_host_service, self.haproxy)
if not ret5['success']:
test_flag = False
# 验证环境变量是否添加进去 失败可以继续后面测试
ret6 = exec_feature(self.k8s_host_service,
self.namespace,
command="env",
commands_string="key=value")
if not ret6['success']:
test_flag = False
# 验证volume id是否一致
ret7 = verify_volumes(self.k8s_host_service, ret2['volume_id'])
if not ret7['success']:
test_flag = False
# 判断是否有Metrics 不阻塞后面的测试
ret8 = get_metrics(self.k8s_host_service)
if not ret8['success']:
test_flag = False
# 停止服务 如果失败block后面操作
ret9 = stop_app(self.k8s_host_service)
self.assert_successful(ret9)
# 启动服务 如果失败block 后面操作
ret10 = start_app(self.k8s_host_service, num=1)
self.assert_successful(ret10)
# scale up 服务，更新服务的数量和size，失败block后面操作
ret11 = update_service(self.k8s_host_service, num=2, size="XS")
self.assert_successful(ret11)
# scale down 服务更新服务的数量和size 失败block后面操作
ret12 = update_service(self.k8s_host_service, num=1, size="XXS")
self.assert_successful(ret12)
# check 服务的日志
ret13 = get_logs(self.k8s_host_service)
if not ret13['success']:
test_flag = False
ret14 = delete_app(self.k8s_host_service,
settings.SERVICE_CLAAS_REGION[0])
if not ret14['success']:
test_flag = False
#删除volume
sleep(30)
delete_volume(ret2['volume_id'], self.gluster_name)
result = {
'success': test_flag,
"create envfile ": ret1,
"create glustfs volume": ret2,
"get haproxy id ": ret3,
"create service": ret4,
"access service": ret5,
"check envfile": ret6,
"check volume": ret7,
"check metrics": ret8,
"stop service": ret9,
"start service": ret10,
"scale up": ret11,
"scale down": ret12,
"check log": ret13,
"delete service": ret14
}
self.assert_successful(result)
return result
